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

Complete comment translation of gerbview source.

This commit is contained in:
stambaughw 2009-11-09 14:00:22 +00:00
parent 8b3ffe7412
commit 3c7df7b75d
27 changed files with 1436 additions and 1580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
gerbview/block.cpp
View File

@ -1,6 +1,6 @@
/*****************************************************************/
/* Operations sur Blocks : deplacement, rotation, effacement ... */
/*****************************************************************/
/**********************************************************/
/* Block operations: displacement, rotation, deletion ... */
/**********************************************************/
#include "fctsys.h"
@ -16,21 +16,18 @@
#define BLOCK_COLOR BROWN
/* Routines Locales */
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel,
wxDC* DC,
bool erase );
static TRACK* IsSegmentInBox( BLOCK_SELECTOR& blocklocate, TRACK* PtSegm );
static TRACK* IsSegmentInBox( BLOCK_SELECTOR& blocklocate, TRACK* PtSegm );
/* Variables locales :*/
/*************************************************/
int WinEDA_GerberFrame::ReturnBlockCommand( int key )
/*************************************************/
/* Return the block command (BLOCK_MOVE, BLOCK_COPY...) corresponding to
* the key (ALT, SHIFT ALT ..)
*/
int WinEDA_GerberFrame::ReturnBlockCommand( int key )
{
int cmd = 0;
@ -67,23 +64,22 @@ int WinEDA_GerberFrame::ReturnBlockCommand( int key )
}
/*****************************************************/
/* Routine to handle the BLOCK PLACE command */
void WinEDA_GerberFrame::HandleBlockPlace( wxDC* DC )
/*****************************************************/
/* Routine to handle the BLOCK PLACE commande */
{
bool err = FALSE;
if( DrawPanel->ManageCurseur == NULL )
{
err = TRUE;
DisplayError( this, wxT( "Error in HandleBlockPLace : ManageCurseur = NULL" ) );
DisplayError( this,
wxT( "Error in HandleBlockPLace : ManageCurseur = NULL" ) );
}
GetScreen()->m_BlockLocate.m_State = STATE_BLOCK_STOP;
switch( GetScreen()->m_BlockLocate.m_Command )
{
case BLOCK_IDLE:
case BLOCK_IDLE:
err = TRUE;
break;
@ -121,7 +117,7 @@ void WinEDA_GerberFrame::HandleBlockPlace( wxDC* DC )
GetScreen()->SetModify();
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
GetScreen()->m_BlockLocate.m_Flags = 0;
GetScreen()->m_BlockLocate.m_State = STATE_NO_BLOCK;
GetScreen()->m_BlockLocate.m_Command = BLOCK_IDLE;
@ -135,16 +131,13 @@ void WinEDA_GerberFrame::HandleBlockPlace( wxDC* DC )
}
/**********************************************/
int WinEDA_GerberFrame::HandleBlockEnd( wxDC* DC )
/**********************************************/
/* Routine de gestion de la commande BLOCK END
* returne :
* 0 si aucun compos ant selectionne
* 1 sinon
* -1 si commande terminée et composants trouvés (block delete, block save)
/* Routine management command END BLOCK
* Returns:
* 0 if no and selects compounds
* 1 otherwise
* -1 If order is completed and components found (block delete, block save)
*/
int WinEDA_GerberFrame::HandleBlockEnd( wxDC* DC )
{
int endcommande = TRUE;
bool zoom_command = FALSE;
@ -153,14 +146,15 @@ int WinEDA_GerberFrame::HandleBlockEnd( wxDC* DC )
switch( GetScreen()->m_BlockLocate.m_Command )
{
case BLOCK_IDLE:
case BLOCK_IDLE:
DisplayError( this, wxT( "Error in HandleBlockPLace" ) );
break;
case BLOCK_DRAG: /* Drag (not used, for future enhancements)*/
case BLOCK_DRAG: /* Drag (not used, for future
* enhancements) */
case BLOCK_MOVE: /* Move */
case BLOCK_COPY: /* Copy */
case BLOCK_PRESELECT_MOVE: /* Move with preselection list*/
case BLOCK_PRESELECT_MOVE: /* Move with preselection list */
GetScreen()->m_BlockLocate.m_State = STATE_BLOCK_MOVE;
endcommande = FALSE;
DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
@ -220,49 +214,57 @@ int WinEDA_GerberFrame::HandleBlockEnd( wxDC* DC )
}
/**************************************************************************/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
/**************************************************************************/
/* Retrace le contour du block de repositionnement des structures a déplacer
/* Traces the outline of the block structures of a repositioning move
*/
static void DrawMovingBlockOutlines( WinEDA_DrawPanel* panel,
wxDC* DC,
bool erase )
{
int Color;
BASE_SCREEN* screen = panel->GetScreen();
Color = YELLOW;
/* Effacement ancien cadre */
if( erase )
{
screen->m_BlockLocate.Draw( panel, DC, wxPoint(0,0),g_XorMode, Color );
if( screen->m_BlockLocate.m_MoveVector.x || screen->m_BlockLocate.m_MoveVector.y )
screen->m_BlockLocate.Draw( panel, DC, wxPoint( 0, 0 ), g_XorMode,
Color );
if( screen->m_BlockLocate.m_MoveVector.x
|| screen->m_BlockLocate.m_MoveVector.y )
{
screen->m_BlockLocate.Draw( panel, DC, screen->m_BlockLocate.m_MoveVector,g_XorMode, Color );
screen->m_BlockLocate.Draw( panel,
DC,
screen->m_BlockLocate.m_MoveVector,
g_XorMode,
Color );
}
}
if( panel->GetScreen()->m_BlockLocate.m_State != STATE_BLOCK_STOP )
{
screen->m_BlockLocate.m_MoveVector.x = screen->m_Curseur.x - screen->m_BlockLocate.GetRight();
screen->m_BlockLocate.m_MoveVector.y = screen->m_Curseur.y - screen->m_BlockLocate.GetBottom();
screen->m_BlockLocate.m_MoveVector.x = screen->m_Curseur.x -
screen->m_BlockLocate.GetRight();
screen->m_BlockLocate.m_MoveVector.y = screen->m_Curseur.y -
screen->m_BlockLocate.GetBottom();
}
screen->m_BlockLocate.Draw( panel, DC, wxPoint(0,0),g_XorMode, Color );
if( screen->m_BlockLocate.m_MoveVector.x || screen->m_BlockLocate.m_MoveVector.y )
screen->m_BlockLocate.Draw( panel, DC, wxPoint( 0, 0 ), g_XorMode, Color );
if( screen->m_BlockLocate.m_MoveVector.x
|| screen->m_BlockLocate.m_MoveVector.y )
{
screen->m_BlockLocate.Draw( panel, DC, screen->m_BlockLocate.m_MoveVector,g_XorMode, Color );
screen->m_BlockLocate.Draw( panel,
DC,
screen->m_BlockLocate.m_MoveVector,
g_XorMode,
Color );
}
}
/************************************************/
void WinEDA_GerberFrame::Block_Delete( wxDC* DC )
/************************************************/
/*
* routine d'effacement du block deja selectionne
* Erase the selected block.
*/
void WinEDA_GerberFrame::Block_Delete( wxDC* DC )
{
if( !IsOK( this, _( "Ok to delete block ?" ) ) )
return;
@ -271,43 +273,38 @@ void WinEDA_GerberFrame::Block_Delete( wxDC* DC )
GetScreen()->m_BlockLocate.Normalize();
GetScreen()->SetCurItem( NULL );
/* Effacement des Pistes */
TRACK* pt_segm, * NextS;
for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = NextS )
{
NextS = pt_segm->Next();
if( IsSegmentInBox( GetScreen()->m_BlockLocate, pt_segm ) )
{
/* la piste est ici bonne a etre efface */
/* the track here is good to be cleared */
pt_segm->Draw( DrawPanel, DC, GR_XOR );
pt_segm->DeleteStructure();
}
}
/* Effacement des Zones */
/* Erasing areas. */
for( pt_segm = m_Pcb->m_Zone; pt_segm != NULL; pt_segm = NextS )
{
NextS = pt_segm->Next();
if( IsSegmentInBox( GetScreen()->m_BlockLocate, pt_segm ) )
{
/* la piste est ici bonne a etre efface */
/* The track here is good to be cleared. */
pt_segm->Draw( DrawPanel, DC, GR_XOR );
pt_segm->DeleteStructure();
}
}
/* Rafraichissement de l'ecran : */
RedrawActiveWindow( DC, TRUE );
}
/************************************************/
void WinEDA_GerberFrame::Block_Move( wxDC* DC )
/************************************************/
/*
* Function to move items in the current selected block
*/
void WinEDA_GerberFrame::Block_Move( wxDC* DC )
{
wxPoint delta;
wxPoint oldpos;
@ -320,7 +317,7 @@ void WinEDA_GerberFrame::Block_Move( wxDC* DC )
GetScreen()->SetModify();
GetScreen()->m_BlockLocate.Normalize();
/* calcul du vecteur de deplacement pour les deplacements suivants */
/* Calculate displacement vectors. */
delta = GetScreen()->m_BlockLocate.m_MoveVector;
/* Move the Track segments in block */
@ -333,9 +330,10 @@ void WinEDA_GerberFrame::Block_Move( wxDC* DC )
track->Draw( DrawPanel, DC, GR_XOR ); // erase the display
track->m_Start += delta;
track->m_End += delta;
// the two parameters are used in gerbview to store centre coordinates for arcs.
// move this centre
track->m_Param += delta.x;
// the two parameters are used in gerbview to store center
// coordinates for arcs. Move this center.
track->m_Param += delta.x;
track->SetSubNet( track->GetSubNet() + delta.y );
track->Draw( DrawPanel, DC, GR_OR ); // redraw the moved track
@ -344,7 +342,7 @@ void WinEDA_GerberFrame::Block_Move( wxDC* DC )
}
/* Move the Zone segments in block */
SEGZONE * zsegment= m_Pcb->m_Zone;
SEGZONE* zsegment = m_Pcb->m_Zone;
while( zsegment )
{
if( IsSegmentInBox( GetScreen()->m_BlockLocate, zsegment ) )
@ -352,11 +350,13 @@ void WinEDA_GerberFrame::Block_Move( wxDC* DC )
zsegment->Draw( DrawPanel, DC, GR_XOR ); // erase the display
zsegment->m_Start += delta;
zsegment->m_End += delta;
// the two parameters are used in gerbview to store centre coordinates for arcs.
// move this centre
zsegment->m_Param += delta.x;
// the two parameters are used in gerbview to store center
// coordinates for arcs. Move this center
zsegment->m_Param += delta.x;
zsegment->SetSubNet( zsegment->GetSubNet() + delta.y );
zsegment->Draw( DrawPanel, DC, GR_OR ); // redraw the moved zone zegment
zsegment->Draw( DrawPanel, DC, GR_OR ); // redraw the moved zone
// segment
}
zsegment = zsegment->Next();
}
@ -365,13 +365,10 @@ void WinEDA_GerberFrame::Block_Move( wxDC* DC )
}
/************************************************/
void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
/************************************************/
/*
* Function to mirror items in the current selected block
*/
void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
{
int xoffset = 0;
wxPoint oldpos;
@ -385,11 +382,12 @@ void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
GetScreen()->m_BlockLocate.Normalize();
/* Calculate offset to mirror track points from block edges */
xoffset = GetScreen()->m_BlockLocate.m_Pos.x + GetScreen()->m_BlockLocate.m_Pos.x
xoffset = GetScreen()->m_BlockLocate.m_Pos.x
+ GetScreen()->m_BlockLocate.m_Pos.x
+ GetScreen()->m_BlockLocate.m_Size.x;
/* Move the Track segments in block */
for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
{
if( IsSegmentInBox( GetScreen()->m_BlockLocate, track ) )
{
@ -398,15 +396,17 @@ void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
track->m_Start.x = xoffset - track->m_Start.x;
track->m_End.x = xoffset - track->m_End.x;
// the two parameters are used in gerbview to store centre coordinates for arcs.
// move this centre
// the two parameters are used in gerbview to store center
// coordinates for arcs. Move this center
track->m_Param = xoffset - track->m_Param;
track->Draw( DrawPanel, DC, GR_OR ); // redraw the moved track
}
}
/* Move the Zone segments in block */
for( SEGZONE* zsegment = m_Pcb->m_Zone; zsegment; zsegment = zsegment->Next() )
for( SEGZONE* zsegment = m_Pcb->m_Zone;
zsegment;
zsegment = zsegment->Next() )
{
if( IsSegmentInBox( GetScreen()->m_BlockLocate, zsegment ) )
{
@ -414,10 +414,11 @@ void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
zsegment->m_Start.x = xoffset - zsegment->m_Start.x;
zsegment->m_End.x = xoffset - zsegment->m_End.x;
// the two parameters are used in gerbview to store centre coordinates for arcs.
// move this centre
// the two parameters are used in gerbview to store center
// coordinates for arcs. Move this center
zsegment->m_Param = xoffset - zsegment->m_Param;
zsegment->Draw( DrawPanel, DC, GR_OR ); // redraw the moved zone zegment
zsegment->Draw( DrawPanel, DC, GR_OR ); // redraw the moved zone
// segment
}
}
@ -425,15 +426,12 @@ void WinEDA_GerberFrame::Block_Mirror_X( wxDC* DC )
}
/**************************************************/
void WinEDA_GerberFrame::Block_Duplicate( wxDC* DC )
/**************************************************/
/*
* Function to duplicate items in the current selected block
*/
void WinEDA_GerberFrame::Block_Duplicate( wxDC* DC )
{
wxPoint delta;
wxPoint delta;
wxPoint oldpos;
oldpos = GetScreen()->m_Curseur;
@ -444,8 +442,6 @@ void WinEDA_GerberFrame::Block_Duplicate( wxDC* DC )
GetScreen()->SetModify();
GetScreen()->m_BlockLocate.Normalize();
/* calcul du vecteur de deplacement pour les deplacements suivants */
delta = GetScreen()->m_BlockLocate.m_MoveVector;
/* Copy selected track segments and move the new track its new location */
@ -464,41 +460,40 @@ void WinEDA_GerberFrame::Block_Duplicate( wxDC* DC )
new_track->m_Start += delta;
new_track->m_End += delta;
new_track->Draw( DrawPanel, DC, GR_OR ); // draw the new created segment
new_track->Draw( DrawPanel, DC, GR_OR ); // draw the new created
// segment
}
track = next_track;
}
/* Copy the Zone segments and move the new segment to its new location */
SEGZONE * zsegment= m_Pcb->m_Zone;
SEGZONE* zsegment = m_Pcb->m_Zone;
while( zsegment )
{
SEGZONE * next_zsegment = zsegment->Next();
SEGZONE* next_zsegment = zsegment->Next();
if( IsSegmentInBox( GetScreen()->m_BlockLocate, zsegment ) )
{
/* this zone segment must be duplicated */
SEGZONE * new_zsegment = (SEGZONE*) zsegment->Copy();
SEGZONE* new_zsegment = (SEGZONE*) zsegment->Copy();
m_Pcb->Add( new_zsegment );
new_zsegment->m_Start += delta;
new_zsegment->m_End += delta;
new_zsegment->Draw( DrawPanel, DC, GR_OR ); // draw the new created segment
new_zsegment->Draw( DrawPanel, DC, GR_OR ); // draw the new created
// segment
}
zsegment = next_zsegment;
}
}
/**************************************************************************/
static TRACK* IsSegmentInBox( BLOCK_SELECTOR& blocklocate, TRACK* PtSegm )
/**************************************************************************/
/* Teste si la structure PtStruct est inscrite dans le block selectionne
* Retourne PtSegm si oui
* NULL si non
/* Test if the structure PtStruct is listed in the block selects
* Returns whether PtSegm
* NULL if not
*/
static TRACK* IsSegmentInBox( BLOCK_SELECTOR& blocklocate, TRACK* PtSegm )
{
if( blocklocate.Inside( PtSegm->m_Start.x, PtSegm->m_Start.y ) )
return PtSegm;

36
gerbview/controle.cpp
View File

@ -1,12 +1,6 @@
/********************************************************/
/* Routines generales de gestion des commandes usuelles */
/********************************************************/
/* fichier controle.cpp */
/*
* Routines d'affichage grille, Boite de coordonnees, Curseurs, marqueurs ...
*/
/****************/
/* controle.cpp */
/****************/
#include "fctsys.h"
#include "common.h"
@ -17,25 +11,13 @@
#include "protos.h"
/**********************************************************************/
BOARD_ITEM* WinEDA_GerberFrame::GerberGeneralLocateAndDisplay()
/**********************************************************************/
{
return Locate( CURSEUR_OFF_GRILLE );
}
/****************************************************************/
void WinEDA_GerberFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
/****************************************************************/
/* traitement des touches de fonctions utilisees ds tous les menus
* Zoom
* Redessin d'ecran
* Cht Unites
* Cht couches
* Remise a 0 de l'origine des coordonnees relatives
*/
{
wxRealPoint delta;
wxPoint curpos, oldpos;
@ -68,25 +50,25 @@ void WinEDA_GerberFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
switch( g_KeyPressed )
{
case WXK_NUMPAD8: /* Deplacement curseur vers le haut */
case WXK_NUMPAD8:
case WXK_UP:
Mouse.y -= wxRound(delta.y);
DrawPanel->MouseTo( Mouse );
break;
case WXK_NUMPAD2: /* Deplacement curseur vers le bas */
case WXK_NUMPAD2:
case WXK_DOWN:
Mouse.y += wxRound(delta.y);
DrawPanel->MouseTo( Mouse );
break;
case WXK_NUMPAD4: /* Deplacement curseur vers la gauche */
case WXK_NUMPAD4:
case WXK_LEFT:
Mouse.x -= wxRound(delta.x);
DrawPanel->MouseTo( Mouse );
break;
case WXK_NUMPAD6: /* Deplacement curseur vers la droite */
case WXK_NUMPAD6:
case WXK_RIGHT:
Mouse.x += wxRound(delta.x);
DrawPanel->MouseTo( Mouse );
@ -97,10 +79,8 @@ void WinEDA_GerberFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
break;
}
/* Recalcul de la position du curseur schema */
GetScreen()->m_Curseur = curpos;
/* Placement sur la grille generale */
PutOnGrid( &GetScreen()->m_Curseur );
if( oldpos != GetScreen()->m_Curseur )
@ -129,5 +109,5 @@ void WinEDA_GerberFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
}
SetToolbars();
UpdateStatusBar(); /* Affichage des coord curseur */
UpdateStatusBar();
}

306
gerbview/dcode.cpp
View File

@ -1,6 +1,6 @@
/********************************************************/
/**** Routine de lecture et visu d'un fichier GERBER ****/
/********************************************************/
/***************************/
/**** Read GERBER files ****/
/***************************/
#include "fctsys.h"
#include "common.h"
@ -14,61 +14,57 @@
#define DEFAULT_SIZE 100
/* Format Gerber : NOTES :
Fonctions preparatoires:
Gn =
G01 interpolation lineaire ( trace de droites )
G02,G20,G21 Interpolation circulaire , sens trigo < 0
G03,G30,G31 Interpolation circulaire , sens trigo > 0
G04 commentaire
G06 Interpolation parabolique
G07 Interpolation cubique
G10 interpolation lineaire ( echelle 10x )
G11 interpolation lineaire ( echelle 0.1x )
G12 interpolation lineaire ( echelle 0.01x )
G52 plot symbole reference par Dnn code
G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
G54 Selection d'outil
G55 Mode exposition photo
G56 plot symbole reference par Dnn A code
G57 affiche le symbole reference sur la console
G58 plot et affiche le symbole reference sur la console
G60 interpolation lineaire ( echelle 100x )
G70 Unites = Inches
G71 Unites = Millimetres
G74 supprime interpolation circulaire sur 360 degre, revient a G01
G75 Active interpolation circulaire sur 360 degre
G90 Mode Coordonnees absolues
G91 Mode Coordonnees Relatives
Coordonnees X,Y
X,Y sont suivies de + ou - et de m+n chiffres (non separes)
m = partie entiere
n = partie apres la virgule
formats classiques : m = 2, n = 3 (format 2.3)
m = 3, n = 4 (format 3.4)
ex:
G__ X00345Y-06123 D__*
/* Format Gerber: NOTES:
* Features history:
* Gn =
* G01 linear interpolation (right trace)
* G02, G20, G21 Circular interpolation, meaning trig < 0
* G03, G30, G31 Circular interpolation, meaning trig > 0
* G04 review
* G06 parabolic interpolation
* G07 Cubic Interpolation
* G10 linear interpolation (scale x10)
* G11 linear interpolation (0.1x range)
* G12 linear interpolation (0.01x scale)
* G52 plot symbol reference code by Dnn
* G53 plot symbol reference by Dnn; symbol rotates from -90 degrees
* G54 Selection Tool
* G55 Fashion photo exhibition
* G56 plot symbol reference code for DNN
* G57 displays the symbol link to the console
* G58 plot displays the symbol and link to the console
* G60 linear interpolation (scale x100)
* G70 Units = Inches
* G71 Units = Millimeters
* G74 circular interpolation removes 360 degree, has returned G01
* G75 circular interpolation Active 360 degree
* G90 mode absolute coordinates
* G91 Fashion Related Contacts
*
* Coordinates X, Y
* X and Y are followed by + or - and m + n digits (not separated)
* m = integer part
* n = part after the comma
* conventional formats: m = 2, n = 3 (size 2.3)
* m = 3, n = 4 (size 3.4)
* eg
* G__ X00345Y-06123 * D__
*
* Tools and D_CODES
* tool number (identification of shapes)
* 1 to 99 (Classical)
* 1 to 999
*
* D_CODES:
* D01 ... D9 = action codes:
* D01 = activating light (lower pen) when di ¿½ placement
* D02 = light extinction (lift pen) when di ¿½ placement
* D03 Flash
* D09 = VAPE Flash
* D10 ... = Indentification Tool (Opening)
*/
Outils et D_CODES
numero d'outil ( identification des formes )
1 a 99 (classique)
1 a 999
D_CODES:
D01 ... D9 = codes d'action:
D01 = activation de lumiere (baisser de plume) lors du d<EFBFBD>placement
D02 = extinction de lumiere (lever de plume) lors du d<EFBFBD>placement
D03 = Flash
D09 = VAPE Flash
D10 ... = Indentification d'outils ( d'ouvertures )
*/
/*********************************/
/* class GERBER : Methodes */
/*********************************/
GERBER::GERBER( int aLayer )
{
@ -78,7 +74,7 @@ GERBER::GERBER( int aLayer )
ResetDefaultValues();
for( unsigned ii = 0; ii < DIM( m_Aperture_List ); ii++ )
for( unsigned ii = 0; ii < DIM( m_Aperture_List ); ii++ )
m_Aperture_List[ii] = 0;
m_Pcb = 0;
@ -87,9 +83,10 @@ GERBER::GERBER( int aLayer )
GERBER::~GERBER()
{
for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
for( unsigned ii = 0; ii < DIM( m_Aperture_List ); ii++ )
{
delete m_Aperture_List[ii];
// m_Aperture_List[ii] = NULL;
}
@ -101,7 +98,7 @@ D_CODE* GERBER::GetDCODE( int aDCODE, bool create )
{
unsigned ndx = aDCODE - FIRST_DCODE;
if( ndx < (unsigned) DIM(m_Aperture_List) )
if( ndx < (unsigned) DIM( m_Aperture_List ) )
{
// lazily create the D_CODE if it does not exist.
if( create )
@ -130,20 +127,20 @@ APERTURE_MACRO* GERBER::FindApertureMacro( const APERTURE_MACRO& aLookup )
}
/******************************************/
void GERBER::ResetDefaultValues()
/******************************************/
{
m_FileName.Empty();
m_Name = wxT( "no name" ); // Layer name
m_LayerNegative = FALSE; // TRUE = Negative Layer
m_ImageNegative = FALSE; // TRUE = Negative image
m_GerbMetric = FALSE; // FALSE = Inches, TRUE = metric
m_Relative = FALSE; // FALSE = absolute Coord, RUE = relative Coord
m_NoTrailingZeros = FALSE; // True: zeros a droite supprim<69>s
m_MirorA = FALSE; // True: miror / axe A (X)
m_MirorB = FALSE; // True: miror / axe B (Y)
m_Has_DCode = FALSE; // TRUE = DCodes in file (FALSE = no DCode->
m_Relative = FALSE; // FALSE = absolute Coord, RUE =
// relative Coord
m_NoTrailingZeros = FALSE; // True: trailing zeros deleted
m_MirorA = FALSE; // True: miror / axe A (X)
m_MirorB = FALSE; // True: miror / axe B (Y)
m_Has_DCode = FALSE; // TRUE = DCodes in file (FALSE = no
// DCode->
// separate DCode file
m_Offset.x = m_Offset.y = 0; // Coord Offset
@ -151,43 +148,47 @@ void GERBER::ResetDefaultValues()
m_FmtScale.x = m_FmtScale.y = g_Default_GERBER_Format % 10;
m_FmtLen.x = m_FmtLen.y = m_FmtScale.x + (g_Default_GERBER_Format / 10);
m_LayerScale.x = m_LayerScale.y = 1.0; // scale (X et Y) pour cette layer
m_LayerScale.x = m_LayerScale.y = 1.0; // scale (X and Y) this
// layer
m_Rotation = 0;
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Linear, 90 arc, Circ.
m_360Arc_enbl = FALSE; // 360 deg circular interpolation disable
m_Current_Tool = 0; // Current Tool (Dcode) number selected
m_CommandState = 0; // donne l'etat de l'analyse des commandes gerber
m_CurrentPos.x = m_CurrentPos.y = 0; // current specified coord for plot
m_PreviousPos.x = m_PreviousPos.y = 0; // old current specified coord for plot
m_IJPos.x = m_IJPos.y = 0; // current centre coord for plot arcs & circles
m_Current_File = NULL; // File to read
m_FilesPtr = 0;
m_Transform[0][0] = m_Transform[1][1] = 1;
m_Transform[0][1] = m_Transform[1][0] = 0; // Rotation/mirror = Normal
m_PolygonFillMode = FALSE;
m_360Arc_enbl = FALSE; // 360 deg circular
// interpolation disable
m_Current_Tool = 0; // Current Tool (Dcode)
// number selected
m_CommandState = 0; // gives tate of the
// stacking order analysis
m_CurrentPos.x = m_CurrentPos.y = 0; // current specified coord
// for plot
m_PreviousPos.x = m_PreviousPos.y = 0; // old current specified
// coord for plot
m_IJPos.x = m_IJPos.y = 0; // current centre coord for
// plot arcs & circles
m_Current_File = NULL; // File to read
m_FilesPtr = 0;
m_Transform[0][0] = m_Transform[1][1] = 1;
m_Transform[0][1] = m_Transform[1][0] = 0; // Rotation/mirror = Normal
m_PolygonFillMode = FALSE;
m_PolygonFillModeState = 0;
}
/********************************************/
int GERBER::ReturnUsedDcodeNumber()
/********************************************/
{
int count = 0;
for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
for( unsigned ii = 0; ii < DIM( m_Aperture_List ); ii++ )
{
if( m_Aperture_List[ii] )
if( m_Aperture_List[ii]->m_InUse || m_Aperture_List[ii]->m_Defined )
++count;
}
return count;
}
/******************************/
void GERBER::InitToolTable()
/******************************/
{
for( int count = 0; count < MAX_TOOLS; count++ )
{
@ -200,13 +201,9 @@ void GERBER::InitToolTable()
}
/*************************/
/* Class DCODE: methodes */
/*************************/
/* Variables locales : */
/* Routines Locales */
/***************/
/* Class DCODE */
/***************/
D_CODE::D_CODE( int num_dcode )
@ -228,33 +225,45 @@ void D_CODE::Clear_D_CODE_Data()
m_Shape = APT_CIRCLE;
m_Drill.x = m_Drill.y = 0;
m_DrillShape = 0;
m_InUse = FALSE;
m_Defined = FALSE;
m_Macro = 0;
m_InUse = FALSE;
m_Defined = FALSE;
m_Macro = 0;
}
const wxChar* D_CODE::ShowApertureType( APERTURE_T aType )
{
const wxChar* ret;
switch( aType )
{
case APT_CIRCLE: ret = wxT( "Round" ); break;
case APT_LINE: ret = wxT( "Line" ); break;
case APT_RECT: ret = wxT( "Rect" ); break;
case APT_OVAL: ret = wxT( "Oval" ); break;
case APT_POLYGON: ret = wxT( "Poly" ); break;
case APT_MACRO: ret = wxT( "Macro" ); break;
default: ret = wxT( "???" ); break;
case APT_CIRCLE:
ret = wxT( "Round" ); break;
case APT_LINE:
ret = wxT( "Line" ); break;
case APT_RECT:
ret = wxT( "Rect" ); break;
case APT_OVAL:
ret = wxT( "Oval" ); break;
case APT_POLYGON:
ret = wxT( "Poly" ); break;
case APT_MACRO:
ret = wxT( "Macro" ); break;
default:
ret = wxT( "???" ); break;
}
return ret;
}
/******************************************************************************/
int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
/******************************************************************************/
{
int current_Dcode, ii, dcode_scale;
char* ptcar;
@ -276,9 +285,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
GERBER* gerber = g_GERBER_List[layer];
/* Mise a jour de l'echelle gerber : */
dcode_scale = 10; /* ici unit dcode = mil, unit interne = 0.1 mil
* -> 1 unite dcode = 10 unit PCB */
/* Updating gerber scale: */
dcode_scale = 10; /* By uniting dCode = mil, internal unit = 0.1 mil
* -> 1 unite dcode = 10 unit PCB */
current_Dcode = 0;
if( D_Code_FullFileName.IsEmpty() )
@ -297,17 +306,17 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
while( fgets( line, sizeof(line) - 1, dest ) != NULL )
{
if( *line == ';' )
continue; /* Commentaire */
continue;
if( strlen( line ) < 10 )
continue; /* Probablemant ligne vide */
continue; /* Skip blank line. */
dcode = NULL;
current_Dcode = 0;
/* Determination du type de fichier D_Code */
/* Determine of the type of file from D_Code. */
ptcar = line;
ii = 0;
ii = 0;
while( *ptcar )
if( *(ptcar++) == ',' )
ii++;
@ -315,9 +324,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
if( ii >= 6 ) /* valeurs en mils */
{
sscanf( line, "%d,%d,%d,%d,%d,%d,%d", &ii,
&dimH, &dimV, &drill,
&dummy, &dummy,
&type_outil );
&dimH, &dimV, &drill,
&dummy, &dummy,
&type_outil );
dimH = (int) ( (dimH * dcode_scale) + 0.5 );
dimV = (int) ( (dimV * dcode_scale) + 0.5 );
@ -326,7 +335,7 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
ii = 1;
current_Dcode = ii - 1 + FIRST_DCODE;
}
else /* valeurs en inches a convertir en mils */
else /* Values in inches are converted to mils. */
{
fdrill = 0;
current_Dcode = 0;
@ -344,9 +353,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
ptcar++;
}
dimH = (int) ( (fdimH * dcode_scale * 1000) + 0.5 );
dimV = (int) ( (fdimV * dcode_scale * 1000) + 0.5 );
drill = (int) ( (fdrill * dcode_scale * 1000) + 0.5 );
dimH = (int) ( (fdimH * dcode_scale * 1000) + 0.5 );
dimV = (int) ( (fdimV * dcode_scale * 1000) + 0.5 );
drill = (int) ( (fdrill * dcode_scale * 1000) + 0.5 );
if( strchr( "CLROP", c_type_outil[0] ) )
type_outil = (APERTURE_T) c_type_outil[0];
@ -357,7 +366,7 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
}
}
/* Mise a jour de la liste des d_codes si valeurs lues coherentes*/
/* Update the list of d_codes if consistant. */
if( current_Dcode < FIRST_DCODE )
continue;
@ -378,33 +387,32 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
}
/***************************************************/
void WinEDA_GerberFrame::CopyDCodesSizeToItems()
/***************************************************/
/* Set Size Items (Lines, Flashes) from DCodes List
*/
void WinEDA_GerberFrame::CopyDCodesSizeToItems()
{
static D_CODE dummy(999); //Used if D_CODE not found in list
static D_CODE dummy( 999 ); //Used if D_CODE not found in list
for( TRACK* track = GetBoard()->m_Track; track; track = track->Next() )
for( TRACK* track = GetBoard()->m_Track; track; track = track->Next() )
{
GERBER* gerber = g_GERBER_List[track->GetLayer()];
wxASSERT( gerber );
D_CODE* dcode = gerber->GetDCODE( track->GetNet(), false );
D_CODE* dcode = gerber->GetDCODE( track->GetNet(), false );
wxASSERT( dcode );
if ( dcode == NULL )
if( dcode == NULL )
dcode = &dummy;
dcode->m_InUse = TRUE;
if( // Line Item
(track->m_Shape == S_SEGMENT ) /* segment rectiligne */
|| (track->m_Shape == S_RECT ) /* segment forme rect (i.e. bouts non arrondis) */
|| (track->m_Shape == S_ARC ) /* segment en arc de cercle (bouts arrondis)*/
|| (track->m_Shape == S_CIRCLE ) /* segment en cercle (anneau)*/
|| (track->m_Shape == S_ARC_RECT ) /* segment en arc de cercle (bouts droits) (GERBER)*/
(track->m_Shape == S_SEGMENT ) /* rectilinear segment */
|| (track->m_Shape == S_RECT ) /* rect segment form (i.e.
* non-rounded ends) */
|| (track->m_Shape == S_ARC ) /* segment arc (rounded tips) */
|| (track->m_Shape == S_CIRCLE ) /* segment in a circle (ring) */
|| (track->m_Shape == S_ARC_RECT ) /* segment arc (stretches)
* (GERBER)*/
)
{
track->m_Width = dcode->m_Size.x;
@ -421,12 +429,13 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
track->m_Start.x = (track->m_Start.x + track->m_End.x) / 2;
track->m_Start.y = (track->m_Start.y + track->m_End.y) / 2;
track->m_End = track->m_Start; // m_Start = m_End = Spot center
track->m_End = track->m_Start; // m_Start = m_End = Spot center
switch( dcode->m_Shape )
{
case APT_LINE: // might not appears here, but some broken gerber files use it
case APT_CIRCLE: /* spot round (for GERBER)*/
case APT_LINE: // might not appears here, but some broken
// gerber files use it
case APT_CIRCLE: /* spot round (for GERBER) */
track->m_Shape = S_SPOT_CIRCLE;
break;
@ -455,18 +464,15 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
}
/************************************************/
void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
/************************************************/
{
int ii, jj;
D_CODE* pt_D_code;
wxString Line;
WinEDA_TextFrame* List;
int scale = 10000;
int curr_layer = GetScreen()->m_Active_Layer;
int ii, jj;
D_CODE* pt_D_code;
wxString Line;
WinEDA_TextFrame* List;
int scale = 10000;
int curr_layer = GetScreen()->m_Active_Layer;
/* Construction de la liste des messages */
List = new WinEDA_TextFrame( this, _( "List D codes" ) );
for( int layer = 0; layer < 32; layer++ )
@ -494,13 +500,13 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
continue;
Line.Printf( wxT(
"tool %2.2d: D%2.2d V %2.4f H %2.4f %s" ),
jj,
pt_D_code->m_Num_Dcode,
(float) pt_D_code->m_Size.y / scale,
(float) pt_D_code->m_Size.x / scale,
D_CODE::ShowApertureType( pt_D_code->m_Shape )
);
"tool %2.2d: D%2.2d V %2.4f H %2.4f %s" ),
jj,
pt_D_code->m_Num_Dcode,
(float) pt_D_code->m_Size.y / scale,
(float) pt_D_code->m_Size.x / scale,
D_CODE::ShowApertureType( pt_D_code->m_Shape )
);
if( !pt_D_code->m_Defined )
Line += wxT( " ?" );
@ -520,7 +526,7 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
#if 0
// Mise en surbrillance des <20>l<EFBFBD>ments correspondant au DCode s<>lectionn<6E>
// Highlight segment corresponding to dCode selected.
if( Etat_Surbrillance )
Hight_Light( DrawPanel, DC );
net_code_Surbrillance = (GetScreen()->m_Active_Layer << 16) + ii;

45
gerbview/deltrack.cpp
View File

@ -1,6 +1,6 @@
/*********************************************/
/* Edition des pistes: Routines d'effacement */
/* Effacement de segment, piste, net et zone */
/* Edit Track: Erase Routines */
/* Drop the segment, track, and net area */
/*********************************************/
#include "fctsys.h"
@ -10,22 +10,16 @@
#include "gerbview.h"
#include "protos.h"
/* Routines externes : */
/* Routines Locales */
/* Variables locales */
/****************************************************************************************/
void WinEDA_GerberFrame::Delete_DCode_Items( wxDC* DC, int dcode_value, int layer_number )
/****************************************************************************************/
void WinEDA_GerberFrame::Delete_DCode_Items( wxDC* DC,
int dcode_value,
int layer_number )
{
if( dcode_value < FIRST_DCODE ) // No tool selected
return;
TRACK* next;
for( TRACK* track = GetBoard()->m_Track; track; track = next )
for( TRACK* track = GetBoard()->m_Track; track; track = next )
{
next = track->Next();
@ -42,28 +36,26 @@ void WinEDA_GerberFrame::Delete_DCode_Items( wxDC* DC, int dcode_value, int laye
}
/*****************************************************************/
TRACK* WinEDA_GerberFrame::Delete_Segment( wxDC* DC, TRACK* Track )
/*****************************************************************/
/* Supprime 1 segment de piste.
* 2 Cas possibles:
* Si On est en trace de nouvelle piste: Effacement du segment en
* cours de trace
* Sinon : Effacment du segment sous le curseur.
/* Removes 1 segment of track.
*
* If There is evidence of new track: erase segment
* Otherwise: Delete segment under the cursor.
*/
TRACK* WinEDA_GerberFrame::Delete_Segment( wxDC* DC, TRACK* Track )
{
if( Track == NULL )
return NULL;
if( Track->m_Flags & IS_NEW ) // Trace en cours, on peut effacer le dernier segment
if( Track->m_Flags & IS_NEW ) // Trace in progress, delete the last
// segment
{
if( g_CurrentTrackList.GetCount() > 0 )
{
// modification du trace
// Change track.
delete g_CurrentTrackList.PopBack();
if( g_CurrentTrackList.GetCount() && g_CurrentTrackSegment->Type() == TYPE_VIA )
if( g_CurrentTrackList.GetCount()
&& g_CurrentTrackSegment->Type() == TYPE_VIA )
{
delete g_CurrentTrackList.PopBack();
}
@ -85,12 +77,11 @@ TRACK* WinEDA_GerberFrame::Delete_Segment( wxDC* DC, TRACK* Track )
}
return NULL;
} // Fin traitement si trace en cours
}
Trace_Segment( DrawPanel, DC, Track, GR_XOR );
DLIST<TRACK>* container = (DLIST<TRACK>*) Track->GetList();
DLIST<TRACK>* container = (DLIST<TRACK>*)Track->GetList();
wxASSERT( container );
container->Remove( Track );

61
gerbview/edit.cpp
View File

@ -1,6 +1,6 @@
/******************************************************/
/* edit.cpp: fonctions generales de l'edition du PCB */
/******************************************************/
/***********************************/
/* edit.cpp: PCB editing functions */
/***********************************/
#include "fctsys.h"
#include "class_drawpanel.h"
@ -13,21 +13,17 @@
#include "protos.h"
/************************************************************************/
void WinEDA_GerberFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
/************************************************************************/
/* Traite les commandes declench<63>e par le bouton gauche de la souris,
* quand un outil est deja selectionn<EFBFBD>
/* Process the command triggered by the left button of the mouse when a tool
* is already selected.
*/
void WinEDA_GerberFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
{
BOARD_ITEM* DrawStruct = GetScreen()->GetCurItem();
wxString msg;
BOARD_ITEM* DrawStruct = GetScreen()->GetCurItem();
wxString msg;
if( m_ID_current_state == 0 )
{
if( DrawStruct && DrawStruct->m_Flags ) // Commande "POPUP" en cours
if( DrawStruct && DrawStruct->m_Flags )
{
msg.Printf( wxT( "WinEDA_GerberFrame::ProcessCommand err: Struct %d, m_Flags = %X" ),
(unsigned) DrawStruct->Type(),
@ -70,18 +66,15 @@ void WinEDA_GerberFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
}
/********************************************************************************/
void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
/********************************************************************************/
/* Traite les selections d'outils et les commandes appelees du menu POPUP
/* Handles the selection of tools, menu, and popup menu commands.
*/
void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
{
int id = event.GetId();
int layer = GetScreen()->m_Active_Layer;
GERBER* gerber_layer = g_GERBER_List[layer];
wxPoint pos;
wxClientDC dc( DrawPanel );
int id = event.GetId();
int layer = GetScreen()->m_Active_Layer;
GERBER* gerber_layer = g_GERBER_List[layer];
wxPoint pos;
wxClientDC dc( DrawPanel );
DrawPanel->PrepareGraphicContext( &dc );
@ -89,7 +82,7 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
pos.y += 20;
switch( id ) // Arret eventuel de la commande de d<>placement en cours
switch( id )
{
case wxID_CUT:
case wxID_COPY:
@ -108,7 +101,7 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
{
DrawPanel->ForceCloseManageCurseur( DrawPanel, &dc );
}
/* ne devrait pas etre execute, sauf bug */
/* Should not be executed, except bug */
if( GetScreen()->m_BlockLocate.m_Command != BLOCK_IDLE )
{
GetScreen()->m_BlockLocate.m_Command = BLOCK_IDLE;
@ -121,7 +114,7 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
SetCursor( DrawPanel->m_PanelCursor = DrawPanel->m_PanelDefaultCursor );
break;
default: // Arret dea commande de d<>placement en cours
default:
if( DrawPanel->ManageCurseur
&& DrawPanel->ForceCloseManageCurseur )
{
@ -131,7 +124,7 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
break;
}
switch( id ) // Traitement des commandes
switch( id )
{
case ID_EXIT:
Close( TRUE );
@ -147,10 +140,12 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
break;
case ID_GET_TOOLS:
// InstallToolsFrame(this, wxPoint(-1,-1) );
break;
case ID_FIND_ITEMS:
// InstallFindFrame(this, pos);
break;
@ -249,7 +244,8 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_GERBVIEW_POPUP_DELETE_DCODE_ITEMS:
if( gerber_layer )
Delete_DCode_Items( &dc, gerber_layer->m_Selected_Tool, ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
Delete_DCode_Items( &dc, gerber_layer->m_Selected_Tool,
( (PCB_SCREEN*) GetScreen() )->m_Active_Layer );
break;
default:
@ -261,12 +257,9 @@ void WinEDA_GerberFrame::Process_Special_Functions( wxCommandEvent& event )
}
/**************************************************************************/
void WinEDA_GerberFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
/**************************************************************************/
/* Called on a double click:
/* Called on a double click of left mouse button.
*/
void WinEDA_GerberFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
{
EDA_BaseStruct* DrawStruct = GetScreen()->GetCurItem();
wxClientDC dc( DrawPanel );
@ -281,7 +274,7 @@ void WinEDA_GerberFrame::OnLeftDClick( wxDC* DC, const wxPoint& MousePos )
DrawStruct = GerberGeneralLocateAndDisplay();
}
break; // end case 0
break;
default:
break;

96
gerbview/export_to_pcbnew.cpp
View File

@ -15,21 +15,15 @@
#include "class_board_design_settings.h"
#include "protos.h"
/* Routines Locales : */
static int SavePcbFormatAscii( WinEDA_GerberFrame* frame,
FILE* File, int* LayerLookUpTable );
/* Variables Locales */
/************************************************************************/
void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
/************************************************************************/
/* Export data in pcbnew format
*/
void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
{
int ii = 0;
int ii = 0;
bool no_used_layers = true; // Changed to false if any used layer found
// Check whether any of the Gerber layers are actually currently used
@ -42,7 +36,8 @@ void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
if( no_used_layers )
{
DisplayInfoMessage( this, _( "None of the Gerber layers contain any data" ) );
DisplayInfoMessage( this,
_( "None of the Gerber layers contain any data" ) );
return;
}
@ -50,14 +45,14 @@ void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
wxString PcbExt( wxT( ".brd" ) );
FILE* dest;
FILE* dest;
msg = wxT( "*" ) + PcbExt;
FullFileName = EDA_FileSelector( _( "Board file name:" ),
wxEmptyString, /* Chemin par defaut */
wxEmptyString, /* nom fichier par defaut */
PcbExt, /* extension par defaut */
msg, /* Masque d'affichage */
wxEmptyString,
wxEmptyString,
PcbExt,
msg,
this,
wxFD_SAVE,
FALSE
@ -87,9 +82,7 @@ void WinEDA_GerberFrame::ExportDataInPcbnewFormat( wxCommandEvent& event )
}
/***************************************************************/
static int WriteSetup( FILE* File, BOARD* Pcb )
/***************************************************************/
{
char text[1024];
@ -97,22 +90,21 @@ static int WriteSetup( FILE* File, BOARD* Pcb )
sprintf( text, "InternalUnit %f INCH\n", 1.0 / PCB_INTERNAL_UNIT );
fprintf( File, "%s", text );
Pcb->m_BoardSettings->SetCopperLayerCount( g_DesignSettings.GetCopperLayerCount( ) );
fprintf( File, "Layers %d\n", g_DesignSettings.GetCopperLayerCount( ) );
Pcb->m_BoardSettings->SetCopperLayerCount(
g_DesignSettings.GetCopperLayerCount() );
fprintf( File, "Layers %d\n", g_DesignSettings.GetCopperLayerCount() );
fprintf( File, "$EndSETUP\n\n" );
return 1;
}
/******************************************************/
static bool WriteGeneralDescrPcb( BOARD* Pcb, FILE* File )
/******************************************************/
{
int NbLayers;
/* Print the copper layer count */
NbLayers = Pcb->m_BoardSettings->GetCopperLayerCount( );
NbLayers = Pcb->m_BoardSettings->GetCopperLayerCount();
fprintf( File, "$GENERAL\n" );
fprintf( File, "LayerCount %d\n", NbLayers );
@ -128,29 +120,26 @@ static bool WriteGeneralDescrPcb( BOARD* Pcb, FILE* File )
}
/*******************************************************************/
static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
int* LayerLookUpTable )
/*******************************************************************/
/* Routine to save the board
* @param frame = pointer to the main frame
* @param File = FILE * pointer to an already opened file
* @param LayerLookUpTable = look up table: pcbnew layer for each gerber layer
* @return 1 if OK, 0 if fail
*/
static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
int* LayerLookUpTable )
{
char line[256];
TRACK* track;
BOARD* gerberPcb = frame->GetBoard();
BOARD* pcb;
char line[256];
TRACK* track;
BOARD* gerberPcb = frame->GetBoard();
BOARD* pcb;
wxBeginBusyCursor();
// create an image of gerber data
pcb = new BOARD( NULL, frame );
for( track = gerberPcb->m_Track; track; track = track->Next() )
for( track = gerberPcb->m_Track; track; track = track->Next() )
{
int layer = track->GetLayer();
int pcb_layer_number = LayerLookUpTable[layer];
@ -170,29 +159,32 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
{
double cx = track->m_Param;
double cy = track->GetSubNet();
double a = atan2( track->m_Start.y-cy, track->m_Start.x-cx );
double b = atan2( track->m_End.y-cy, track->m_End.x-cx );
double a = atan2( track->m_Start.y - cy,
track->m_Start.x - cx );
double b = atan2( track->m_End.y - cy, track->m_End.x - cx );
drawitem->m_Shape = S_ARC;
drawitem->m_Angle = (int)fmod( (a-b)/M_PI*1800.0+3600.0, 3600.0 );
drawitem->m_Start.x = (int)cx;
drawitem->m_Start.y = (int)cy;
drawitem->m_Shape = S_ARC;
drawitem->m_Angle = (int) fmod(
(a - b) / M_PI * 1800.0 + 3600.0, 3600.0 );
drawitem->m_Start.x = (int) cx;
drawitem->m_Start.y = (int) cy;
}
pcb->Add( drawitem );
}
else
{
TRACK* newtrack;
TRACK* newtrack;
// replace spots with vias when possible
if( track->m_Shape == S_SPOT_CIRCLE
|| track->m_Shape == S_SPOT_RECT
|| track->m_Shape == S_SPOT_OVALE )
|| track->m_Shape == S_SPOT_RECT
|| track->m_Shape == S_SPOT_OVALE )
{
newtrack = new SEGVIA( (const SEGVIA&) *track );
newtrack = new SEGVIA( (const SEGVIA &) * track );
// A spot is found, and can be a via: change it to via, and delete other
// A spot is found, and can be a via: change it to via, and
// delete other
// spots at same location
newtrack->m_Shape = VIA_THROUGH;
@ -200,10 +192,13 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
newtrack->SetDrillDefault();
// Compute the via position from track position ( Via position is the
// Compute the via position from track position ( Via position
// is the
// position of the middle of the track segment )
newtrack->m_Start.x = (newtrack->m_Start.x + newtrack->m_End.x) / 2;
newtrack->m_Start.y = (newtrack->m_Start.y + newtrack->m_End.y) / 2;
newtrack->m_Start.x =
(newtrack->m_Start.x + newtrack->m_End.x) / 2;
newtrack->m_Start.y =
(newtrack->m_Start.y + newtrack->m_End.y) / 2;
newtrack->m_End = newtrack->m_Start;
}
else // a true TRACK
@ -217,7 +212,7 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
}
// delete redundant vias
for( track = pcb->m_Track; track; track = track->Next() )
for( track = pcb->m_Track; track; track = track->Next() )
{
if( track->m_Shape != VIA_THROUGH )
continue;
@ -225,7 +220,7 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
// Search and delete others vias
TRACK* next_track;
TRACK* alt_track = track->Next();
for( ; alt_track; alt_track = next_track )
for( ; alt_track; alt_track = next_track )
{
next_track = alt_track->Next();
if( alt_track->m_Shape != VIA_THROUGH )
@ -240,8 +235,9 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
}
}
// Switch the locale to standard C (needed to print floating point numbers like 1.3)
SetLocaleTo_C_standard( );
// Switch the locale to standard C (needed to print floating point numbers
// like 1.3)
SetLocaleTo_C_standard();
// write the PCB heading
fprintf( aFile, "PCBNEW-BOARD Version %d date %s\n\n", g_CurrentVersionPCB,
@ -255,7 +251,7 @@ static int SavePcbFormatAscii( WinEDA_GerberFrame* frame, FILE* aFile,
// the destructor should destroy all owned sub-objects
delete pcb;
SetLocaleTo_Default( ); // revert to the current locale
SetLocaleTo_Default(); // revert to the current locale
wxEndBusyCursor();
return 1;
}

136
gerbview/files.cpp
View File

@ -1,6 +1,6 @@
/******************************************************/
/* Files.cp: Lecture / Sauvegarde des fichiers gerber */
/******************************************************/
/*************/
/* files.cpp */
/*************/
#include "fctsys.h"
#include "common.h"
@ -13,8 +13,9 @@
#include "protos.h"
/* Routines locales */
static void LoadDCodeFile( WinEDA_GerberFrame* frame, const wxString& FullFileName, wxDC* DC );
static void LoadDCodeFile( WinEDA_GerberFrame* frame,
const wxString& FullFileName,
wxDC* DC );
void WinEDA_GerberFrame::OnFileHistory( wxCommandEvent& event )
@ -33,15 +34,11 @@ void WinEDA_GerberFrame::OnFileHistory( wxCommandEvent& event )
}
}
/***************
***************************************/
void WinEDA_GerberFrame::Files_io( wxCommandEvent& event )
/********************************************************/
/* Gestion generale des commandes de lecture de fichiers
*/
/* File commands. */
void WinEDA_GerberFrame::Files_io( wxCommandEvent& event )
{
int id = event.GetId();
int id = event.GetId();
wxClientDC dc( DrawPanel );
@ -58,17 +55,17 @@ void WinEDA_GerberFrame::Files_io( wxCommandEvent& event )
case ID_MENU_INC_LAYER_AND_APPEND_FILE:
case ID_INC_LAYER_AND_APPEND_FILE:
{
int origLayer = GetScreen()->m_Active_Layer;
{
int origLayer = GetScreen()->m_Active_Layer;
GetScreen()->m_Active_Layer++;
GetScreen()->m_Active_Layer++;
if( !LoadOneGerberFile( wxEmptyString, &dc, 0 ) )
GetScreen()->m_Active_Layer = origLayer;
if( !LoadOneGerberFile( wxEmptyString, &dc, 0 ) )
GetScreen()->m_Active_Layer = origLayer;
SetToolbars();
}
break;
SetToolbars();
}
break;
case ID_APPEND_FILE:
LoadOneGerberFile( wxEmptyString, &dc, 0 );
@ -106,52 +103,49 @@ void WinEDA_GerberFrame::Files_io( wxCommandEvent& event )
}
/*******************************************************************************************/
bool
WinEDA_GerberFrame::LoadOneGerberFile( const wxString& FullFileName,
wxDC* DC,
int mode )
/*******************************************************************************************/
/*
* Lecture d'un fichier PCB, le nom etant dans PcbNameBuffer.s
* retourne:
* 0 si fichier non lu ( annulation de commande ... )
* 1 si OK
* Load a PCB file.
*
* Returns:
* 0 if file not read (cancellation of order ...)
* 1 if OK
*/
bool WinEDA_GerberFrame::LoadOneGerberFile( const wxString& FullFileName,
wxDC* DC,
int mode )
{
wxString filetypes;
wxString filetypes;
wxFileName filename = FullFileName;
ActiveScreen = GetScreen();
if( !filename.IsOk() )
{
wxString current_path = filename.GetPath();
wxString current_path = filename.GetPath();
/* Standard gerber filetypes */
filetypes += _("Gerber files (.gbr .gbx .lgr .ger .pho)| \
*.gbr;*.GBR;*.gbx;*.GBX;*.lgr;*.LGR;*.ger;*.GER;*.pho;*.PHO|");
/* Standard gerber filetypes */
filetypes += _( "Gerber files (.gbr .gbx .lgr .ger .pho)| \
.gbr;*.GBR;*.gbx;*.GBX;*.lgr;*.LGR;*.ger;*.GER;*.pho;*.PHO|" );
/* Special gerber filetypes */
filetypes += _("Top layer (*.GTL)|*.GTL;*.gtl|");
filetypes += _("Bottom layer (*.GBL)|*.GBL;*.gbl|");
filetypes += _("Bottom solder resist (*.GBS)|*.GBS;*.gbs|");
filetypes += _("Top solder resist (*.GTS)|*.GTS;*.gts|");
filetypes += _("Bottom overlay (*.GBO)|*.GBO;*.gbo|");
filetypes += _("Top overlay (*.GTO)|*.GTO;*.gto|");
filetypes += _("Bottom paste (*.GBP)|*.GBP;*.gbp|");
filetypes += _("Top paste (*.GTP)|*.GTP;*.gtp|");
filetypes += _("Keep-out layer (*.GKO)|*.GKO;*.gko|");
filetypes += _("Mechanical layers (*.GMx)|*.GM1;*.gm1;*.GM2;*.gm2;*.GM3;*.gm3|");
filetypes += _("Top Pad Master (*.GPT)|*.GPT;*.gpt|");
filetypes += _("Bottom Pad Master (*.GPB)|*.GPB;*.gpb|");
/* Special gerber filetypes */
filetypes += _( "Top layer (*.GTL)|*.GTL;*.gtl|" );
filetypes += _( "Bottom layer (*.GBL)|*.GBL;*.gbl|" );
filetypes += _( "Bottom solder resist (*.GBS)|*.GBS;*.gbs|" );
filetypes += _( "Top solder resist (*.GTS)|*.GTS;*.gts|" );
filetypes += _( "Bottom overlay (*.GBO)|*.GBO;*.gbo|" );
filetypes += _( "Top overlay (*.GTO)|*.GTO;*.gto|" );
filetypes += _( "Bottom paste (*.GBP)|*.GBP;*.gbp|" );
filetypes += _( "Top paste (*.GTP)|*.GTP;*.gtp|" );
filetypes += _( "Keep-out layer (*.GKO)|*.GKO;*.gko|" );
filetypes += _( "Mechanical layers (*.GMx)|*.GM1;*.gm1;*.GM2;*.gm2;*.GM3;*.gm3|" );
filetypes += _( "Top Pad Master (*.GPT)|*.GPT;*.gpt|" );
filetypes += _( "Bottom Pad Master (*.GPB)|*.GPB;*.gpb|" );
/* All filetypes */
filetypes += AllFilesWildcard;
/* All filetypes */
filetypes += AllFilesWildcard;
/* Get current path if emtpy */
if ( current_path.IsEmpty() )
/* Get current path if emtpy */
if( current_path.IsEmpty() )
current_path = wxGetCwd();
wxFileDialog dlg( this,
@ -182,18 +176,18 @@ WinEDA_GerberFrame::LoadOneGerberFile( const wxString& FullFileName,
}
/**********************************************************************************************/
static void LoadDCodeFile( WinEDA_GerberFrame* frame, const wxString& FullFileName, wxDC* DC )
/**********************************************************************************************/
/*
* Lecture d'un fichier PCB, le nom etant dans PcbNameBuffer.s
* retourne:
* 0 si fichier non lu ( annulation de commande ... )
* 1 si OK
* Read a PCB file.
*
* Returns:
* 0 if file not read (cancellation of order ...)
* 1 if OK
*/
static void LoadDCodeFile( WinEDA_GerberFrame* frame,
const wxString& FullFileName,
wxDC* DC )
{
wxString wildcard;
wxString wildcard;
wxFileName fn = FullFileName;
ActiveScreen = frame->GetScreen();
@ -201,11 +195,12 @@ static void LoadDCodeFile( WinEDA_GerberFrame* frame, const wxString& FullFileNa
if( !fn.IsOk() )
{
wildcard.Printf( _( "Gerber DCODE files (%s)|*.%s" ),
GetChars( g_PenFilenameExt ), GetChars( g_PenFilenameExt ));
GetChars( g_PenFilenameExt ),
GetChars( g_PenFilenameExt ) );
wildcard += AllFilesWildcard;
fn = frame->GetScreen()->m_FileName;
fn.SetExt( g_PenFilenameExt );
wxFileDialog dlg( ( wxWindow* )frame, _( "Load GERBER DCODE File" ),
wxFileDialog dlg( (wxWindow*) frame, _( "Load GERBER DCODE File" ),
fn.GetPath(), fn.GetFullName(), wildcard,
wxFD_OPEN | wxFD_FILE_MUST_EXIST );
@ -221,14 +216,12 @@ static void LoadDCodeFile( WinEDA_GerberFrame* frame, const wxString& FullFileNa
}
/*******************************************************************************/
bool WinEDA_GerberFrame::SaveGerberFile( const wxString& FullFileName, wxDC* DC )
/*******************************************************************************/
/* Sauvegarde du fichier PCB en format ASCII
/* Save the file in ASCII PCB.
*/
bool WinEDA_GerberFrame::SaveGerberFile( const wxString& FullFileName,
wxDC* DC )
{
wxString wildcard;
wxString wildcard;
wxFileName fn = FullFileName;
if( !fn.IsOk() )
@ -236,7 +229,8 @@ bool WinEDA_GerberFrame::SaveGerberFile( const wxString& FullFileName, wxDC* DC
fn = GetScreen()->m_FileName;
wildcard.Printf( _( "Gerber DCODE files (%s)|*.%s" ),
GetChars( g_PenFilenameExt ), GetChars( g_PenFilenameExt ));
GetChars( g_PenFilenameExt ),
GetChars( g_PenFilenameExt ) );
wxFileDialog dlg( this, _( "Save Gerber File" ), fn.GetPath(),
fn.GetFullName(), wildcard,

85
gerbview/gerberframe.cpp
View File

@ -1,6 +1,6 @@
/******************************************************************/
/* gerberframe.cpp - fonctions des classes du type WinEDA_GerberFrame */
/******************************************************************/
/*******************/
/* gerberframe.cpp */
/*******************/
#ifdef __GNUG__
#pragma implementation
@ -94,15 +94,13 @@ BEGIN_EVENT_TABLE( WinEDA_GerberFrame, WinEDA_BasePcbFrame )
EVT_KICAD_CHOICEBOX( ID_TOOLBARH_GERBER_SELECT_TOOL,
WinEDA_GerberFrame::Process_Special_Functions )
// Vertical toolbar:
EVT_TOOL( ID_NO_SELECT_BUTT, WinEDA_GerberFrame::Process_Special_Functions )
EVT_TOOL( ID_TRACK_BUTT, WinEDA_GerberFrame::Process_Special_Functions )
EVT_TOOL( ID_PCB_ZONES_BUTT, WinEDA_GerberFrame::Process_Special_Functions )
EVT_TOOL( ID_PCB_DELETE_ITEM_BUTT,
WinEDA_GerberFrame::Process_Special_Functions )
WinEDA_GerberFrame::Process_Special_Functions )
// Annulation de commande en cours
EVT_MENU_RANGE( ID_POPUP_GENERAL_START_RANGE, ID_POPUP_GENERAL_END_RANGE,
WinEDA_GerberFrame::Process_Special_Functions )
@ -116,11 +114,6 @@ BEGIN_EVENT_TABLE( WinEDA_GerberFrame, WinEDA_BasePcbFrame )
END_EVENT_TABLE()
/****************/
/* Constructeur */
/****************/
WinEDA_GerberFrame::WinEDA_GerberFrame( wxWindow* father,
const wxString& title,
const wxPoint& pos,
@ -130,8 +123,8 @@ WinEDA_GerberFrame::WinEDA_GerberFrame( wxWindow* father,
{
m_FrameName = wxT( "GerberFrame" );
m_Draw_Axis = true; // true to show X and Y axis on screen
m_Draw_Sheet_Ref = FALSE; // TRUE pour avoir le cartouche dessin<69>
m_Draw_Axis = true; // true to show X and Y axis on screen
m_Draw_Sheet_Ref = FALSE; // TRUE for reference drawings.
if( DrawPanel )
DrawPanel->m_Block_Enable = TRUE;
@ -146,6 +139,7 @@ WinEDA_GerberFrame::WinEDA_GerberFrame( wxWindow* father,
ActiveScreen = ScreenPcb;
LoadSettings();
SetSize( m_FramePos.x, m_FramePos.y, m_FrameSize.x, m_FrameSize.y );
GetScreen()->SetGrid( ID_POPUP_GRID_LEVEL_1000 + m_LastGridSizeId );
@ -153,36 +147,37 @@ WinEDA_GerberFrame::WinEDA_GerberFrame( wxWindow* father,
ReCreateHToolbar();
ReCreateVToolbar();
ReCreateOptToolbar();
#if defined(KICAD_AUIMANAGER)
m_auimgr.SetManagedWindow(this);
m_auimgr.SetManagedWindow( this );
wxAuiPaneInfo horiz;
horiz.Gripper(false);
horiz.DockFixed(true);
horiz.Movable(false);
horiz.Floatable(false);
horiz.CloseButton(false);
horiz.CaptionVisible(false);
horiz.Gripper( false );
horiz.DockFixed( true );
horiz.Movable( false );
horiz.Floatable( false );
horiz.CloseButton( false );
horiz.CaptionVisible( false );
wxAuiPaneInfo vert(horiz);
wxAuiPaneInfo vert( horiz );
vert.TopDockable(false).BottomDockable(false);
horiz.LeftDockable(false).RightDockable(false);
vert.TopDockable( false ).BottomDockable( false );
horiz.LeftDockable( false ).RightDockable( false );
m_auimgr.AddPane(m_HToolBar,
wxAuiPaneInfo(horiz).Name(wxT("m_HToolBar")).Top().Row(0));
m_auimgr.AddPane( m_HToolBar,
wxAuiPaneInfo( horiz ).Name( wxT( "m_HToolBar" ) ).Top().Row( 0 ) );
m_auimgr.AddPane(m_VToolBar,
wxAuiPaneInfo(vert).Name(wxT("m_VToolBar")).Right());
m_auimgr.AddPane( m_VToolBar,
wxAuiPaneInfo( vert ).Name( wxT( "m_VToolBar" ) ).Right() );
m_auimgr.AddPane(m_OptionsToolBar,
wxAuiPaneInfo(vert).Name(wxT("m_OptionsToolBar")).Left());
m_auimgr.AddPane( m_OptionsToolBar,
wxAuiPaneInfo( vert ).Name( wxT( "m_OptionsToolBar" ) ).Left() );
m_auimgr.AddPane(DrawPanel,
wxAuiPaneInfo().Name(wxT("DrawFrame")).CentrePane());
m_auimgr.AddPane( DrawPanel,
wxAuiPaneInfo().Name( wxT( "DrawFrame" ) ).CentrePane() );
m_auimgr.AddPane(MsgPanel,
wxAuiPaneInfo(horiz).Name(wxT("MsgPanel")).Bottom());
m_auimgr.AddPane( MsgPanel,
wxAuiPaneInfo( horiz ).Name( wxT( "MsgPanel" ) ).Bottom() );
m_auimgr.Update();
#endif
@ -194,13 +189,10 @@ WinEDA_GerberFrame::~WinEDA_GerberFrame()
SetBaseScreen( ScreenPcb );
extern PARAM_CFG_BASE* ParamCfgList[];
wxGetApp().SaveCurrentSetupValues( ParamCfgList );
}
/***********************************************************/
void WinEDA_GerberFrame::OnCloseWindow( wxCloseEvent& Event )
/***********************************************************/
{
PCB_SCREEN* screen = ScreenPcb;
@ -221,7 +213,8 @@ void WinEDA_GerberFrame::OnCloseWindow( wxCloseEvent& Event )
}
}
#endif
while( screen ) // suppression flag modify pour eviter d'autres message
while( screen ) // Modify delete flag to prevent further message.
{
screen->ClrModify();
screen = screen->Next();
@ -234,13 +227,10 @@ void WinEDA_GerberFrame::OnCloseWindow( wxCloseEvent& Event )
}
/*******************************************/
void WinEDA_GerberFrame::SetToolbars()
/*******************************************/
/** Function SetToolbars()
* Set the tools state for the toolbars, accordint to display options
* Set the tools state for the toolbars, according to display options
*/
void WinEDA_GerberFrame::SetToolbars()
{
int layer = ( (PCB_SCREEN*) GetScreen() )->m_Active_Layer;
GERBER* gerber = g_GERBER_List[layer];
@ -263,7 +253,7 @@ void WinEDA_GerberFrame::SetToolbars()
( (PCB_SCREEN*) GetScreen() )->m_Active_Layer )
{
m_SelLayerBox->SetSelection(
( (PCB_SCREEN*) GetScreen() )->m_Active_Layer );
( (PCB_SCREEN*) GetScreen() )->m_Active_Layer );
}
if( gerber )
@ -318,16 +308,15 @@ void WinEDA_GerberFrame::SetToolbars()
}
DisplayUnitsMsg();
#if defined(KICAD_AUIMANAGER)
if(m_auimgr.GetManagedWindow())
m_auimgr.Update();
if( m_auimgr.GetManagedWindow() )
m_auimgr.Update();
#endif
}
/*************************************/
int WinEDA_GerberFrame::BestZoom()
/*************************************/
{
double x, y;
wxSize size;
@ -340,5 +329,5 @@ int WinEDA_GerberFrame::BestZoom()
GetScreen()->GetGridSize().y ) / (double) size.y;
GetScreen()->m_Curseur = GetBoard()->m_BoundaryBox.Centre();
return wxRound( MAX( x, y ) * (double)GetScreen()->m_ZoomScalar );
return wxRound( MAX( x, y ) * (double) GetScreen()->m_ZoomScalar );
}

32
gerbview/gerbview.cpp
View File

@ -26,7 +26,7 @@ wxString g_PenFilenameExt;
int g_DCodesColor;
int g_Default_GERBER_Format;
int g_Plot_Spot_Mini; /* Diametre mini de l'ouverture pour */
int g_Plot_Spot_Mini; /* Diameter of the opening mini-track for GERBER. */
int g_DisplayPolygonsModeSketch;
GERBER* g_GERBER_List[32];
@ -37,7 +37,7 @@ IMPLEMENT_APP( WinEDA_App )
bool WinEDA_App::OnInit()
{
wxFileName fn;
wxFileName fn;
WinEDA_GerberFrame* frame = NULL;
InitEDA_Appl( wxT( "GerbView" ), APP_TYPE_GERBVIEW );
@ -47,9 +47,10 @@ bool WinEDA_App::OnInit()
ActiveScreen = ScreenPcb;
// read current setup and reopen last directory if no filename to open in command line
// read current setup and reopen last directory if no filename to open in
// command line
bool reopenLastUsedDirectory = argc == 1;
GetSettings(reopenLastUsedDirectory);
GetSettings( reopenLastUsedDirectory );
extern PARAM_CFG_BASE* ParamCfgList[];
wxGetApp().ReadCurrentSetupValues( ParamCfgList );
@ -62,25 +63,28 @@ bool WinEDA_App::OnInit()
g_DrawBgColor = BLACK;
Read_Hotkey_Config( frame, false ); /* Must be called before creating the main frame
* in order to display the real hotkeys
* in menus or tool tips */
Read_Hotkey_Config( frame, false ); /* Must be called before creating the
* main frame in order to display the
* real hotkeys in menus or tool tips
*/
frame = new WinEDA_GerberFrame( NULL, wxT( "GerbView" ),
wxPoint( 0, 0 ),
wxSize( 600, 400 ) );
wxPoint( 0, 0 ),
wxSize( 600, 400 ) );
/* Gerbview mainframe title */
frame->SetTitle( GetTitle() + wxT( " " ) + GetBuildVersion() );
frame->SetBoard( new BOARD( NULL, frame ) );
// Initialize some display options
DisplayOpt.DisplayPadIsol = false; // Pad clearance has no meaning here
DisplayOpt.ShowTrackClearanceMode = 0; // tracks and vias clearance has no meaning here
DisplayOpt.DisplayPadIsol = false; // Pad clearance has no meaning
// here
DisplayOpt.ShowTrackClearanceMode = 0; // tracks and vias clearance has no
// meaning here
SetTopWindow( frame ); // Set GerbView mainframe on top
frame->Show( TRUE ); // Show GerbView mainframe
frame->Zoom_Automatique( TRUE ); // Zoomfit drawing in frame
SetTopWindow( frame ); // Set GerbView mainframe on top
frame->Show( TRUE ); // Show GerbView mainframe
frame->Zoom_Automatique( TRUE ); // Zoomfit drawing in frame
Read_Config();

185
gerbview/gerbview.h
View File

@ -1,6 +1,6 @@
/*******************************************************/
/* Menu General de Trace (PLOT): Fichier inclus PLOT.H */
/*******************************************************/
/**************/
/* gerbview.h */
/**************/
#ifndef GERBVIEW_H
#define GERBVIEW_H
@ -12,13 +12,14 @@
class WinEDA_GerberFrame;
class BOARD;
// Type d'action du phototraceur:
#define GERB_ACTIVE_DRAW 1 // activation de lumiere ( baisser de plume)
#define GERB_STOP_DRAW 2 // extinction de lumiere ( lever de plume)
// Type of photoplotter action:
#define GERB_ACTIVE_DRAW 1 // Activate light (lower pen)
#define GERB_STOP_DRAW 2 // Extinguish light (lift pen)
#define GERB_FLASH 3 // Flash
typedef enum {
typedef enum
{
FORMAT_HPGL,
FORMAT_GERBER,
FORMAT_POST
@ -32,14 +33,10 @@ extern wxString g_PenFilenameExt;
extern int g_DCodesColor;
extern int g_Default_GERBER_Format;
/* Gestion des ouvertures GERBER */
extern int g_Plot_Spot_Mini; /* Diametre mini de l'ouverture pour trace GERBER */
extern int g_Plot_Spot_Mini; /* Diameter of the opening mini-track for
* GERBER */
/*************************************/
/* Constantes utiles en trace GERBER */
/*************************************/
/**
* Enum APERTURE_T
* is the set of all gerber aperture types allowed, according to page 16 of
@ -57,7 +54,8 @@ enum APERTURE_T
// Interpolation type
enum Gerb_Interpolation {
enum Gerb_Interpolation
{
GERB_INTERPOL_LINEAR_1X = 0,
GERB_INTERPOL_LINEAR_10X,
GERB_INTERPOL_LINEAR_01X,
@ -68,20 +66,21 @@ enum Gerb_Interpolation {
// Command Type (GCodes)
enum Gerb_GCommand {
GC_MOVE = 0,
GC_LINEAR_INTERPOL_1X = 1,
GC_CIRCLE_NEG_INTERPOL = 2,
GC_CIRCLE_POS_INTERPOL = 3,
GC_COMMENT = 4,
GC_LINEAR_INTERPOL_10X = 10,
GC_LINEAR_INTERPOL_0P1X = 11,
GC_LINEAR_INTERPOL_0P01X = 12,
enum Gerb_GCommand
{
GC_MOVE = 0,
GC_LINEAR_INTERPOL_1X = 1,
GC_CIRCLE_NEG_INTERPOL = 2,
GC_CIRCLE_POS_INTERPOL = 3,
GC_COMMENT = 4,
GC_LINEAR_INTERPOL_10X = 10,
GC_LINEAR_INTERPOL_0P1X = 11,
GC_LINEAR_INTERPOL_0P01X = 12,
GC_TURN_ON_POLY_FILL = 36,
GC_TURN_OFF_POLY_FILL = 37,
GC_SELECT_TOOL = 54,
GC_PHOTO_MODE = 55, // can starts a D03 flash command: redundant with D03
GC_SPECIFY_INCHES = 70,
GC_SELECT_TOOL = 54,
GC_PHOTO_MODE = 55, // can start a D03 flash command: redundant with D03
GC_SPECIFY_INCHES = 70,
GC_SPECIFY_MILLIMETERS = 71,
GC_TURN_OFF_360_INTERPOL = 74,
GC_TURN_ON_360_INTERPOL = 75,
@ -93,7 +92,8 @@ enum Gerb_GCommand {
#define MAX_TOOLS 2048
#define FIRST_DCODE 10
enum Gerb_Analyse_Cmd {
enum Gerb_Analyse_Cmd
{
CMD_IDLE = 0,
END_BLOCK,
ENTER_RS274X_CMD
@ -104,10 +104,11 @@ class D_CODE;
/**
* Class DCODE_PARAM
* holds a parameter for a DCODE or an "aperture macro" as defined within standard RS274X.
* The \a value field can be a constant, i.e. "immediate" parameter or it may not be used
* if this param is going to defer to the referencing aperture macro. In that case, the
* \a index field is an index into the aperture macro's paramters.
* holds a parameter for a DCODE or an "aperture macro" as defined within
* standard RS274X. The \a value field can be a constant, i.e. "immediate"
* parameter or it may not be used if this param is going to defer to the
* referencing aperture macro. In that case, the \a index field is an index
* into the aperture macro's parameters.
*/
class DCODE_PARAM
{
@ -126,8 +127,8 @@ public:
/**
* Function IsImmediate
* tests if this DCODE_PARAM holds an immediate parameter or is a pointer into
* a parameter held by an owning D_CODE.
* tests if this DCODE_PARAM holds an immediate parameter or is a pointer
* into a parameter held by an owning D_CODE.
*/
bool IsImmediate() const { return index == -1; }
@ -142,8 +143,11 @@ public:
}
private:
int index; ///< if -1, then \a value field is an immediate value, else this is an index into parent's D_CODE.m_am_params.
double value; ///< if IsImmediate()==true then use the value, else not used.
int index; ///< if -1, then \a value field is an immediate value,
// else this is an index into parent's
// D_CODE.m_am_params.
double value; ///< if IsImmediate()==true then use the value, else
// not used.
};
@ -177,7 +181,8 @@ typedef std::vector<DCODE_PARAM> DCODE_PARAMS;
struct AM_PRIMITIVE
{
AM_PRIMITIVE_ID primitive_id; ///< The primitive type
DCODE_PARAMS params; ///< A sequence of parameters used by the primitive
DCODE_PARAMS params; ///< A sequence of parameters used by
// the primitive
/**
* Function GetExposure
@ -186,7 +191,8 @@ struct AM_PRIMITIVE
*/
int GetExposure() const
{
wxASSERT( params.size() && params[0].IsImmediate() ); // we have no D_CODE* for GetValue()
// No D_CODE* for GetValue()
wxASSERT( params.size() && params[0].IsImmediate() );
return (int) params[0].GetValue( NULL );
}
};
@ -207,7 +213,8 @@ struct APERTURE_MACRO
/**
* Struct APERTURE_MACRO_less_than
* is used by std:set<APERTURE_MACRO> instantiation which uses APERTURE_MACRO.name as its key.
* is used by std:set<APERTURE_MACRO> instantiation which uses
* APERTURE_MACRO.name as its key.
*/
struct APERTURE_MACRO_less_than
{
@ -236,7 +243,8 @@ class D_CODE
{
friend class DCODE_PARAM;
APERTURE_MACRO* m_Macro; ///< no ownership, points to GERBER.m_aperture_macros element
APERTURE_MACRO* m_Macro; ///< no ownership, points to
// GERBER.m_aperture_macros element
/**
* parameters used only when this D_CODE holds a reference to an aperture
@ -245,13 +253,13 @@ class D_CODE
DCODE_PARAMS m_am_params;
public:
wxSize m_Size; /* Dimensions horiz et Vert */
APERTURE_T m_Shape; /* shape ( Line, rect , circulaire , ovale .. ) */
int m_Num_Dcode; /* numero de code ( >= 10 ) */
wxSize m_Drill; /* dimension du trou central (s'il existe) */
int m_DrillShape; /* forme du trou central ( rond = 1, rect = 2 ) */
bool m_InUse; /* FALSE si non utilisé */
bool m_Defined; /* FALSE si non defini */
wxSize m_Size; /* Horizontal and vertical dimensions. */
APERTURE_T m_Shape; /* shape ( Line, rectangle, circle , oval .. ) */
int m_Num_Dcode; /* D code ( >= 10 ) */
wxSize m_Drill; /* dimension of the hole (if any) */
int m_DrillShape; /* shape of the hole (round = 1, rect = 2) */
bool m_InUse; /* FALSE if not used */
bool m_Defined; /* FALSE if not defined */
wxString m_SpecialDescr;
public:
@ -310,49 +318,49 @@ inline double DCODE_PARAM::GetValue( const D_CODE* aDcode ) const
*/
class GERBER
{
D_CODE* m_Aperture_List[MAX_TOOLS]; ///< Dcode (Aperture) List for this layer
bool m_Exposure; ///< whether an aperture macro tool is flashed on or off
D_CODE* m_Aperture_List[MAX_TOOLS]; ///< Dcode (Aperture) List for this layer
bool m_Exposure; ///< whether an aperture macro tool is flashed on or off
BOARD* m_Pcb;
public:
wxString m_FileName; // Full File Name for this layer
wxString m_Name; // Layer name
int m_Layer; // Layer Number
bool m_LayerNegative; // TRUE = Negative Layer
bool m_GerbMetric; // FALSE = Inches, TRUE = metric
bool m_Relative; // FALSE = absolute Coord, RUE = relative Coord
bool m_NoTrailingZeros; // True: zeros a droite supprimés
bool m_MirorA; // True: miror / axe A (X)
bool m_MirorB; // True: miror / axe B (Y)
bool m_Has_DCode; // TRUE = DCodes in file (FALSE = no DCode->
wxString m_FileName; // Full File Name for this layer
wxString m_Name; // Layer name
int m_Layer; // Layer Number
bool m_LayerNegative; // TRUE = Negative Layer
bool m_GerbMetric; // FALSE = Inches, TRUE = metric
bool m_Relative; // FALSE = absolute Coord, RUE = relative Coord
bool m_NoTrailingZeros; // True: remove tailing zeros.
bool m_MirorA; // True: miror / axe A (X)
bool m_MirorB; // True: miror / axe B (Y)
bool m_Has_DCode; // TRUE = DCodes in file (FALSE = no DCode->
// separate DCode file
wxPoint m_Offset; // Coord Offset
wxSize m_FmtScale; // Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4
wxSize m_FmtLen; // Nb chars per coord. ex fmt 2.3, m_FmtLen = 5
wxRealPoint m_LayerScale; // scale (X et Y) pour cette layer
wxPoint m_Offset; // Coord Offset
wxSize m_FmtScale; // Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4
wxSize m_FmtLen; // Nb chars per coord. ex fmt 2.3, m_FmtLen = 5
wxRealPoint m_LayerScale; // scale (X and Y) of layer.
int m_Rotation;
int m_Iterpolation; // Linear, 90 arc, Circ.
bool m_ImageNegative; // TRUE = Negative image
int m_Current_Tool; // Current Tool (Dcode) number selected
int m_Last_Pen_Command; // Current or last pen state (0..9, set by Dn option with n <10
int m_CommandState; // donne l'etat de l'analyse des commandes gerber
wxPoint m_CurrentPos; // current specified coord for plot
wxPoint m_PreviousPos; // old current specified coord for plot
wxPoint m_IJPos; // IJ coord (for arcs & circles )
int m_Iterpolation; // Linear, 90 arc, Circ.
bool m_ImageNegative; // TRUE = Negative image
int m_Current_Tool; // Current Tool (Dcode) number selected
int m_Last_Pen_Command; // Current or last pen state (0..9, set by Dn option with n <10
int m_CommandState; // state of gerber analysis command.
wxPoint m_CurrentPos; // current specified coord for plot
wxPoint m_PreviousPos; // old current specified coord for plot
wxPoint m_IJPos; // IJ coord (for arcs & circles )
FILE* m_Current_File; // Current file to read
FILE* m_FilesList[12]; // Files list
int m_FilesPtr; // Stack pointer for files list
FILE* m_Current_File; // Current file to read
FILE* m_FilesList[12]; // Files list
int m_FilesPtr; // Stack pointer for files list
int m_Selected_Tool; // Pour editions: Tool (Dcode) selectionné
int m_Selected_Tool; // Pour editions: Tool (Dcode) selectionné
int m_Transform[2][2]; // The rotation/mirror transformation matrix.
bool m_360Arc_enbl; // Enbl 360 deg circular interpolation
bool m_PolygonFillMode; // Enbl polygon mode (read coord as a polygone descr)
int m_PolygonFillModeState; // In polygon mode: 0 = first segm, 1 = next segm
int m_Transform[2][2]; // The rotation/mirror transformation matrix.
bool m_360Arc_enbl; // Enbl 360 deg circular interpolation
bool m_PolygonFillMode; // Enbl polygon mode (read coord as a polygon descr)
int m_PolygonFillModeState; // In polygon mode: 0 = first segm, 1 = next segm
APERTURE_MACRO_SET m_aperture_macros; ///< a collection of APERTURE_MACROS, sorted by name
APERTURE_MACRO_SET m_aperture_macros; ///< a collection of APERTURE_MACROS, sorted by name
public:
GERBER( int layer );
@ -367,7 +375,6 @@ public:
*/
void InitToolTable();
// Routines utilisées en lecture de ficher gerber
wxPoint ReadXYCoord( char*& Text );
wxPoint ReadIJCoord( char*& Text );
int ReturnGCodeNumber( char*& Text );
@ -391,9 +398,10 @@ public:
/**
* Function ExecuteRS274XCommand
* executes 1 commande
* executes 1 command
*/
bool ExecuteRS274XCommand( int command, char aBuff[GERBER_BUFZ], char*& text );
bool ExecuteRS274XCommand( int command, char aBuff[GERBER_BUFZ],
char*& text );
/**
@ -401,11 +409,13 @@ public:
* reads in an aperture macro and saves it in m_aperture_macros.
* @param aBuff a character buffer at least GERBER_BUFZ long that can be
* used to read successive lines from the gerber file.
* @param text A reference to a character pointer which gives the initial text to read from.
* @param text A reference to a character pointer which gives the initial
* text to read from.
* @param gerber_file Which file to read from for continuation.
* @return bool - true if a macro was read in successfully, else false.
*/
bool ReadApertureMacro( char aBuff[GERBER_BUFZ], char*& text, FILE* gerber_file );
bool ReadApertureMacro( char aBuff[GERBER_BUFZ], char*& text,
FILE* gerber_file );
/**
@ -413,7 +423,8 @@ public:
* returns a pointer to the D_CODE within this GERBER for the given
* \a aDCODE.
* @param aDCODE The numeric value of the D_CODE to look up.
* @param createIfNoExist If true, then create the D_CODE if it does not exist.
* @param createIfNoExist If true, then create the D_CODE if it does not
* exist.
* @return D_CODE* - the one implied by the given \a aDCODE, or NULL
* if the requested \a aDCODE is out of range.
*/
@ -423,13 +434,13 @@ public:
* Function FindApertureMacro
* looks up a previously read in aperture macro.
* @param aLookup A dummy APERTURE_MACRO with [only] the name field set.
* @return APERTURE_MACRO* - the one with a matching name, or NULL if not found.
* @return APERTURE_MACRO* - the one with a matching name, or NULL if
* not found.
*/
APERTURE_MACRO* FindApertureMacro( const APERTURE_MACRO& aLookup );
};
/**************/
/* rs274x.cpp */
/**************/

40
gerbview/gerbview_config.cpp
View File

@ -2,8 +2,6 @@
/** gerbview_config.cpp : Gerbview configuration*/
/************************************************/
/* Functions to handle Gerbview configuration */
#include "fctsys.h"
#include "appl_wxstruct.h"
#include "common.h"
@ -27,9 +25,7 @@ const wxString GerbviewProjectFileExt( wxT( "cnf" ) );
const wxString GerbviewProjectFileWildcard( _( "GerbView project files (.cnf)|*.cnf" ) );
/*************************************************************/
void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
/*************************************************************/
{
int id = event.GetId();
wxPoint pos;
@ -45,7 +41,7 @@ void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
DisplayColorSetupFrame( this, pos );
break;
case ID_CONFIG_REQ: // Creation de la fenetre de configuration
case ID_CONFIG_REQ:
{
InstallConfigFrame( pos );
break;
@ -91,7 +87,7 @@ void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
HandleHotkeyConfigMenuSelection( this, id );
break;
case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST: // Display Current hotkey list for gerbview
case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST:
DisplayHotkeyList( this, s_Gerbview_Hokeys_Descr );
break;
@ -102,22 +98,16 @@ void WinEDA_GerberFrame::Process_Config( wxCommandEvent& event )
}
/*****************************************************/
bool Read_Config()
/*****************************************************/
/* lit la configuration, si elle n'a pas deja etee lue
* 1 - lit gerbview.cnf
* 2 - si non trouve lit <chemin de gerbview.exe>/gerbview.cnf
* 3 - si non trouve: init des variables aux valeurs par defaut
*
* Retourne un pointeur su le message d'erreur a afficher
/* Read configuration, if it has not already read.
* 1 - bed gerbview.cnf
* 2 - if no bed is path> gerbview.exe> / gerbview.cnf
* 3 - If not found: init variables to default values
*/
bool Read_Config()
{
wxGetApp().ReadProjectConfig( wxT( "gerbview.cnf" ), GROUP, ParamCfgList,
FALSE );
/* Inits autres variables */
if( g_PhotoFilenameExt.IsEmpty() )
g_PhotoFilenameExt = wxT( "pho" );
if( g_DrillFilenameExt.IsEmpty() )
@ -129,13 +119,7 @@ bool Read_Config()
}
/******************************************/
void WinEDA_GerberFrame::Update_config()
/******************************************/
/*
* creation du fichier de config
*/
{
wxFileName fn = wxFileName( wxEmptyString, wxT( "gerbview" ),
GerbviewProjectFileExt );
@ -147,21 +131,17 @@ void WinEDA_GerberFrame::Update_config()
if( dlg.ShowModal() == wxID_CANCEL )
return;
/* ecriture de la configuration */
wxGetApp().WriteProjectConfig( dlg.GetPath(), GROUP, ParamCfgList );
}
/***************************************************************/
bool Read_Hotkey_Config( WinEDA_DrawFrame* frame, bool verbose )
/***************************************************************/
/*
* Read the hotkey files config for pcbnew and module_edit
*/
bool Read_Hotkey_Config( WinEDA_DrawFrame* frame, bool verbose )
{
wxString FullFileName = ReturnHotkeyConfigFilePath(
g_ConfigFileLocationChoice );
wxString FullFileName =
ReturnHotkeyConfigFilePath( g_ConfigFileLocationChoice );
FullFileName += HOTKEY_FILENAME;
FullFileName += wxT(".");

300
gerbview/gerbview_config.h
View File

@ -1,6 +1,6 @@
/**********************************************************/
/** cfg.h : configuration: definition des structures **/
/**********************************************************/
/*************************/
/** gerberview_config.h **/
/*************************/
#include "param_config.h"
@ -13,382 +13,382 @@
static PARAM_CFG_WXSTRING PhotoExtBufCfg
(
wxT("PhoExt"), /* identification */
&g_PhotoFilenameExt /* Adresse du parametre */
wxT("PhoExt"),
&g_PhotoFilenameExt
);
static PARAM_CFG_WXSTRING PenExtBufCfg
(
wxT("PenExt"), /* identification */
&g_PenFilenameExt /* Adresse du parametre */
wxT("PenExt"),
&g_PenFilenameExt
);
static PARAM_CFG_WXSTRING DrillExtBufCfg
(
wxT("DrilExt"), /* identification */
&g_DrillFilenameExt /* Adresse du parametre */
wxT("DrilExt"),
&g_DrillFilenameExt
);
static PARAM_CFG_INT UnitCfg // Unites; 0 inche, 1 mm
static PARAM_CFG_INT UnitCfg // Units; 0 inches, 1 mm
(
wxT("Unite"), /* identification */
&g_UnitMetric, /* Adresse du parametre */
FALSE /* Valeur par defaut */
wxT("Unite"),
&g_UnitMetric,
FALSE
);
static PARAM_CFG_INT GerberScaleCfg // default scale; 0 2.3, 1 3.4
(
wxT("Def_fmt"), /* identification */
&g_Default_GERBER_Format, /* Adresse du parametre */
23, /* Valeur par defaut */
23, 66 /* Valeurs extremes */
wxT("Def_fmt"),
&g_Default_GERBER_Format,
23,
23, 66
);
static PARAM_CFG_BOOL SegmFillCfg
(
INSETUP,
wxT("SegFill"), /* identification */
&DisplayOpt.DisplayPcbTrackFill, /* Adresse du parametre */
TRUE /* Valeur par defaut */
wxT("SegFill"),
&DisplayOpt.DisplayPcbTrackFill,
TRUE
);
static PARAM_CFG_INT PadFillCfg
(
INSETUP,
wxT("PadFill"), /* identification */
(int*)&DisplayOpt.DisplayPadFill, /* Adresse du parametre */
TRUE /* Valeur par defaut */
wxT("PadFill"),
(int*)&DisplayOpt.DisplayPadFill,
TRUE
);
static PARAM_CFG_INT ViaFillCfg
(
INSETUP,
wxT("ViaFill"), /* identification */
(int*)&DisplayOpt.DisplayViaFill, /* Adresse du parametre */
TRUE /* Valeur par defaut */
wxT("ViaFill"),
(int*)&DisplayOpt.DisplayViaFill,
TRUE
);
static PARAM_CFG_BOOL PadShowNumCfg // Affiche DCodes
static PARAM_CFG_BOOL PadShowNumCfg // Show DCodes
(
INSETUP,
wxT("PadSNum"), /* identification */
&DisplayOpt.DisplayPadNum, /* Adresse du parametre */
TRUE /* Valeur par defaut */
wxT("PadSNum"),
&DisplayOpt.DisplayPadNum,
TRUE
);
static PARAM_CFG_SETCOLOR ColorLayer0Cfg
(
INSETUP,
wxT("ColLay0"), /* identification */
&g_DesignSettings.m_LayerColor[0], /* Adresse du parametre */
GREEN /* Valeur par defaut */
wxT("ColLay0"),
&g_DesignSettings.m_LayerColor[0],
GREEN
);
static PARAM_CFG_SETCOLOR ColorLayer1Cfg
(
INSETUP,
wxT("ColLay1"), /* identification */
&g_DesignSettings.m_LayerColor[1], /* Adresse du parametre */
BLUE /* Valeur par defaut */
wxT("ColLay1"),
&g_DesignSettings.m_LayerColor[1],
BLUE
);
static PARAM_CFG_SETCOLOR ColorLayer2Cfg
(
INSETUP,
wxT("ColLay2"), /* identification */
&g_DesignSettings.m_LayerColor[2], /* Adresse du parametre */
LIGHTGRAY /* Valeur par defaut */
wxT("ColLay2"),
&g_DesignSettings.m_LayerColor[2],
LIGHTGRAY
);
static PARAM_CFG_SETCOLOR ColorLayer3Cfg
(
INSETUP,
wxT("ColLay3"), /* identification */
&g_DesignSettings.m_LayerColor[3], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLay3"),
&g_DesignSettings.m_LayerColor[3],
5
);
static PARAM_CFG_SETCOLOR ColorLayer4Cfg
(
INSETUP,
wxT("ColLay4"), /* identification */
&g_DesignSettings.m_LayerColor[4], /* Adresse du parametre */
4 /* Valeur par defaut */
wxT("ColLay4"),
&g_DesignSettings.m_LayerColor[4],
4
);
static PARAM_CFG_SETCOLOR ColorLayer5Cfg
(
INSETUP,
wxT("ColLay5"), /* identification */
&g_DesignSettings.m_LayerColor[5], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLay5"),
&g_DesignSettings.m_LayerColor[5],
5
);
static PARAM_CFG_SETCOLOR ColorLayer6Cfg
(
INSETUP,
wxT("ColLay6"), /* identification */
&g_DesignSettings.m_LayerColor[6], /* Adresse du parametre */
6 /* Valeur par defaut */
wxT("ColLay6"),
&g_DesignSettings.m_LayerColor[6],
6
);
static PARAM_CFG_SETCOLOR ColorLayer7Cfg
(
INSETUP,
wxT("ColLay7"), /* identification */
&g_DesignSettings.m_LayerColor[7], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLay7"),
&g_DesignSettings.m_LayerColor[7],
5
);
static PARAM_CFG_SETCOLOR ColorLayer8Cfg
(
INSETUP,
wxT("ColLay8"), /* identification */
&g_DesignSettings.m_LayerColor[8], /* Adresse du parametre */
7 /* Valeur par defaut */
wxT("ColLay8"),
&g_DesignSettings.m_LayerColor[8],
7
);
static PARAM_CFG_SETCOLOR ColorLayer9Cfg
(
INSETUP,
wxT("ColLay9"), /* identification */
&g_DesignSettings.m_LayerColor[9], /* Adresse du parametre */
1 /* Valeur par defaut */
wxT("ColLay9"),
&g_DesignSettings.m_LayerColor[9],
1
);
static PARAM_CFG_SETCOLOR ColorLayer10Cfg
(
INSETUP,
wxT("ColLayA"), /* identification */
&g_DesignSettings.m_LayerColor[10], /* Adresse du parametre */
2 /* Valeur par defaut */
wxT("ColLayA"),
&g_DesignSettings.m_LayerColor[10],
2
);
static PARAM_CFG_SETCOLOR ColorLayer11Cfg
(
INSETUP,
wxT("ColLayB"), /* identification */
&g_DesignSettings.m_LayerColor[11], /* Adresse du parametre */
3 /* Valeur par defaut */
wxT("ColLayB"),
&g_DesignSettings.m_LayerColor[11],
3
);
static PARAM_CFG_SETCOLOR ColorLayer12Cfg
(
INSETUP,
wxT("ColLayC"), /* identification */
&g_DesignSettings.m_LayerColor[12], /* Adresse du parametre */
12 /* Valeur par defaut */
wxT("ColLayC"),
&g_DesignSettings.m_LayerColor[12],
12
);
static PARAM_CFG_SETCOLOR ColorLayer13Cfg
(
INSETUP,
wxT("ColLayD"), /* identification */
&g_DesignSettings.m_LayerColor[13], /* Adresse du parametre */
13 /* Valeur par defaut */
wxT("ColLayD"),
&g_DesignSettings.m_LayerColor[13],
13
);
static PARAM_CFG_SETCOLOR ColorLayer14Cfg
(
INSETUP,
wxT("ColLayE"), /* identification */
&g_DesignSettings.m_LayerColor[14], /* Adresse du parametre */
14 /* Valeur par defaut */
wxT("ColLayE"),
&g_DesignSettings.m_LayerColor[14],
14
);
static PARAM_CFG_SETCOLOR ColorLayer15Cfg
(
INSETUP,
wxT("ColLayF"), /* identification */
&g_DesignSettings.m_LayerColor[15], /* Adresse du parametre */
RED /* Valeur par defaut */
wxT("ColLayF"),
&g_DesignSettings.m_LayerColor[15],
RED
);
static PARAM_CFG_SETCOLOR ColorLayer16Cfg
(
INSETUP,
wxT("ColLayG"), /* identification */
&g_DesignSettings.m_LayerColor[16], /* Adresse du parametre */
1 /* Valeur par defaut */
wxT("ColLayG"),
&g_DesignSettings.m_LayerColor[16],
1
);
static PARAM_CFG_SETCOLOR ColorLayer17Cfg
(
INSETUP,
wxT("ColLayH"), /* identification */
&g_DesignSettings.m_LayerColor[17], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLayH"),
&g_DesignSettings.m_LayerColor[17],
5
);
static PARAM_CFG_SETCOLOR ColorLayer18Cfg
(
INSETUP,
wxT("ColLayI"), /* identification */
&g_DesignSettings.m_LayerColor[18], /* Adresse du parametre */
11 /* Valeur par defaut */
wxT("ColLayI"),
&g_DesignSettings.m_LayerColor[18],
11
);
static PARAM_CFG_SETCOLOR ColorLayer19Cfg
(
INSETUP,
wxT("ColLayJ"), /* identification */
&g_DesignSettings.m_LayerColor[19], /* Adresse du parametre */
4 /* Valeur par defaut */
wxT("ColLayJ"),
&g_DesignSettings.m_LayerColor[19],
4
);
static PARAM_CFG_SETCOLOR ColorLayer20Cfg
(
INSETUP,
wxT("ColLayK"), /* identification */
&g_DesignSettings.m_LayerColor[20], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLayK"),
&g_DesignSettings.m_LayerColor[20],
5
);
static PARAM_CFG_SETCOLOR ColorLayer21Cfg
(
INSETUP,
wxT("ColLayL"), /* identification */
&g_DesignSettings.m_LayerColor[21], /* Adresse du parametre */
3 /* Valeur par defaut */
wxT("ColLayL"),
&g_DesignSettings.m_LayerColor[21],
3
);
static PARAM_CFG_SETCOLOR ColorLayer22Cfg
(
INSETUP,
wxT("ColLayM"), /* identification */
&g_DesignSettings.m_LayerColor[22], /* Adresse du parametre */
6 /* Valeur par defaut */
wxT("ColLayM"),
&g_DesignSettings.m_LayerColor[22],
6
);
static PARAM_CFG_SETCOLOR ColorLayer23Cfg
(
INSETUP,
wxT("ColLayN"), /* identification */
&g_DesignSettings.m_LayerColor[23], /* Adresse du parametre */
5 /* Valeur par defaut */
wxT("ColLayN"),
&g_DesignSettings.m_LayerColor[23],
5
);
static PARAM_CFG_SETCOLOR ColorLayer24Cfg
(
INSETUP,
wxT("ColLayO"), /* identification */
&g_DesignSettings.m_LayerColor[24], /* Adresse du parametre */
LIGHTGRAY /* Valeur par defaut */
wxT("ColLayO"),
&g_DesignSettings.m_LayerColor[24],
LIGHTGRAY
);
static PARAM_CFG_SETCOLOR ColorLayer25Cfg
(
INSETUP,
wxT("ColLayP"), /* identification */
&g_DesignSettings.m_LayerColor[25], /* Adresse du parametre */
1 /* Valeur par defaut */
wxT("ColLayP"),
&g_DesignSettings.m_LayerColor[25],
1
);
static PARAM_CFG_SETCOLOR ColorLayer26Cfg
(
INSETUP,
wxT("ColLayQ"), /* identification */
&g_DesignSettings.m_LayerColor[26], /* Adresse du parametre */
2 /* Valeur par defaut */
wxT("ColLayQ"),
&g_DesignSettings.m_LayerColor[26],
2
);
static PARAM_CFG_SETCOLOR ColorLayer27Cfg
(
INSETUP,
wxT("ColLayR"), /* identification */
&g_DesignSettings.m_LayerColor[27], /* Adresse du parametre */
14 /* Valeur par defaut */
wxT("ColLayR"),
&g_DesignSettings.m_LayerColor[27],
14
);
static PARAM_CFG_SETCOLOR ColorLayer28Cfg
(
INSETUP,
wxT("ColLayS"), /* identification */
&g_DesignSettings.m_LayerColor[28], /* Adresse du parametre */
YELLOW /* Valeur par defaut */
wxT("ColLayS"),
&g_DesignSettings.m_LayerColor[28],
YELLOW
);
static PARAM_CFG_SETCOLOR ColorLayer29Cfg
(
INSETUP,
wxT("ColLayT"), /* identification */
&g_DesignSettings.m_LayerColor[29], /* Adresse du parametre */
13 /* Valeur par defaut */
wxT("ColLayT"),
&g_DesignSettings.m_LayerColor[29],
13
);
static PARAM_CFG_SETCOLOR ColorLayer30Cfg
(
INSETUP,
wxT("ColLayU"), /* identification */
&g_DesignSettings.m_LayerColor[30], /* Adresse du parametre */
14 /* Valeur par defaut */
wxT("ColLayU"),
&g_DesignSettings.m_LayerColor[30],
14
);
static PARAM_CFG_SETCOLOR ColorLayer31Cfg
(
INSETUP,
wxT("ColLayV"), /* identification */
&g_DesignSettings.m_LayerColor[31], /* Adresse du parametre */
7 /* Valeur par defaut */
wxT("ColLayV"),
&g_DesignSettings.m_LayerColor[31],
7
);
static PARAM_CFG_SETCOLOR ColorpcbGrilleCfg
(
INSETUP,
wxT("CoPcbGr"), /* identification */
wxT("CoPcbGr"),
//@@IMB: Wrong object &g_DesignSettings.m_PcbGridColor, /* Adresse du parametre */
&g_GridColor, //@@IMB: This is the real variable.
DARKGRAY /* Valeur par defaut */
DARKGRAY
);
static PARAM_CFG_SETCOLOR ColorDCodesCfg
(
INSETUP,
wxT("CoDCode"), /* identification */
&g_DCodesColor, /* Adresse du parametre */
WHITE /* Valeur par defaut */
wxT("CoDCode"),
&g_DCodesColor,
WHITE
);
static PARAM_CFG_INT GERBERSpotMiniCfg
(
wxT("GERBmin"), /* identification */
&g_Plot_Spot_Mini, /* Adresse du parametre */
15, /* Valeur par defaut */
2,0xFFFF /* Valeurs extremes */
wxT("GERBmin"),
&g_Plot_Spot_Mini,
15,
2,0xFFFF
);
static PARAM_CFG_INT DrawSegmLargeurCfg
(
wxT("DrawLar"), /* identification */
&g_DesignSettings.m_DrawSegmentWidth, /* Adresse du parametre */
120, /* Valeur par defaut */
0,10000 /* Valeurs extremes */
wxT("DrawLar"),
&g_DesignSettings.m_DrawSegmentWidth,
120,
0,10000
);
static PARAM_CFG_INT EdgeSegmLargeurCfg
(
wxT("EdgeLar"), /* identification */
&g_DesignSettings.m_EdgeSegmentWidth, /* Adresse du parametre */
120, /* Valeur par defaut */
0,10000 /* Valeurs extremes */
wxT("EdgeLar"),
&g_DesignSettings.m_EdgeSegmentWidth,
120,
0,10000
);
static PARAM_CFG_INT TimeOutCfg
(
wxT("TimeOut"), /* identification */
&g_TimeOut, /* Adresse du parametre */
600, /* Valeur par defaut */
0,60000 /* Valeurs extremes */
wxT("TimeOut"),
&g_TimeOut,
600,
0,60000
);
static PARAM_CFG_BOOL DisplPolairCfg
(
INSETUP,
wxT("DPolair"), /* identification */
&DisplayOpt.DisplayPolarCood, /* Adresse du parametre */
FALSE /* Valeur par defaut */
wxT("DPolair"),
&DisplayOpt.DisplayPolarCood,
FALSE
);
PARAM_CFG_BASE * ParamCfgList[] =

85
gerbview/initpcb.cpp
View File

@ -1,7 +1,6 @@
/**********************************************/
/* GERBVIEW : Routines d'initialisation globale */
/******* Fichier INITPCB.C ********************/
/**********************************************/
/****************************************/
/******* initpcb.cpp ********************/
/****************************************/
#include "fctsys.h"
@ -12,16 +11,8 @@
#include "gerbview.h"
#include "protos.h"
/* Routines Locales */
/********************************************************/
bool WinEDA_GerberFrame::Clear_Pcb( bool query )
/********************************************************/
/* Realise les init des pointeurs et variables
* Si Item == NULL, il n'y aura pas de confirmation
*/
{
int layer;
@ -30,9 +21,10 @@ bool WinEDA_GerberFrame::Clear_Pcb( bool query )
if( query )
{
if( GetBoard()->m_Drawings || GetBoard()->m_Track || GetBoard()->m_Zone )
if( GetBoard()->m_Drawings || GetBoard()->m_Track
|| GetBoard()->m_Zone )
{
if( !IsOK( this, _( "Current Data will be lost ?" ) ) )
if( !IsOK( this, _( "Current data will be lost?" ) ) )
return FALSE;
}
}
@ -43,21 +35,18 @@ bool WinEDA_GerberFrame::Clear_Pcb( bool query )
GetBoard()->m_Zone.DeleteAll();
/* init pointeurs et variables */
for( layer = 0; layer < 32; layer++ )
{
if( g_GERBER_List[layer] )
g_GERBER_List[layer]->InitToolTable();
}
/* remise a 0 ou a une valeur initiale des variables de la structure */
GetBoard()->m_BoundaryBox.SetOrigin( 0, 0 );
GetBoard()->m_BoundaryBox.SetSize( 0, 0 );
GetBoard()->m_Status_Pcb = 0;
GetBoard()->m_Status_Pcb = 0;
GetBoard()->m_NbNodes = 0;
GetBoard()->m_NbNoconnect = 0;
/* Init parametres de gestion des ecrans PAD et PCB */
SetBaseScreen( ActiveScreen = ScreenPcb );
GetScreen()->Init();
@ -65,11 +54,9 @@ bool WinEDA_GerberFrame::Clear_Pcb( bool query )
}
/*********************************************************/
void WinEDA_GerberFrame::Erase_Zones( bool query )
/*********************************************************/
{
if( query && !IsOK( this, _( "Delete zones ?" ) ) )
if( query && !IsOK( this, _( "Delete zones?" ) ) )
return;
GetBoard()->m_Zone.DeleteAll();
@ -78,17 +65,15 @@ void WinEDA_GerberFrame::Erase_Zones( bool query )
}
/************************************************************************/
void WinEDA_GerberFrame::Erase_Segments_Pcb( bool all_layers, bool query )
/************************************************************************/
{
int layer = GetScreen()->m_Active_Layer;
int layer = GetScreen()->m_Active_Layer;
if( all_layers )
layer = -1;
BOARD_ITEM* next;
for( BOARD_ITEM* item = GetBoard()->m_Drawings; item; item = next )
BOARD_ITEM* next;
for( BOARD_ITEM* item = GetBoard()->m_Drawings; item; item = next )
{
next = item->Next();
@ -103,7 +88,7 @@ void WinEDA_GerberFrame::Erase_Segments_Pcb( bool all_layers, bool query )
break;
default:
DisplayError( this, wxT( "Type Draw inconnu/inattendu" ) );
DisplayError( this, wxT( "Draw type unknown." ) );
break;
}
}
@ -112,24 +97,23 @@ void WinEDA_GerberFrame::Erase_Segments_Pcb( bool all_layers, bool query )
}
/******************************************************************/
void WinEDA_GerberFrame::Erase_Pistes( int masque_type, bool query )
/******************************************************************/
/* Efface les segments de piste, selon les autorisations affichees
* masque_type = masque des options de selection:
* SEGM_FIXE, SEGM_AR
* Si un des bits est a 1, il n'y a pas effacement du segment de meme bit a 1
/* Delete track segments.
* masque_type mask options selection:
* SEGM_FIXE, SEGM_AR
* If a bit is 1, segment is not erased.
*/
void WinEDA_GerberFrame::Erase_Pistes( int masque_type, bool query )
{
TRACK* pt_segm;
BOARD_ITEM* PtNext;
TRACK* pt_segm;
BOARD_ITEM* PtNext;
if( query && !IsOK( this, _( "Delete Tracks?" ) ) )
if( query && !IsOK( this, _( "Delete tracks?" ) ) )
return;
/* Marquage des pistes a effacer */
for( pt_segm = GetBoard()->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext )
/* Mark tracks to clear. */
for( pt_segm = GetBoard()->m_Track;
pt_segm != NULL;
pt_segm = (TRACK*) PtNext )
{
PtNext = pt_segm->Next();
if( pt_segm->GetState( SEGM_FIXE | SEGM_AR ) & masque_type )
@ -141,14 +125,12 @@ void WinEDA_GerberFrame::Erase_Pistes( int masque_type, bool query )
}
/*****************************************************************/
void WinEDA_GerberFrame::Erase_Textes_Pcb( bool query )
/*****************************************************************/
{
BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
if( query && !IsOK( this, _( "Delete Pcb Texts" ) ) )
if( query && !IsOK( this, _( "Delete pcb text?" ) ) )
return;
PtStruct = GetBoard()->m_Drawings;
@ -163,20 +145,20 @@ void WinEDA_GerberFrame::Erase_Textes_Pcb( bool query )
}
/*********************************************************/
void WinEDA_GerberFrame::Erase_Current_Layer( bool query )
/*********************************************************/
{
int layer = GetScreen()->m_Active_Layer;
wxString msg;
int layer = GetScreen()->m_Active_Layer;
wxString msg;
msg.Printf( _( "Delete Layer %d" ), layer + 1 );
msg.Printf( _( "Delete layer %d?" ), layer + 1 );
if( query && !IsOK( this, msg ) )
return;
/* Delete tracks (spots and lines) */
TRACK* PtNext;
for( TRACK* pt_segm = GetBoard()->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext )
TRACK* PtNext;
for( TRACK* pt_segm = GetBoard()->m_Track;
pt_segm != NULL;
pt_segm = (TRACK*) PtNext )
{
PtNext = pt_segm->Next();
if( pt_segm->GetLayer() != layer )
@ -185,7 +167,7 @@ void WinEDA_GerberFrame::Erase_Current_Layer( bool query )
}
/* Delete polygons */
SEGZONE* Nextzone;
SEGZONE* Nextzone;
for( SEGZONE* zone = GetBoard()->m_Zone; zone != NULL; zone = Nextzone )
{
Nextzone = zone->Next();
@ -193,6 +175,7 @@ void WinEDA_GerberFrame::Erase_Current_Layer( bool query )
continue;
zone->DeleteStructure();
}
ScreenPcb->SetModify();
ScreenPcb->SetRefreshReq();
}

20
gerbview/lay2plot.cpp
View File

@ -1,6 +1,6 @@
/**********************************************/
/* Routine de selection de couches pour trace */
/**********************************************/
/****************/
/* lay2plot.cpp */
/****************/
#include "fctsys.h"
#include "common.h"
@ -10,14 +10,8 @@
#include "protos.h"
/* Variables locales : */
/* Routines Locales */
/*******************************************************************************/
/* Routine to plot the pcb, by selected layers. */
void Print_PcbItems(BOARD * Pcb, wxDC *DC, int drawmode, int printmasklayer)
/*******************************************************************************/
/* routine de trace du pcb, avec selection des couches */
{
DISPLAY_OPTIONS save_opt;
TRACK * pt_piste;
@ -33,16 +27,12 @@ void Print_PcbItems(BOARD * Pcb, wxDC *DC, int drawmode, int printmasklayer)
DisplayOpt.DisplayDrawItems = FILLED;
DisplayOpt.DisplayZonesMode = 0;
/* trace des pistes */
pt_piste = Pcb->m_Track;
for( ; pt_piste != NULL ; pt_piste = pt_piste->Next() )
{
// if( (printmasklayer & ReturnMaskLayer(pt_piste) ) == 0 ) continue;
// if( (printmasklayer & ReturnMaskLayer(pt_piste) ) == 0 ) continue;
Trace_Segment(NULL, DC, pt_piste, drawmode);
}
DisplayOpt = save_opt;
}

373
gerbview/locate.cpp
View File

@ -1,6 +1,6 @@
/***************************************************/
/* Localisation des elements pointes par la souris */
/***************************************************/
/************************************************/
/* Locate items at the current cursor position. */
/************************************************/
#include "fctsys.h"
#include "common.h"
@ -12,50 +12,48 @@
#include "protos.h"
/* variables locales */
int ux0, uy0, dx, dy, spot_cX, spot_cY; /* Variables utilisees pour
* la localisation des segments */
/* fonctions locales */
int ux0, uy0, dx, dy, spot_cX, spot_cY;
static TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc );
static TRACK* Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer );
static TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc );
static TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer );
static TRACK* Locate_Pistes( TRACK* start_adresse,
int Layer,
int typeloc );
static TRACK* Locate_Pistes( TRACK* start_adresse,
wxPoint ref,
int Layer );
static DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc );
static TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc );
static int distance( int seuil );
/**/
/* Macro de calcul de la coord de pointage selon le curseur
* (ON/OFF grille) choisi
/* Macro for calculating the coordinates of the cursor position.
*/
#define SET_REF_POS( ref ) if( typeloc == CURSEUR_ON_GRILLE ) \
#define SET_REF_POS( ref ) if( typeloc == CURSEUR_ON_GRILLE ) \
{ ref = ActiveScreen->m_Curseur; } \
else { ref = ActiveScreen->m_MousePosition; }
/*************************************************************/
BOARD_ITEM* WinEDA_GerberFrame::Locate( int typeloc )
/*************************************************************/
/* Fonction de localisation generale
* Affiche les caract de la stucture localis<EFBFBD>e et retourne un pointeur
* sur celle-ci
/* Display the character of the localized STRUCTURE and return a pointer
* to it.
*/
BOARD_ITEM* WinEDA_GerberFrame::Locate( int typeloc )
{
TEXTE_PCB* pt_texte_pcb;
TRACK* Track, * TrackLocate;
DRAWSEGMENT* DrawSegm;
int layer;
/* Localistion des pistes et vias, avec priorite aux vias */
/* Locate tracks and vias, with priority to vias */
layer = GetScreen()->m_Active_Layer;
Track = Locate_Pistes( GetBoard()->m_Track, -1, typeloc );
if( Track != NULL )
{
TrackLocate = Track; /* Reperage d'une piste ou via */
/* recherche de 1 via eventuelle */
while( ( TrackLocate = Locate_Pistes( TrackLocate, layer, typeloc ) ) != NULL )
TrackLocate = Track;
while( ( TrackLocate = Locate_Pistes( TrackLocate,
layer, typeloc ) ) != NULL )
{
Track = TrackLocate;
if( TrackLocate->Type() == TYPE_VIA )
@ -68,8 +66,10 @@ BOARD_ITEM* WinEDA_GerberFrame::Locate( int typeloc )
}
pt_texte_pcb = Locate_Texte_Pcb( (TEXTE_PCB*) GetBoard()->m_Drawings.GetFirst(), typeloc );
if( pt_texte_pcb ) // texte type PCB localise
pt_texte_pcb = Locate_Texte_Pcb(
(TEXTE_PCB*) GetBoard()->m_Drawings.GetFirst(), typeloc );
if( pt_texte_pcb )
{
pt_texte_pcb->DisplayInfo( this );
return pt_texte_pcb;
@ -81,7 +81,8 @@ BOARD_ITEM* WinEDA_GerberFrame::Locate( int typeloc )
}
if( ( TrackLocate = Locate_Zone( GetBoard()->m_Zone,
GetScreen()->m_Active_Layer, typeloc ) ) != NULL )
GetScreen()->m_Active_Layer,
typeloc ) ) != NULL )
{
TrackLocate->DisplayInfo( this );
return TrackLocate;
@ -92,21 +93,17 @@ BOARD_ITEM* WinEDA_GerberFrame::Locate( int typeloc )
}
/********************************************************/
DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
/********************************************************/
/* Localisation de segments de contour du type edge pcb ou draw
* (selon couche active)
* Retourne:
* Pointeur sur DEBUT du segment localise
* NULL si rien trouve
/* Locate of segments of pcb edge or draw as active layer.
* Returns:
* Pointer to START segment if found
* NULL if nothing found
*/
DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
{
BOARD_ITEM* PtStruct;
DRAWSEGMENT* pts;
wxPoint ref;
PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen;
BOARD_ITEM* PtStruct;
DRAWSEGMENT* pts;
wxPoint ref;
PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen;
SET_REF_POS( ref );
@ -116,25 +113,27 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
if( PtStruct->Type() != TYPE_DRAWSEGMENT )
continue;
pts = (DRAWSEGMENT*) PtStruct;
ux0 = pts->m_Start.x; uy0 = pts->m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx = pts->m_End.x - ux0; dy = pts->m_End.y - uy0;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
ux0 = pts->m_Start.x;
uy0 = pts->m_Start.y;
dx = pts->m_End.x - ux0;
dy = pts->m_End.y - uy0;
spot_cX = ref.x - ux0;
spot_cY = ref.y - uy0;
/* detection : */
if( pts->GetLayer() != screen->m_Active_Layer )
continue;
if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
if( ( pts->m_Shape == S_CIRCLE ) || ( pts->m_Shape == S_ARC ) )
{
int rayon, dist, StAngle, EndAngle, MouseAngle;
rayon = (int) hypot( (double) (dx), (double) (dy) );
dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
if( abs( rayon - dist ) <= (pts->m_Width / 2) )
if( abs( rayon - dist ) <= ( pts->m_Width / 2 ) )
{
if( pts->m_Shape == S_CIRCLE )
return pts;
/* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente( spot_cY, spot_cX );
StAngle = (int) ArcTangente( dy, dx );
EndAngle = StAngle + pts->m_Angle;
@ -143,7 +142,7 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
{
StAngle -= 3600; EndAngle -= 3600;
}
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
if( ( MouseAngle >= StAngle ) && ( MouseAngle <= EndAngle ) )
return pts;
}
}
@ -158,19 +157,13 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
}
/****************************************************************************/
/* TRACK *Locate_Pistes(TRACK * start_adresse, int MasqueLayer,int typeloc) */
/* TRACK *Locate_Pistes(TRACK * start_adresse, wxPoint ref, int MasqueLayer)*/
/****************************************************************************/
/*
* 1 - routine de localisation du segment de piste pointe par la souris.
* 2 - routine de localisation du segment de piste pointe par le point
* ref_pX , ref_pY.r
* 1 - Locate segment of track at current cursor position.
* 2 - Locate segment of track point by point.
* Ref_pX, ref_pY.r
*
* La recherche commence a l'adresse start_adresse
* The search begins to address start_adresse
*/
TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc )
{
wxPoint ref;
@ -183,25 +176,28 @@ TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc )
TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer )
{
TRACK* Track; /* pointeur sur les pistes */
int l_piste; /* demi-largeur de la piste */
TRACK* Track;
int l_piste; /* half-width of the track */
for( Track = start_adresse; Track != NULL; Track = Track->Next() )
{
if( Track->GetState( BUSY | DELETED ) )
continue;
/* calcul des coordonnees du segment teste */
l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Track->m_Start.x; uy0 = Track->m_Start.y; /* coord de depart */
dx = Track->m_End.x; dy = Track->m_End.y; /* coord d'arrivee */
/* Calculate coordinates of the test segment. */
l_piste = Track->m_Width >> 1;
ux0 = Track->m_Start.x;
uy0 = Track->m_Start.y;
dx = Track->m_End.x;
dy = Track->m_End.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0; dy -= uy0;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
dx -= ux0;
dy -= uy0;
spot_cX = ref.x - ux0;
spot_cY = ref.y - uy0;
if( Track->Type() == TYPE_VIA ) /* VIA rencontree */
if( Track->Type() == TYPE_VIA )
{
if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) )
if( ( abs( spot_cX ) <= l_piste ) && ( abs( spot_cY ) <=l_piste ) )
{
return Track;
}
@ -210,7 +206,7 @@ TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer )
if( Layer >= 0 )
if( Track->GetLayer() != Layer )
continue;/* Segments sur couches differentes */
continue;
if( distance( l_piste ) )
return Track;
}
@ -219,22 +215,11 @@ TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer )
}
/****************************************************************/
/* TRACK * Locate_Zone(TRACK * start_adresse, int layer, */
/* int typeloc) */
/* TRACK * Locate_Zone(TRACK * start_adresse,wxPoint ref, int layer) */
/****************************************************************/
/*
* 1 - routine de localisation du segment de zone pointe par la souris.
* 2 - routine de localisation du segment de zone pointe par le point
* ref_pX , ref_pY.r
* Locate zone area at the cursor position.
*
* Si layer == -1 , le tst de la couche n'est pas fait
*
* La recherche commence a l'adresse start_adresse
* The search begins to address start_adresse
*/
TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc )
{
wxPoint ref;
@ -245,23 +230,30 @@ TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc )
}
/*
* Locate zone area at point.
*
* The search begins to address start_adresse
*/
TRACK* Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer )
{
TRACK* Zone; /* pointeur sur les pistes */
int l_segm; /* demi-largeur de la piste */
TRACK* Zone;
int l_segm;
for( Zone = start_adresse; Zone != NULL; Zone = Zone->Next() )
{
/* calcul des coordonnees du segment teste */
l_segm = Zone->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Zone->m_Start.x; uy0 = Zone->m_Start.y; /* coord de depart */
dx = Zone->m_End.x; dy = Zone->m_End.y; /* coord d'arrivee */
l_segm = Zone->m_Width >> 1;
ux0 = Zone->m_Start.x;
uy0 = Zone->m_Start.y;
dx = Zone->m_End.x;
dy = Zone->m_End.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
dx -= ux0; dy -= uy0;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
dx -= ux0;
dy -= uy0;
spot_cX = ref.x - ux0;
spot_cY = ref.y - uy0;
if( (layer != -1) && (Zone->GetLayer() != layer) )
if( ( layer != -1 ) && ( Zone->GetLayer() != layer ) )
continue;
if( distance( l_segm ) )
return Zone;
@ -271,15 +263,10 @@ TRACK* Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer )
}
/***************************************************************/
/* TEXTE_PCB * Locate_Texte_Pcb(char * pt_txt_pcb,int typeloc) */
/***************************************************************/
/* localisation des inscriptions sur le Pcb:
* entree : char pointeur sur le debut de la zone de recherche
* retour : pointeur sur la description du texte localise
/* Location of text on the PCB:
* INPUT: char pointer to the beginning of the search area
* Return: pointer to the text description located.
*/
TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc )
{
int angle;
@ -295,14 +282,17 @@ TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc )
pt_txt_pcb = (TEXTE_PCB*) PtStruct;
angle = pt_txt_pcb->m_Orient;
ux0 = pt_txt_pcb->m_Pos.x; uy0 = pt_txt_pcb->m_Pos.y;
ux0 = pt_txt_pcb->m_Pos.x;
uy0 = pt_txt_pcb->m_Pos.y;
dx = ( pt_txt_pcb->m_Size.x * pt_txt_pcb->GetLength() ) / 2;
dy = pt_txt_pcb->m_Size.y / 2;
dx *= 13; dx /= 9; /* Facteur de forme des lettres : 13/9 */
dx *= 13;
dx /= 9; /* Character for factor 13/9. */
/* la souris est-elle dans ce rectangle autour du centre */
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
/* Cursor in the rectangle around the center. */
spot_cX = ref.x - ux0;
spot_cY = ref.y - uy0;
RotatePoint( &spot_cX, &spot_cY, -angle );
if( ( abs( spot_cX ) <= abs( dx ) ) && ( abs( spot_cY ) <= abs( dy ) ) )
return pt_txt_pcb;
@ -312,155 +302,164 @@ TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc )
}
/*****************************/
/* int distance(int seuil) */
/*****************************/
/*
* Calcul de la distance du curseur souris a un segment de droite :
* ( piste, edge, contour module ..
* retourne:
* 0 si distance > seuil
* 1 si distance <= seuil
* Variables utilisees ( doivent etre initialisees avant appel , et
* sont ramenees au repere centre sur l'origine du segment)
* dx, dy = coord de l'extremite segment.
* spot_cX,spot_cY = coord du curseur souris
* la recherche se fait selon 4 cas:
* segment horizontal
* segment vertical
* segment 45
* segment quelconque
* Calculate the distance from the cursor to a line segment:
* (Track, edge, contour module ..
* Returns:
* 0 if distance > threshold
* 1 if distance <= threshold
* Variables used (must be initialized before use, and
* are brought to the mark center on the origin of the segment)
* dx, dy = coord of extremity segment.
* spot_cX, spot_cY = coord of mouse cursor
* Search 4 cases:
* Horizontal segment
* Vertical segment
* Segment 45
* Any segment
*/
int distance( int seuil )
{
int cXrot, cYrot, /* coord du point (souris) dans le repere tourne */
segX, segY; /* coord extremite segment tj >= 0 */
int pointX, pointY;/* coord point a tester dans repere modifie dans lequel
* segX et segY sont >=0 */
int cXrot, cYrot, segX, segY;
int pointX, pointY;
segX = dx; segY = dy; pointX = spot_cX; pointY = spot_cY;
segX = dx;
segY = dy;
pointX = spot_cX;
pointY = spot_cY;
/*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
if( segX < 0 ) /* mise en >0 par symetrie par rapport a l'axe Y */
/* Reroute coordinate for the segment in 1st quadrant (coord> = 0). */
if( segX < 0 ) /* Set > 0 if symmetrical about the axis Y. */
{
segX = -segX; pointX = -pointX;
segX = -segX;
pointX = -pointX;
}
if( segY < 0 ) /* mise en > 0 par symetrie par rapport a l'axe X */
if( segY < 0 ) /* Set > 0 if symmetrical about the axis X. */
{
segY = -segY; pointY = -pointY;
segY = -segY;
pointY = -pointY;
}
if( segY == 0 ) /* piste Horizontale */
if( segY == 0 ) /* Horizontal track. */
{
if( abs( pointY ) <= seuil )
{
if( (pointX >= 0) && (pointX <= segX) )
if( ( pointX >= 0 ) && ( pointX <= segX ) )
return 1;
/* Etude des extremites : cercle de rayon seuil */
if( (pointX < 0) && (pointX >= -seuil) )
if( ( pointX < 0 ) && ( pointX >= -seuil ) )
{
if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) )
if( ( ( pointX * pointX ) + ( pointY * pointY ) ) <=
( seuil * seuil ) )
return 1;
}
if( (pointX > segX) && ( pointX <= (segX + seuil) ) )
if( ( pointX > segX ) && ( pointX <= ( segX + seuil ) ) )
{
if( ( ( (pointX - segX) * (pointX - segX) ) + (pointY * pointY) ) <=
(seuil * seuil) )
if( ( ( ( pointX - segX ) * ( pointX - segX ) ) +
( pointY * pointY ) ) <= ( seuil * seuil ) )
return 1;
}
}
}
else if( segX == 0 ) /* piste verticale */
else if( segX == 0 ) /* Vertical track. */
{
if( abs( pointX ) <= seuil )
{
if( (pointY >= 0 ) && (pointY <= segY) )
if( ( pointY >= 0 ) && ( pointY <= segY ) )
return 1;
if( (pointY < 0) && (pointY >= -seuil) )
if( ( pointY < 0 ) && ( pointY >= -seuil ) )
{
if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) )
if( ( (pointY * pointY ) + ( pointX * pointX ) ) <=
( seuil * seuil ) )
return 1;
}
if( (pointY > segY) && ( pointY <= (segY + seuil) ) )
if( ( pointY > segY ) && ( pointY <= ( segY + seuil ) ) )
{
if( ( ( (pointY - segY) * (pointY - segY) ) + (pointX * pointX) ) <=
(seuil * seuil) )
if( ( ( ( pointY - segY ) * ( pointY - segY ) ) +
( pointX * pointX ) ) <= ( seuil * seuil ) )
return 1;
}
}
}
else if( segX == segY ) /* piste a 45 degre */
else if( segX == segY ) /* 45 degree track. */
{
/* on fait tourner les axes de 45 degre. la souris a alors les
* coord : x1 = x*cos45 + y*sin45
* y1 = y*cos45 - x*sin45
* et le segment de piste est alors horizontal.
* recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
* remarque : sin ou cos45 = .707, et lors du recalcul des coord
* dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
* trop grands. (c.a.d trop petits)
* spot_cX,Y doit etre * par .707 * .707 = 0.5 */
/* You spin axes of 45 degrees. mouse was then
* coord: x1 = x * y * cos45 + sin45
* y1 = y * cos45 - sin45 x *
* And the segment of track is horizontal.
* coord recalculation of the mouse (sin45 = cos45 = .707 = 7 / 10
* Note: sin or cos45 = .707, and when recalculating coord
* dX45 and dy45, lect coeff .707 is neglected, dx and dy are both
* actually .707
* too big. (security hole too small)
* spot_cX *, Y * must be by .707 * .707 = 0.5
*/
cXrot = (pointX + pointY) >> 1;
cYrot = (pointY - pointX) >> 1;
/* recalcul des coord de l'extremite du segment , qui sera vertical
* suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
* et est en fait 1,414 plus grand , et dy45 = 0 */
// seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
/* Recalculate coordinates of extremity segment, which will be vertical
* following the orientation of axes on the screen: DX45 = pointx
* (or pointy) and 1.414 is actually greater, and dy45 = 0
*
* Threshold should be .707 to reflect the difference in coeff dx, dy
*/
seuil *= 7; seuil /= 10;
if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
if( abs( cYrot ) <= seuil )
{
if( (cXrot >= 0) && (cXrot <= segX) )
if( ( cXrot >= 0 ) && ( cXrot <= segX ) )
return 1;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
if( ( cXrot < 0 ) && ( cXrot >= -seuil ) )
{
if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
if( ( ( cXrot * cXrot ) + ( cYrot * cYrot ) )
<= ( seuil * seuil ) )
return 1;
}
if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
if( ( cXrot > segX ) && ( cXrot <= ( segX + seuil ) ) )
{
if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
if( ( ( ( cXrot - segX ) * ( cXrot - segX ) ) +
( cYrot * cYrot ) ) <= ( seuil * seuil ) )
return 1;
}
}
}
else /* orientation quelconque */
else /* Any orientation. */
{
/* On fait un changement d'axe (rotation) de facon a ce que le segment
* de piste soit horizontal dans le nouveau repere */
/* There is a change of axis (rotation), so that the segment
* track is horizontal in the new reference, */
int angle;
angle = (int) ( atan2( (double) segY, (double) segX ) * 1800 / M_PI);
cXrot = pointX; cYrot = pointY;
RotatePoint( &cXrot, &cYrot, angle ); /* Rotation du point a tester */
RotatePoint( &segX, &segY, angle ); /* Rotation du segment */
cXrot = pointX;
cYrot = pointY;
RotatePoint( &cXrot, &cYrot, angle ); /* Rotate test point. */
RotatePoint( &segX, &segY, angle ); /* Rotate segment. */
/*la piste est Horizontale , par suite des modifs de coordonnes
* et d'axe, donc segX = longueur du segment */
/* The track is horizontal, following the changes to coordinate
* axis and, therefore segX = length of segment
*/
if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
if( abs( cYrot ) <= seuil )
{
if( (cXrot >= 0) && (cXrot <= segX) )
if( ( cXrot >= 0 ) && ( cXrot <= segX ) )
return 1;
/* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) )
if( ( cXrot < 0 ) && ( cXrot >= -seuil ) )
{
if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
if( ( ( cXrot * cXrot ) + ( cYrot * cYrot ) )
<= ( seuil * seuil ) )
return 1;
}
if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
if( ( cXrot > segX ) && ( cXrot <= ( segX + seuil ) ) )
{
if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
if( ( ( ( cXrot - segX ) * ( cXrot - segX ) ) +
( cYrot * cYrot ) ) <= ( seuil * seuil ) )
return 1;
}
}
}
return 0;
}

50
gerbview/onrightclick.cpp
View File

@ -1,6 +1,6 @@
/******************************************************/
/* edit.cpp: fonctions generales de l'edition du PCB */
/******************************************************/
/********************/
/* onrightclick.cpp */
/********************/
#include "fctsys.h"
#include "common.h"
@ -11,27 +11,28 @@
#include "pcbplot.h"
#include "protos.h"
/********************************************************************************/
bool WinEDA_GerberFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu )
/********************************************************************************/
/* Prepare the right-click pullup menu.
* The menu already has a list of zoom commands.
*/
bool WinEDA_GerberFrame::OnRightClick( const wxPoint& MousePos,
wxMenu* PopMenu )
{
BOARD_ITEM* DrawStruct = GetScreen()->GetCurItem();
wxString msg;
bool BlockActive = (GetScreen()->m_BlockLocate.m_Command != BLOCK_IDLE);
BOARD_ITEM* DrawStruct = GetScreen()->GetCurItem();
wxString msg;
bool BlockActive =
(GetScreen()->m_BlockLocate.m_Command != BLOCK_IDLE);
DrawPanel->m_CanStartBlock = -1; // Ne pas engager un debut de bloc sur validation menu
// Do not initiate a start block validation on menu.
DrawPanel->m_CanStartBlock = -1;
// Simple localisation des elements si possible
if( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
// Simple location of elements where possible.
if( ( DrawStruct == NULL ) || ( DrawStruct->m_Flags == 0 ) )
{
DrawStruct = GerberGeneralLocateAndDisplay();
}
// Si commande en cours: affichage fin de commande
// If command in progress, end command.
if( m_ID_current_state )
{
if( DrawStruct && DrawStruct->m_Flags )
@ -46,16 +47,21 @@ bool WinEDA_GerberFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
{
if( BlockActive )
{
PopMenu->Append( ID_POPUP_CANCEL_CURRENT_COMMAND, _( "Cancel Block" ) );
PopMenu->Append( ID_POPUP_ZOOM_BLOCK, _( "Zoom Block (drag middle mouse)" ) );
PopMenu->Append( ID_POPUP_CANCEL_CURRENT_COMMAND,
_( "Cancel Block" ) );
PopMenu->Append( ID_POPUP_ZOOM_BLOCK,
_( "Zoom Block (drag middle mouse)" ) );
PopMenu->AppendSeparator();
PopMenu->Append( ID_POPUP_PLACE_BLOCK, _( "Place Block" ) );
PopMenu->Append( ID_POPUP_COPY_BLOCK, _( "Copy Block (shift mouse)" ) );
PopMenu->Append( ID_POPUP_DELETE_BLOCK, _( "Delete Block (ctrl + drag mouse)" ) );
PopMenu->Append( ID_POPUP_COPY_BLOCK,
_( "Copy Block (shift mouse)" ) );
PopMenu->Append( ID_POPUP_DELETE_BLOCK,
_( "Delete Block (ctrl + drag mouse)" ) );
PopMenu->Append( ID_POPUP_MIRROR_X_BLOCK, _( "Mirror Block" ) );
}
else
PopMenu->Append( ID_POPUP_CANCEL_CURRENT_COMMAND, _( "Cancel" ) );
PopMenu->Append( ID_POPUP_CANCEL_CURRENT_COMMAND,
_( "Cancel" ) );
PopMenu->AppendSeparator();
}
}
@ -63,7 +69,8 @@ bool WinEDA_GerberFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
if( BlockActive )
return true;
PopMenu->Append( ID_GERBVIEW_POPUP_DELETE_DCODE_ITEMS, _( "Delete Dcode items" ) );
PopMenu->Append( ID_GERBVIEW_POPUP_DELETE_DCODE_ITEMS,
_( "Delete Dcode items" ) );
if( DrawStruct == NULL )
return true;
@ -81,9 +88,8 @@ bool WinEDA_GerberFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
default:
msg.Printf(
wxT( "WinEDA_GerberFrame::OnRightClick Error: illegal or unknown DrawType %d" ),
DrawStruct->Type() );
msg.Printf( wxT( "WinEDA_GerberFrame::OnRightClick Error: illegal or unknown DrawType %d" ),
DrawStruct->Type() );
DisplayError( this, msg );
break;
}

49
gerbview/options.cpp
View File

@ -1,8 +1,6 @@
/********************************************/
/* GERBVIEW - Gestion des Options et Reglages */
/********************************************/
/* File options.cpp */
/************************/
/* File options.cpp */
/************************/
/*
* Set the display options for Gerbview
@ -21,13 +19,10 @@
#include <wx/spinctrl.h>
/*****************************************************************/
void WinEDA_GerberFrame::OnSelectOptionToolbar( wxCommandEvent& event )
/*****************************************************************/
/** Function OnSelectOptionToolbar
* called to validate current choices
*/
void WinEDA_GerberFrame::OnSelectOptionToolbar( wxCommandEvent& event )
{
int id = event.GetId();
@ -112,7 +107,7 @@ void WinEDA_GerberFrame::OnSelectOptionToolbar( wxCommandEvent& event )
default:
DisplayError( this,
wxT( "WinEDA_PcbFrame::OnSelectOptionToolbar error" ) );
wxT( "WinEDA_PcbFrame::OnSelectOptionToolbar error" ) );
break;
}
@ -120,9 +115,7 @@ void WinEDA_GerberFrame::OnSelectOptionToolbar( wxCommandEvent& event )
}
/******************************************************/
class WinEDA_GerberGeneralOptionsFrame : public wxDialog
/******************************************************/
{
private:
@ -132,7 +125,6 @@ private:
wxRadioBox* m_CursorShape;
wxRadioBox* m_GerberDefaultScale;
// Constructor and destructor
public:
WinEDA_GerberGeneralOptionsFrame( WinEDA_BasePcbFrame* parent,
const wxPoint& pos );
@ -145,25 +137,19 @@ private:
DECLARE_EVENT_TABLE()
};
/* Events table for WinEDA_GerberGeneralOptionsFrame */
BEGIN_EVENT_TABLE( WinEDA_GerberGeneralOptionsFrame, wxDialog )
EVT_BUTTON( wxID_OK, WinEDA_GerberGeneralOptionsFrame::OnOkClick )
EVT_BUTTON( wxID_CANCEL, WinEDA_GerberGeneralOptionsFrame::OnCancelClick )
END_EVENT_TABLE()
/**********************************************************************************************/
WinEDA_GerberGeneralOptionsFrame::WinEDA_GerberGeneralOptionsFrame(
WinEDA_BasePcbFrame* parent,
const
wxPoint& framepos ) :
const wxPoint& framepos ) :
wxDialog( parent, -1, _( "Gerbview Options" ),
framepos, wxSize( 300, 240 ),
wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT )
/**********************************************************************************************/
/** WinEDA_GerberGeneralOptionsFrame Constructor
*/
{
m_Parent = parent;
@ -228,18 +214,14 @@ WinEDA_GerberGeneralOptionsFrame::WinEDA_GerberGeneralOptionsFrame(
}
/************************************************************************/
void WinEDA_GerberGeneralOptionsFrame::OnCancelClick(
wxCommandEvent& WXUNUSED(event) )
/************************************************************************/
{
EndModal( -1 );
}
/*****************************************************************************/
void WinEDA_GerberGeneralOptionsFrame::OnOkClick( wxCommandEvent& event )
/*****************************************************************************/
{
DisplayOpt.DisplayPolarCood =
(m_PolarDisplay->GetSelection() == 0) ? FALSE : TRUE;
@ -253,7 +235,7 @@ void WinEDA_GerberGeneralOptionsFrame::OnOkClick( wxCommandEvent& event )
/*******************************************/
/* Dialog frame to select deisplay options */
/* Dialog frame to select display options */
/*******************************************/
class WinEDA_LookFrame : public wxDialog
{
@ -261,14 +243,13 @@ private:
WinEDA_BasePcbFrame* m_Parent;
wxRadioBox* m_OptDisplayLines;
wxRadioBox* m_OptDisplayFlashes;
wxRadioBox* m_OptDisplayVias; //@@@@TODO: Does it belong here?
wxRadioBox* m_OptDisplayVias; //@@@@TODO: Does it belong here?
wxRadioBox* m_OptDisplayPolygons;
wxCheckBox* m_OptDisplayDCodes;
wxRadioBox* m_OptDisplayDrawings;
public:
// Constructor and destructor
WinEDA_LookFrame( WinEDA_BasePcbFrame* parent, const wxPoint& pos );
~WinEDA_LookFrame() {};
@ -279,20 +260,17 @@ private:
DECLARE_EVENT_TABLE()
};
/* Construction de la table des evenements pour WinEDA_LookFrame */
BEGIN_EVENT_TABLE( WinEDA_LookFrame, wxDialog )
EVT_BUTTON( wxID_OK, WinEDA_LookFrame::OnOkClick )
EVT_BUTTON( wxID_CANCEL, WinEDA_LookFrame::OnCancelClick )
END_EVENT_TABLE()
/*******************************************************************************/
WinEDA_LookFrame::WinEDA_LookFrame( WinEDA_BasePcbFrame* parent,
const wxPoint& framepos ) :
wxDialog( parent, -1, _( "Gerbview Draw Options" ), framepos,
wxSize( 350, 200 ),
wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT )
/*******************************************************************************/
{
m_Parent = parent;
@ -362,20 +340,13 @@ WinEDA_LookFrame::WinEDA_LookFrame( WinEDA_BasePcbFrame* parent,
}
/**************************************************************/
void WinEDA_LookFrame::OnCancelClick( wxCommandEvent& WXUNUSED(event) )
/**************************************************************/
{
EndModal( -1 );
}
/*************************************************************/
void WinEDA_LookFrame::OnOkClick( wxCommandEvent& event )
/*************************************************************/
/* Met a jour les options
*/
{
if( m_OptDisplayLines->GetSelection() == 1 )
DisplayOpt.DisplayPcbTrackFill = TRUE;
@ -412,9 +383,7 @@ void WinEDA_LookFrame::OnOkClick( wxCommandEvent& event )
}
/***************************************************************************/
void WinEDA_GerberFrame::InstallGerberOptionsFrame( const wxPoint& pos, int id )
/***************************************************************************/
{
switch( id )
{

16
gerbview/pcbplot.cpp
View File

@ -1,6 +1,6 @@
/************************************************/
/* Menu General de Trace (PLOT) fichier PLOT.CC */
/************************************************/
/***************/
/* pcbplot.cpp */
/***************/
#include "fctsys.h"
#include "common.h"
@ -15,13 +15,9 @@
PCB_Plot_Options g_pcb_plot_options;
/* variables locale : */
/* Routines Locales */
/**************************************************************/
/* void WinEDA_BasePcbFrame::ToPlotter(wxCommandEvent& event) */
/***************************************************************/
/**************************************************************/
/* void WinEDA_BasePcbFrame::ToPlotter(wxCommandEvent& event) */
/***************************************************************/
void WinEDA_BasePcbFrame::ToPlotter(wxCommandEvent& event)
{

19
gerbview/pcbplot.h
View File

@ -13,30 +13,32 @@
#define OPTKEY_PRINT_SCALE wxT( "PrintScale" )
/* Plot Options : */
struct PCB_Plot_Options {
struct PCB_Plot_Options
{
bool Exclude_Edges_Pcb;
int PlotLine_Width;
bool Plot_Frame_Ref; // True to plot/print frame references
bool DrawViaOnMaskLayer; // True if vias are drawn on Mask layer (ie protected by mask)
bool DrawViaOnMaskLayer; // True if vias are drawn on Mask layer
// (ie protected by mask)
int Plot_Mode;
bool Plot_Set_MIROIR;
bool Sel_Rotate_Window;
int HPGL_Pen_Num;
int HPGL_Pen_Num;
int HPGL_Pen_Speed;
int HPGL_Pen_Diam;
int HPGL_Pen_Recouvrement;
bool HPGL_Org_Centre; // TRUE si en HPGL, l'origine le centre de la feuille
bool HPGL_Org_Centre; // TRUE if, HPGL originally the center of the node
int PlotPSColorOpt; // True for color Postscript output
bool Plot_PS_Negative; // True to create a negative board ps plot
bool Plot_PS_Negative; // True to create a negative board ps plot
/* Autorisation de trace des divers items en serigraphie */
/* Settings to trace the various items in silkscreen. */
bool Sel_Texte_Reference;
bool Sel_Texte_Valeur;
bool Sel_Texte_Divers;
bool Sel_Texte_Invisible;
bool PlotPadsOnSilkLayer;
bool Plot_Pads_All_Layers; /* Plot pads meme n'appartenant pas a la
couche ( utile pour serigraphie) */
/* Plot pads even outside the layer (useful for silkscreen) */
bool Plot_Pads_All_Layers;
/* id for plot format (see enum PlotFormat in plot_common.h) */
int PlotFormat;
@ -49,4 +51,3 @@ struct PCB_Plot_Options {
extern PCB_Plot_Options g_pcb_plot_options;
#endif // ifndef PCBPLOT_H

207
gerbview/readgerb.cpp
View File

@ -1,6 +1,6 @@
/********************************************************/
/**** Routine de lecture et visu d'un fichier GERBER ****/
/********************************************************/
/**********************/
/**** readgerb.cpp ****/
/**********************/
#include "fctsys.h"
#include "common.h"
@ -11,121 +11,113 @@
#include "pcbplot.h"
#include "protos.h"
/* Format Gerber : NOTES :
* Fonctions preparatoires:
* Gn =
* G01 interpolation lineaire ( trace de droites )
* G02,G20,G21 Interpolation circulaire , sens trigo < 0
* G03,G30,G31 Interpolation circulaire , sens trigo > 0
* G04 commentaire
* G06 Interpolation parabolique
* G07 Interpolation cubique
* G10 interpolation lineaire ( echelle 10x )
* G11 interpolation lineaire ( echelle 0.1x )
* G12 interpolation lineaire ( echelle 0.01x )
* G52 plot symbole reference par Dnn code
* G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
* G54 Selection d'outil
* G55 Mode exposition photo
* G56 plot symbole reference par Dnn A code
* G57 affiche le symbole reference sur la console
* G58 plot et affiche le symbole reference sur la console
* G60 interpolation lineaire ( echelle 100x )
* G70 Unites = Inches
* G71 Unites = Millimetres
* G74 supprime interpolation circulaire sur 360 degre, revient a G01
* G75 Active interpolation circulaire sur 360 degre
* G90 Mode Coordonnees absolues
* G91 Mode Coordonnees Relatives
/* Format Gerber: NOTES:
* Functions history:
* Gn =
* G01 linear interpolation (right trace)
* G02, G20, G21 Circular interpolation, meaning trig <0
* G03, G30, G31 Circular interpolation, meaning trigo> 0
* G04 review
* G06 parabolic interpolation
* G07 Cubic Interpolation
* G10 linear interpolation (scale x10)
* G11 linear interpolation (0.1x range)
* G12 linear interpolation (0.01x scale)
* G52 plot symbol reference code by Dnn
* G53 plot symbol reference by Dnn; symbol rotates from -90 degrees
* G54 Selection Tool
* G55 Fashion photo exhibition
* G56 plot symbol reference code for DNN
* G57 displays the symbol link to the console
* G58 plot displays the symbol and link to the console
* G60 linear interpolation (scale x100)
* G70 Units = Inches
* G71 Units = Millimeters
* G74 circular interpolation removes 360 degree, has returned G01
* G75 Active circular interpolation on 360 degree
* G90 mode absolute coordinates
* G91 Fashion Related Contacts
*
* Coordonnees X,Y
* X,Y sont suivies de + ou - et de m+n chiffres (non separes)
* m = partie entiere
* n = partie apres la virgule
* formats classiques : m = 2, n = 3 (format 2.3)
* m = 3, n = 4 (format 3.4)
* ex:
* G__ X00345Y-06123 D__*
* X, Y coordinates
* X and Y are followed by + or - and m + n digits (not separated)
* m = integer part
* n = part after the comma
* Classic formats: m = 2, n = 3 (size 2.3)
* m = 3, n = 4 (size 3.4)
* eg
* G__ X00345Y-06123 * D__
*
* Outils et D_CODES
* numero d'outil ( identification des formes )
* 1 a 99 (classique)
* 1 a 999
* D_CODES:
* Tools and D_CODES
* Tool number (identification of shapes)
* 1 to 99 (Classical)
* 1 to 999
* D_CODES:
*
* D01 ... D9 = codes d'action:
* D01 = activation de lumiere (baisser de plume) lors du d<EFBFBD>placement
* D02 = extinction de lumiere (lever de plume) lors du d<EFBFBD>placement
* D03 = Flash
* D09 = VAPE Flash
* D51 = precede par G54 -> Select VAPE
* D01 ... D9 = action codes:
* D01 = activating light (lower pen) when placement
* D02 = light extinction (lift pen) when placement
* D03 = Flash
* D09 = VAPE Flash
* D51 = G54 preceded by -> Select VAPE
*
* D10 ... D255 = Indentification d'outils ( d'ouvertures )
* Ne sont pas tj dans l'ordre ( voir tableau dans PCBPLOT.H)
* D10 ... D255 = Identification Tool (Opening)
* Not in order (see table in PCBPLOT.H)
*/
/* Variables locales : */
/* Routines Locales */
/* Routine de Lecture d'un fichier de D Codes.
* Accepte format standard ou ALSPCB
* un ';' demarre un commentaire.
/* Routine to Read a file D Codes.
* Accepts standard format or ALSPCB
* A ';' starts a comment.
*
* Format Standard:
* tool, Horiz, Vert, drill, vitesse, acc. ,Type ; [DCODE (commentaire)]
* ex: 1, 12, 12, 0, 0, 0, 3 ; D10
* Standard Format:
* Tool, Horiz, Vert, drill, speed, acc. Type; [dCode (comment)]
* Ex: 1, 12, 12, 0, 0, 0, 3; D10
*
* Format ALSPCB:
* Ver , Hor , Type , Tool [,Drill]
* ex: 0.012, 0.012, L , D10
* Format: ALSPCB
* Ver, Hor, Type, Tool, [Drill]
* Eg 0012, 0012, L, D10
*
* Classe les caract en buf_tmp sous forme de tableau de structures D_CODE.
* Retourne:
* < 0 si erreur:
* -1 = Fichier non trouve
* -2 = Erreur lecture fichier
* Rang de D_code maxi lu ( nbr de dcodes )
* Rank the characters in buf_tmp tabular structures D_CODE.
* Returns:
* <0 if error:
* -1 = File not found
* -2 = Error reading file
* Rank D_code max lu (nbr of dCode)
*
* Internal Representation:
*
* Representation interne:
*
* Les lignes sont repr<EFBFBD>sent<EFBFBD>es par des TRACKS standards
* Les Flash sont repr<EFBFBD>sent<EFBFBD>es par des DRAWSEGMENTS
* - ronds ou ovales: DRAWSEGMENTS
* - rectangles: DRAWSEGMENTS
* la reference aux D-CODES est plac<EFBFBD>e dans le membre GetNet()
* Lines are represented as standard TRACKS
* The flash is represented as DRAWSEGMENTS
* - Round or oval: DRAWSEGMENTS
* - Rectangles DRAWSEGMENTS
* Reference to the D-CODE is set in the member Getnet()
*/
/********************************************************/
/* Read a gerber file (RS274D gold RS274X format).
* Normal size:
* Imperial
* Absolute
* End of block = *
* CrLf after each command
* G codes BROKE
*/
bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
const wxString& GERBER_FullFileName,
const wxString& D_Code_FullFileName )
/********************************************************/
/* Read a gerber file (RS274D or RS274X format).
* Normal format:
* Imperial
* Absolute
* end of block = *
* CrLf after each command
* G codes repetes
*/
{
int G_commande = 0,
D_commande = 0; /* command number for G et D commands (like G04 or D02) */
int G_commande = 0,
D_commande = 0; /* command number for G or D commands
* (like G04 or D02) */
char line[GERBER_BUFZ];
char line[GERBER_BUFZ];
wxString msg;
char* text;
int layer; /* current layer used in gerbview */
GERBER* gerber;
wxPoint pos;
int error = 0;
wxString msg;
char* text;
int layer; /* current layer used in gerbview */
GERBER* gerber;
wxPoint pos;
int error = 0;
layer = GetScreen()->m_Active_Layer;
@ -155,11 +147,11 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
wxSetWorkingDirectory( path );
wxBusyCursor show_wait;
SetLocaleTo_C_standard( );
SetLocaleTo_C_standard();
while( TRUE )
{
if( fgets( line, sizeof(line), gerber->m_Current_File ) == NULL ) // E.O.F
if( fgets( line, sizeof(line), gerber->m_Current_File ) == NULL )
{
if( gerber->m_FilesPtr == 0 )
break;
@ -185,7 +177,7 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
text++;
break;
case '*': // End commande
case '*': // End command
gerber->m_CommandState = END_BLOCK;
text++;
break;
@ -202,7 +194,8 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
gerber->Execute_G_Command( text, G_commande );
break;
case 'D': /* Line type Dxx : Tool selection (xx > 0) or command if xx = 0..9*/
case 'D': /* Line type Dxx : Tool selection (xx > 0) or
* command if xx = 0..9 */
D_commande = gerber->ReturnDCodeNumber( text );
gerber->Execute_DCODE_Command( this, DC, text, D_commande );
break;
@ -251,15 +244,16 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
if( error )
{
msg.Printf( _( "%d errors while reading Gerber file [%s]" ),
error, GERBER_FullFileName.GetData() );
error, GERBER_FullFileName.GetData() );
DisplayError( this, msg );
}
fclose( gerber->m_Current_File );
SetLocaleTo_Default( );
SetLocaleTo_Default();
/* Init DCodes list and perhaps read a DCODES file,
* if the gerber file is only a RS274D file (without any aperture information)
/* Init DCodes list and perhaps read a DCODES file,
* if the gerber file is only a RS274D file (without any aperture
* information)
*/
if( !gerber->m_Has_DCode )
{
@ -272,7 +266,8 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC* DC,
fn = GERBER_FullFileName;
fn.SetExt( g_PenFilenameExt );
wildcard.Printf( _( "Gerber DCODE files (%s)|*.%s" ),
GetChars( g_PenFilenameExt ), GetChars( g_PenFilenameExt ));
GetChars( g_PenFilenameExt ),
GetChars( g_PenFilenameExt ) );
wildcard += AllFilesWildcard;
wxFileDialog dlg( this, _( "Load GERBER DCODE File" ),

36
gerbview/reglage.cpp
View File

@ -1,8 +1,6 @@
/**********************************************/
/* GERBVIEW - Gestion des Options et Reglages */
/**********************************************/
/* Fichier reglage.cpp */
/***************/
/* reglage.cpp */
/***************/
/*
* Options for file extensions
@ -16,13 +14,12 @@
#include "pcbplot.h"
#include "protos.h"
/***********/
enum {
enum
{
ID_SAVE_CFG = 1000
};
/* Routines Locales */
class WinEDA_ConfigFrame : public wxDialog
{
@ -36,7 +33,6 @@ private:
WinEDA_EnterText* TextPhotoExt;
WinEDA_EnterText* TextPenExt;
// Constructor and destructor
public:
WinEDA_ConfigFrame( WinEDA_GerberFrame* parent, const wxPoint& pos );
~WinEDA_ConfigFrame() { };
@ -48,7 +44,8 @@ private:
DECLARE_EVENT_TABLE()
};
/* Construction de la table des evenements pour WinEDA_ConfigFrame */
BEGIN_EVENT_TABLE( WinEDA_ConfigFrame, wxDialog )
EVT_BUTTON( ID_SAVE_CFG, WinEDA_ConfigFrame::SaveCfg )
EVT_BUTTON( wxID_OK, WinEDA_ConfigFrame::OnOkClick )
@ -56,14 +53,11 @@ BEGIN_EVENT_TABLE( WinEDA_ConfigFrame, wxDialog )
END_EVENT_TABLE()
/*****************************************************************/
void WinEDA_GerberFrame::InstallConfigFrame( const wxPoint& pos )
/*****************************************************************/
/** Function InstallConfigFrame
* install the dialog box to configure some gerbview options
* manly the default file extensions
* install the dialog box to configure some gerbview options
* mainly the default file extensions
*/
void WinEDA_GerberFrame::InstallConfigFrame( const wxPoint& pos )
{
WinEDA_ConfigFrame* CfgFrame = new WinEDA_ConfigFrame( this, pos );
@ -72,19 +66,17 @@ void WinEDA_GerberFrame::InstallConfigFrame( const wxPoint& pos )
}
/************************************************************/
WinEDA_ConfigFrame::WinEDA_ConfigFrame( WinEDA_GerberFrame* parent,
const wxPoint& framepos ) :
wxDialog( parent, -1, wxEmptyString, framepos, wxSize( 300, 180 ),
wxDEFAULT_DIALOG_STYLE | wxFRAME_FLOAT_ON_PARENT )
/************************************************************/
{
const int LEN_EXT = 100;
wxString title;
m_Parent = parent;
/* Shows the config filename currently used : */
/* Shows the config filename currently used : */
title = _( "from " ) + wxGetApp().m_CurrentOptionFile;
SetTitle( title );
@ -132,9 +124,7 @@ WinEDA_ConfigFrame::WinEDA_ConfigFrame( WinEDA_GerberFrame* parent,
}
/******************************************************************/
void WinEDA_ConfigFrame::OnOkClick( wxCommandEvent& WXUNUSED (event) )
/******************************************************************/
{
g_DrillFilenameExt = TextDrillExt->GetValue();
g_PhotoFilenameExt = TextPhotoExt->GetValue();
@ -144,17 +134,13 @@ void WinEDA_ConfigFrame::OnOkClick( wxCommandEvent& WXUNUSED (event) )
}
/******************************************************************/
void WinEDA_ConfigFrame::OnCancelClick( wxCommandEvent& WXUNUSED (event) )
/******************************************************************/
{
EndModal( -1 );
}
/******************************************************/
void WinEDA_ConfigFrame::SaveCfg( wxCommandEvent& event )
/******************************************************/
{
m_Parent->Update_config();
}

260
gerbview/rs274d.cpp
View File

@ -1,6 +1,6 @@
/********************************************************/
/**** Routine de lecture et visu d'un fichier GERBER ****/
/********************************************************/
/********************/
/**** rs274d.cpp ****/
/********************/
#include "fctsys.h"
@ -14,74 +14,75 @@
#define IsNumber( x ) ( ( ( (x) >= '0' ) && ( (x) <='9' ) ) \
|| ( (x) == '-' ) || ( (x) == '+' ) || ( (x) == '.' ) )
/* Format Gerber : NOTES :
* Fonctions preparatoires:
* Gn =
* G01 interpolation lineaire ( trace de droites )
* G02,G20,G21 Interpolation circulaire , sens trigo < 0
* G03,G30,G31 Interpolation circulaire , sens trigo > 0
* G04 commentaire
* G06 Interpolation parabolique
* G07 Interpolation cubique
* G10 interpolation lineaire ( echelle 10x )
* G11 interpolation lineaire ( echelle 0.1x )
* G12 interpolation lineaire ( echelle 0.01x )
* G52 plot symbole reference par Dnn code
* G53 plot symbole reference par Dnn ; symbole tourne de -90 degres
* G54 Selection d'outil
* G55 Mode exposition photo
* G56 plot symbole reference par Dnn A code
* G57 affiche le symbole reference sur la console
* G58 plot et affiche le symbole reference sur la console
* G60 interpolation lineaire ( echelle 100x )
* G70 Unites = Inches
* G71 Unites = Millimetres
* G74 supprime interpolation circulaire sur 360 degre, revient a G01
* G75 Active interpolation circulaire sur 360 degre
* G90 Mode Coordonnees absolues
* G91 Mode Coordonnees Relatives
/* Format Gerber: NOTES:
* Functions history:
* Gn =
* G01 linear interpolation (right trace)
* G02, G20, G21 Circular interpolation, meaning trig <0
* G03, G30, G31 Circular interpolation, meaning trigo> 0
* G04 review
* G06 parabolic interpolation
* G07 Cubic Interpolation
* G10 linear interpolation (scale x10)
* G11 linear interpolation (0.1x range)
* G12 linear interpolation (0.01x scale)
* G52 plot symbol reference code by Dnn
* G53 plot symbol reference by Dnn; symbol rotates from -90 degrees
* G54 Selection Tool
* G55 Fashion photo exhibition
* G56 plot symbol reference code for DNN
* G57 displays the symbol link to the console
* G58 plot displays the symbol and link to the console
* G60 linear interpolation (scale x100)
* G70 Units = Inches
* G71 Units = Millimeters
* G74 circular interpolation removes 360 degree, has returned G01
* Active G75 circular interpolation on 360 degree
* G90 mode absolute coordinates
* G91 Fashion Related Contacts
*
* Coordonnees X,Y
* X,Y sont suivies de + ou - et de m+n chiffres (non separes)
* m = partie entiere
* n = partie apres la virgule
* formats classiques : m = 2, n = 3 (format 2.3)
* m = 3, n = 4 (format 3.4)
* ex:
* G__ X00345Y-06123 D__*
* X, Y
* X and Y are followed by + or - and m + n digits (not separated)
* m = integer part
* n = part after the comma
* Classic formats: m = 2, n = 3 (size 2.3)
* m = 3, n = 4 (size 3.4)
* eg
* G__ X00345Y-06123 * D__
*
* Outils et D_CODES
* numero d'outil ( identification des formes )
* 1 a 99 (classique)
* 1 a 999
* D_CODES:
* Tools and D_CODES
* Tool number (identification of shapes)
* 1 to 99 (Classical)
* 1 to 999
* D_CODES:
*
* D01 ... D9 = codes d'action:
* D01 = activation de lumiere (baisser de plume) lors du d<EFBFBD>placement
* D02 = extinction de lumiere (lever de plume) lors du d<EFBFBD>placement
* D03 = Flash
* D09 = VAPE Flash
* D51 = precede par G54 -> Select VAPE
* D01 ... D9 = action codes:
* D01 = activating light (lower pen) when placement
* D02 = light extinction (lift pen) when placement
* D03 = Flash
* D09 = VAPE Flash
* D51 = G54 preceded by -> Select VAPE
*
* D10 ... D255 = Indentification d'outils ( d'ouvertures )
* Ne sont pas tj dans l'ordre ( voir tableau dans PCBPLOT.H)
* D10 ... D255 = Identification Tool (Opening)
* Not tj in order (see table in PCBPLOT.H)
*/
// Type d'action du phototraceur:
#define GERB_ACTIVE_DRAW 1 // activation de lumiere ( baisser de plume)
#define GERB_STOP_DRAW 2 // extinction de lumiere ( lever de plume)
// Photoplot actions:
#define GERB_ACTIVE_DRAW 1 // Activate light (lower pen)
#define GERB_STOP_DRAW 2 // Extinguish light (lift pen)
#define GERB_FLASH 3 // Flash
/* Variables locales : */
static wxPoint LastPosition;
/* Local Functions (are lower case since they are private to this source file) */
/* Local Functions (are lower case since they are private to this source file)
**/
/**
* Function fillCircularTRACK
* initializes a given TRACK so that it can draw a circle which is not filled and
* initializes a given TRACK so that it can draw a circle which is not filled
* and
* has a given pen width (\a aPenWidth ).
*
* @param aTrack The TRACK to fill in.
@ -89,7 +90,8 @@ static wxPoint LastPosition;
* @param aLayer The layer index to set into the TRACK
* @param aPos The center point of the flash
* @param aDiameter The diameter of the round flash
* @param aPenWidth The width of the pen used to draw the circle's circumfrance.
* @param aPenWidth The width of the pen used to draw the circle's
* circumference.
* @param isDark True if flash is positive and should use a drawing
* color other than the background color, else use the background color
* when drawing so that an erasure happens.
@ -260,8 +262,8 @@ static void fillLineTRACK( TRACK* aTrack,
* Function fillArcTRACK
* initializes a given TRACK so that it can draw an arc G code.
* <p>
* if multiquadrant == true : arc can be 0 to 360 degres
* and \a rel_center is the center coordiante relative to startpoint.
* if multiquadrant == true : arc can be 0 to 360 degrees
* and \a rel_center is the center coordinate relative to start point.
* <p>
* if multiquadrant == false arc can be only 0 to 90 deg,
* and only in the same quadrant :
@ -276,9 +278,10 @@ static void fillLineTRACK( TRACK* aTrack,
* @param aLayer is the layer index to set into the TRACK
* @param aStart is the starting point
* @param aEnd is the ending point
* @param rel_center is the center coordiante relative to startpoint,
* given in ABSOLUE VALUE and the signe of values x et y de rel_center
* must be calculated from the previously given constraint: arc only in the same quadrant.
* @param rel_center is the center coordinate relative to start point,
* given in ABSOLUTE VALUE and the sign of values x et y de rel_center
* must be calculated from the previously given constraint: arc only in the
* same quadrant.
* @param aDiameter The diameter of the round flash
* @param aWidth is the pen width.
* @param isDark True if flash is positive and should use a drawing
@ -314,7 +317,7 @@ static void fillArcTRACK( TRACK* aTrack, int Dcode_index, int aLayer,
}
else
{
center = rel_center;
center = rel_center;
delta.x = aEnd.x - aStart.x;
delta.y = aEnd.y - aStart.y;
@ -370,20 +373,15 @@ static void fillArcTRACK( TRACK* aTrack, int Dcode_index, int aLayer,
}
/**************************************************/
/* Routines utilis<69>es en lecture de ficher gerber */
/**************************************************/
/* ces routines lisent la chaine de texte point<6E>e par Text.
* Apres appel, Text pointe le debut de la sequence non lue
/* These routines read the text string point from Text.
* After use, advanced Text the beginning of the sequence unread
*/
/***********************************************/
/* Returns the current coord pointed to by Text (XnnnnYmmmm)
*/
wxPoint GERBER::ReadXYCoord( char*& Text )
{
/***********************************************/
/* Retourne la coord courante pointee par Text (XnnnnYmmmm)
*/
wxPoint pos = m_CurrentPos;
int type_coord = 0, current_coord, nbchar;
bool is_float = false;
@ -514,14 +512,12 @@ wxPoint GERBER::ReadXYCoord( char*& Text )
}
/************************************************/
/* Returns the current coordinate type pointed to by InnJnn Text (InnnnJmmmm)
* These coordinates are relative, so if coordinate is absent, it's value
* defaults to 0
*/
wxPoint GERBER::ReadIJCoord( char*& Text )
{
/************************************************/
/* Retourne la coord type InnJnn courante pointee par Text (InnnnJmmmm)
* Ces coordonn<EFBFBD>es sont relatives, donc si une coord est absente, sa valeur
* par defaut est 0
*/
wxPoint pos( 0, 0 );
int type_coord = 0, current_coord, nbchar;
@ -638,12 +634,10 @@ wxPoint GERBER::ReadIJCoord( char*& Text )
}
/*****************************************************/
/* Read the Gnn sequence and returns the value nn.
*/
int GERBER::ReturnGCodeNumber( char*& Text )
{
/*****************************************************/
/* Lit la sequence Gnn et retourne la valeur nn
*/
int ii = 0;
char* text;
char line[1024];
@ -663,12 +657,10 @@ int GERBER::ReturnGCodeNumber( char*& Text )
}
/**************************************************/
/* Get the sequence Dnn and returns the value nn
*/
int GERBER::ReturnDCodeNumber( char*& Text )
{
/**************************************************/
/* Lit la sequence Dnn et retourne la valeur nn
*/
int ii = 0;
char* text;
char line[1024];
@ -687,15 +679,14 @@ int GERBER::ReturnDCodeNumber( char*& Text )
}
/******************************************************************/
bool GERBER::Execute_G_Command( char*& text, int G_commande )
{
/******************************************************************/
D( printf( "%22s: G_CODE<%d>\n", __func__, G_commande ); )
switch( G_commande )
{
case GC_PHOTO_MODE: // can starts a D03 flash command: redundant, can be safely ignored
case GC_PHOTO_MODE: // can starts a D03 flash command: redundant, can
// be safely ignored
break;
case GC_LINEAR_INTERPOL_1X:
@ -757,11 +748,13 @@ bool GERBER::Execute_G_Command( char*& text, int G_commande )
break;
case GC_SPECIFY_ABSOLUES_COORD:
m_Relative = false; // false = absolute Coord, RUE = relative Coord
m_Relative = false; // false = absolute Coord, RUE = relative
// Coord
break;
case GC_SPECIFY_RELATIVEES_COORD:
m_Relative = true; // false = absolute Coord, RUE = relative Coord
m_Relative = true; // false = absolute Coord, RUE = relative
// Coord
break;
case GC_TURN_ON_POLY_FILL:
@ -773,7 +766,7 @@ bool GERBER::Execute_G_Command( char*& text, int G_commande )
m_PolygonFillModeState = 0;
break;
case GC_MOVE: // Non existant
case GC_MOVE: // Non existent
default:
{
wxString msg; msg.Printf( wxT( "G%0.2d command not handled" ),
@ -814,7 +807,7 @@ static int scale( double aCoord, bool isMetric )
static wxPoint mapPt( double x, double y, bool isMetric )
{
wxPoint ret( scale( x, isMetric ),
scale( y, isMetric ) );
scale( y, isMetric ) );
return ret;
}
@ -822,12 +815,14 @@ static wxPoint mapPt( double x, double y, bool isMetric )
/**
* Function mapExposure
* translates the first parameter from an aperture macro into a current exposure
* translates the first parameter from an aperture macro into a current
* exposure
* setting.
* @param curExposure A dynamic setting which can change throughout the
* reading of the gerber file, and it indicates whether the current tool
* is lit or not.
* @param isNegative A dynamic setting which can change throughout the reading of
* @param isNegative A dynamic setting which can change throughout the reading
* of
* the gerber file, and it indicates whether the current D codes are to
* be interpreted as erasures or not.
*/
@ -854,11 +849,9 @@ static bool mapExposure( int param1, bool curExposure, bool isNegative )
}
/*****************************************************************************/
bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
char*& text, int D_commande )
{
/*****************************************************************************/
wxSize size( 15, 15 );
APERTURE_T aperture = APT_CIRCLE;
@ -878,7 +871,8 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
if( D_commande > (MAX_TOOLS - 1) )
D_commande = MAX_TOOLS - 1;
// remember which tool is selected, nothing is done with it in this call
// remember which tool is selected, nothing is done with it in this
// call
m_Current_Tool = D_commande;
D_CODE* pt_Dcode = GetDCODE( D_commande, false );
@ -887,7 +881,7 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
return true;
}
else // D_commande = 0..9: this is a pen command (usualy D1, D2 or D3)
else // D_commande = 0..9: this is a pen command (usually D1, D2 or D3)
{
m_Last_Pen_Command = D_commande;
}
@ -916,7 +910,7 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
edge_poly->SetNet( m_PolygonFillModeState );
// the first track of each polygon has a netcode of zero,
// otherwise one. Sset the erasure flag in that special track,
// otherwise one. Set the erasure flag in that special track,
// if a negative polygon.
if( !m_PolygonFillModeState )
{
@ -977,7 +971,7 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
pcb->m_Track.Append( track );
D( printf( "R:%p\n", track ); )
fillArcTRACK( track, dcode, activeLayer, m_PreviousPos,
m_CurrentPos, m_IJPos, size.x,
m_CurrentPos, m_IJPos, size.x,
( m_Iterpolation == GERB_INTERPOL_ARC_NEG ) ?
false : true, m_360Arc_enbl,
!(m_LayerNegative ^ m_ImageNegative) );
@ -1009,7 +1003,8 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
switch( aperture )
{
case APT_LINE: // APT_LINE is not in the spec, don't know why it's here
case APT_LINE: // APT_LINE is not in the spec, don't know why it's
// here
case APT_CIRCLE:
track = new TRACK( pcb );
pcb->m_Track.Append( track );
@ -1036,7 +1031,8 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
APERTURE_MACRO* macro = tool->GetMacro();
wxASSERT( macro );
// split the macro primitives up into multiple normal TRACK elements
// split the macro primitives up into multiple normal TRACK
// elements
for( AM_PRIMITIVES::iterator p = macro->primitives.begin();
p!=macro->primitives.end();
++p )
@ -1050,9 +1046,9 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
{
exposure = mapExposure( p->GetExposure(), m_Exposure,
m_ImageNegative );
curPos += mapPt( p->params[2].GetValue( tool ),
p->params[3].GetValue( tool ),
m_GerbMetric );
curPos += mapPt( p->params[2].GetValue( tool ),
p->params[3].GetValue( tool ),
m_GerbMetric );
int diameter = scale( p->params[1].GetValue( tool ),
m_GerbMetric );
@ -1074,9 +1070,9 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
wxPoint start = mapPt( p->params[2].GetValue( tool ),
p->params[3].GetValue( tool ),
m_GerbMetric );
wxPoint end = mapPt( p->params[4].GetValue( tool ),
p->params[5].GetValue( tool ),
m_GerbMetric );
wxPoint end = mapPt( p->params[4].GetValue( tool ),
p->params[5].GetValue( tool ),
m_GerbMetric );
if( start.x == end.x )
{
@ -1089,8 +1085,8 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
size.y = width;
}
wxPoint midPoint( (start.x + end.x) / 2,
(start.y + end.y) / 2 );
wxPoint midPoint( ( start.x + end.x ) / 2,
( start.y + end.y ) / 2 );
curPos += midPoint;
track = new TRACK( pcb );
pcb->m_Track.Append( track );
@ -1113,7 +1109,7 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
curPos += mapPt( p->params[3].GetValue( tool ),
p->params[4].GetValue( tool ),
m_GerbMetric );
track = new TRACK( pcb );
track = new TRACK( pcb );
pcb->m_Track.Append( track );
D( printf( "R:%p\n", track ); )
fillOvalOrRectFlashTRACK( track, dcode, activeLayer,
@ -1164,14 +1160,14 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
D( printf( "R:%p\n", track ); )
fillRoundFlashTRACK( track, dcode, activeLayer,
curPos, outerDiam,
!(m_LayerNegative ^ m_ImageNegative) );
!( m_LayerNegative ^ m_ImageNegative ) );
track = new TRACK( pcb );
pcb->m_Track.Append( track );
D( printf( "R:%p\n", track ); )
fillRoundFlashTRACK( track, dcode, activeLayer, curPos,
innerDiam,
(m_LayerNegative ^ m_ImageNegative) );
( m_LayerNegative ^ m_ImageNegative ) );
// @todo: draw the cross hairs, see page 23 of rs274
// spec. this might be done with two lines, thickness
@ -1187,21 +1183,21 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
m_GerbMetric );
// e.g.: "6,0,0,0.125,.01,0.01,3,0.003,0.150,0"
int outerDiam = scale( p->params[2].GetValue( tool ),
m_GerbMetric );
int outerDiam = scale( p->params[2].GetValue( tool ),
m_GerbMetric );
int penThickness = scale( p->params[3].GetValue( tool ),
m_GerbMetric );
int gap = scale( p->params[4].GetValue( tool ),
m_GerbMetric );
int numCircles = (int)p->params[5].GetValue( tool );
int numCircles = (int) p->params[5].GetValue( tool );
int crossHairThickness =
scale( p->params[6].GetValue( tool ), m_GerbMetric );
int crossHairLength =
scale( p->params[7].GetValue( tool ), m_GerbMetric );
// ignore rotation, not supported
int diamAdjust = 2 * (gap + penThickness); // adjust outerDiam by this on each nested circle
// adjust outerDiam by this on each nested circle
int diamAdjust = 2 * (gap + penThickness);
for( int i = 0;
i < numCircles;
++i, outerDiam -= diamAdjust )
@ -1212,19 +1208,18 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
fillCircularTRACK( track, dcode, activeLayer,
curPos, outerDiam,
penThickness,
!(m_LayerNegative ^ m_ImageNegative) );
!( m_LayerNegative ^ m_ImageNegative ) );
}
track = new TRACK( pcb );
pcb->m_Track.Append( track );
D( printf( "R:%p\n", track ); )
fillOvalOrRectFlashTRACK( track, dcode, activeLayer,
curPos,
wxSize( crossHairThickness,
crossHairLength ),
S_SPOT_RECT,
!(m_LayerNegative ^
m_ImageNegative) );
curPos,
wxSize( crossHairThickness,
crossHairLength ),
S_SPOT_RECT,
!( m_LayerNegative ^ m_ImageNegative ) );
track = new TRACK( pcb );
pcb->m_Track.Append( track );
@ -1232,12 +1227,11 @@ bool GERBER::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
// swap x and y in wxSize() for this one
fillOvalOrRectFlashTRACK( track, dcode, activeLayer,
curPos,
wxSize( crossHairLength,
crossHairThickness ),
S_SPOT_RECT,
!(m_LayerNegative ^
m_ImageNegative) );
curPos,
wxSize( crossHairLength,
crossHairThickness ),
S_SPOT_RECT,
!( m_LayerNegative ^ m_ImageNegative ) );
}
break;

53
gerbview/rs274x.cpp
View File

@ -1,6 +1,6 @@
/********************************************************/
/* Routine de lecture d'un fichier GERBER format RS274X */
/********************************************************/
/**************/
/* rs274x.cpp */
/**************/
#include "fctsys.h"
#include "common.h"
@ -20,9 +20,9 @@ enum RS274X_PARAMETERS {
INCH = CODE( 'I', 'N' ),
MILLIMETER = CODE( 'M', 'M' ),
OFFSET = CODE( 'O', 'F' ),
SCALE_FACTOR = CODE( 'S', 'F' ),
SCALE_FACTOR = CODE( 'S', 'F' ),
IMAGE_NAME = CODE( 'I', 'N' ),
IMAGE_NAME = CODE( 'I', 'N' ),
IMAGE_JUSTIFY = CODE( 'I', 'J' ),
IMAGE_OFFSET = CODE( 'I', 'O' ),
IMAGE_POLARITY = CODE( 'I', 'P' ),
@ -41,9 +41,6 @@ enum RS274X_PARAMETERS {
};
/* Local Functions */
/**
* Function ReadXCommand
* reads in two bytes of data and assembles them into an int with the first
@ -109,11 +106,9 @@ static double ReadDouble( char*& text )
}
/****************************************************************************/
bool GERBER::ReadRS274XCommand( WinEDA_GerberFrame* frame, wxDC* DC,
char buff[GERBER_BUFZ], char*& text )
{
/****************************************************************************/
bool ok = true;
int code_command;
@ -165,12 +160,10 @@ exit:
}
/*******************************************************************************/
bool GERBER::ExecuteRS274XCommand( int command,
char buff[GERBER_BUFZ],
char*& text )
{
/*******************************************************************************/
int code;
int xy_seq_len, xy_seq_char;
bool ok = TRUE;
@ -206,17 +199,18 @@ bool GERBER::ExecuteRS274XCommand( int command,
text++;
break;
case 'A': // Absolute coord
case 'A': // Absolute coord
m_Relative = FALSE;
text++;
break;
case 'I': // Absolute coord
case 'I': // Absolute coord
m_Relative = TRUE;
text++;
break;
case 'N': // Sequence code (followed by the number of digits for the X,Y command
case 'N': // Sequence code (followed by the number of digits
// for the X,Y command
text++;
xy_seq_char = *text++;
if( (xy_seq_char >= '0') && (xy_seq_char <= '9') )
@ -224,14 +218,16 @@ bool GERBER::ExecuteRS274XCommand( int command,
break;
case 'X':
case 'Y': // Valeurs transmises :2 (really xy_seq_len : FIX ME) digits
case 'Y': // Values transmitted :2 (really xy_seq_len : FIX
// ME) digits
{
code = *(text++);
char ctmp = *(text++) - '0';
if( code == 'X' )
{
m_FmtScale.x = *text - '0'; // = nb chiffres apres la virgule
m_FmtLen.x = ctmp + m_FmtScale.x; // = nb total de chiffres
// number of digits after the decimal point
m_FmtScale.x = *text - '0';
m_FmtLen.x = ctmp + m_FmtScale.x;
}
else
{
@ -275,13 +271,13 @@ bool GERBER::ExecuteRS274XCommand( int command,
{
switch( *text )
{
case 'A': // A axis offset in current unit (inch ou mm)
case 'A': // A axis offset in current unit (inch or mm)
text++;
fcoord = ReadDouble( text );
m_Offset.x = wxRound( fcoord * conv_scale );
break;
case 'B': // B axis offset in current unit (inch ou mm)
case 'B': // B axis offset in current unit (inch or mm)
text++;
fcoord = ReadDouble( text );
m_Offset.y = wxRound( fcoord * conv_scale );
@ -348,7 +344,7 @@ bool GERBER::ExecuteRS274XCommand( int command,
if( m_Current_File == 0 )
{
wxString msg;
msg.Printf( wxT( "fichier <%s> non trouve" ), line );
msg.Printf( wxT( "file <%s> not found." ), line );
DisplayError( NULL, msg, 10 );
ok = FALSE;
m_Current_File = m_FilesList[m_FilesPtr];
@ -393,7 +389,7 @@ bool GERBER::ExecuteRS274XCommand( int command,
text += 2; // skip "C," for example
dcode->m_Size.x = dcode->m_Size.y =
wxRound( ReadDouble( text ) * conv_scale );
wxRound( ReadDouble( text ) * conv_scale );
switch( stdAperture )
{
@ -493,7 +489,7 @@ bool GERBER::ExecuteRS274XCommand( int command,
{
// @todo not found, don't know how to report an error
D( printf( "aperture macro %s not found\n",
CONV_TO_UTF8( am_lookup.name ) ); )
CONV_TO_UTF8( am_lookup.name ) ); )
ok = false;
break;
}
@ -514,10 +510,8 @@ bool GERBER::ExecuteRS274XCommand( int command,
}
/*****************************************************************/
bool GetEndOfBlock( char buff[GERBER_BUFZ], char*& text, FILE* gerber_file )
{
/*****************************************************************/
for( ; ; )
{
while( (text < buff + GERBER_BUFZ) && *text )
@ -541,12 +535,10 @@ bool GetEndOfBlock( char buff[GERBER_BUFZ], char*& text, FILE* gerber_file )
}
/*******************************************************************/
bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ],
char*& text,
FILE* gerber_file )
{
/*******************************************************************/
APERTURE_MACRO am;
// read macro name
@ -633,7 +625,7 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ],
}
int i;
for( i = 0; i < paramCount && *text && *text != '*'; ++i )
for( i = 0; i < paramCount && *text && *text != '*'; ++i )
{
prim.params.push_back( DCODE_PARAM() );
@ -648,7 +640,8 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ],
param.SetValue( ReadDouble( text ) );
}
if( i < paramCount ) // maybe some day we can throw an exception and track a line number
if( i < paramCount ) // maybe some day we can throw an exception and
// track a line number
printf( "i=%d, insufficient parameters\n", i );
// there are more parameters to read if this is an AMP_OUTLINE
@ -660,7 +653,7 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ],
paramCount = (int) prim.params[1].GetValue( 0 ) * 2 + 1;
for( int i = 0; i < paramCount && *text && *text != '*'; ++i )
for( int i = 0; i < paramCount && *text && *text != '*'; ++i )
{
prim.params.push_back( DCODE_PARAM() );

31
gerbview/select_layers_to_pcb.cpp
View File

@ -13,12 +13,11 @@
#include "wx/statline.h"
/* Variables locales */
#define LAYER_UNSELECTED NB_LAYERS
static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons
static int ButtonTable[32]; // Indexes buttons to Gerber layers
static int LayerLookUpTable[32]; // Indexes Gerber layers to PCB file layers
wxStaticText* layer_list[32]; // Indexes text strings to buttons
enum swap_layer_id {
ID_WINEDA_SWAPLAYERFRAME = 1800,
@ -27,10 +26,6 @@ enum swap_layer_id {
};
/***********************************************/
/* classe pour la frame de selection de layers */
/***********************************************/
class WinEDA_SwapLayerFrame : public wxDialog
{
private:
@ -46,7 +41,6 @@ private:
public:
// Constructor and destructor
WinEDA_SwapLayerFrame( WinEDA_GerberFrame* parent );
~WinEDA_SwapLayerFrame() {};
@ -58,7 +52,7 @@ private:
DECLARE_EVENT_TABLE()
};
/* Table des evenements pour WinEDA_SwapLayerFrame */
BEGIN_EVENT_TABLE( WinEDA_SwapLayerFrame, wxDialog )
EVT_COMMAND_RANGE( ID_BUTTON_0, ID_BUTTON_0 + 31,
wxEVT_COMMAND_BUTTON_CLICKED,
@ -68,13 +62,12 @@ BEGIN_EVENT_TABLE( WinEDA_SwapLayerFrame, wxDialog )
END_EVENT_TABLE()
/*************************************************************/
int* InstallDialogLayerPairChoice( WinEDA_GerberFrame * parent ) {
/*************************************************************/
/* Install a dialog frame to choose the equivalence
* between gerber layers and pcbnew layers
* return the "lookup table" if ok, or NULL
*/
int* InstallDialogLayerPairChoice( WinEDA_GerberFrame * parent )
{
WinEDA_SwapLayerFrame* frame = new WinEDA_SwapLayerFrame( parent );
int ii = frame->ShowModal();
@ -87,12 +80,10 @@ int* InstallDialogLayerPairChoice( WinEDA_GerberFrame * parent ) {
}
/*************************************************************************/
WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_GerberFrame* parent ) :
wxDialog( parent, -1, _( "Layer selection:" ), wxPoint( -1, -1 ),
wxDefaultSize, wxDEFAULT_DIALOG_STYLE | MAYBE_RESIZE_BORDER )
{
/*************************************************************************/
OuterBoxSizer = NULL;
MainBoxSizer = NULL;
FlexColumnBoxSizer = NULL;
@ -184,7 +175,7 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_GerberFrame* parent ) :
// of those items are placed into the left hand column, middle
// column, and right hand column (respectively) of the Flexgrid
// sizer, and the color of the second text string is set to
// fushia or blue (to respectively indicate whether the Gerber
// fuchsia or blue (to respectively indicate whether the Gerber
// layer has been mapped to a pcbnew layer or is not being
// exported at all). (Experimentation has shown that if a text
// control is used to depict which pcbnew layer that each Gerber
@ -249,7 +240,7 @@ WinEDA_SwapLayerFrame::WinEDA_SwapLayerFrame( WinEDA_GerberFrame* parent ) :
// Provide another text string to specify which pcbnew layer that this
// Gerber layer is initially mapped to, and set the initial text to
// specify the appropriate pcbnew layer, and set the foreground color
// of the text to fushia (to indicate that the layer is being exported).
// of the text to fuchsia (to indicate that the layer is being exported).
item_ID = ID_TEXT_0 + ii;
// When the first of these text strings is being added, determine what
@ -367,7 +358,7 @@ void WinEDA_SwapLayerFrame::OnSelectLayer( wxCommandEvent& event )
{
layer_list[ii]->SetLabel( ReturnPcbLayerName( jj ) );
// Change the text color to fushia (to highlight
// Change the text color to fuchsia (to highlight
// that this layer *is* being exported)
layer_list[ii]->SetForegroundColour( wxColour( 255, 0, 128 ) );
}
@ -375,18 +366,14 @@ void WinEDA_SwapLayerFrame::OnSelectLayer( wxCommandEvent& event )
}
/*********************************************************/
void WinEDA_SwapLayerFrame::OnCancelClick( wxCommandEvent& event )
/*********************************************************/
{
EndModal( -1 );
}
/*********************************************************/
void WinEDA_SwapLayerFrame::OnOkClick( wxCommandEvent& event )
{
/*********************************************************/
int ii;
bool AsCmpLayer = false;

83
gerbview/tool_gerber.cpp
View File

@ -1,5 +1,5 @@
/***************************************************/
/* tool_gerber.cpp: Build tool bars and main menu */
/* tool_gerber.cpp: Build tool bars and main menu */
/***************************************************/
#include "fctsys.h"
@ -12,12 +12,8 @@
#include "bitmaps.h"
#include "hotkeys.h"
/***********************************************/
void WinEDA_GerberFrame::ReCreateMenuBar( void )
/***********************************************/
/* Cree ou reinitialise le menu du haut d'ecran
*/
void WinEDA_GerberFrame::ReCreateMenuBar( void )
{
wxMenuBar *menuBar = GetMenuBar();
@ -34,7 +30,7 @@ void WinEDA_GerberFrame::ReCreateMenuBar( void )
FALSE );
filesMenu->Append( ID_APPEND_FILE, _( "Load Gerber File" ),
_( "Load new Gerber file on currrent layer" ),
_( "Load new Gerber file on current layer" ),
FALSE );
filesMenu->Append( ID_MENU_INC_LAYER_AND_APPEND_FILE,
@ -79,15 +75,16 @@ void WinEDA_GerberFrame::ReCreateMenuBar( void )
// Configuration:
wxMenu* configmenu = new wxMenu;
ADD_MENUITEM_WITH_HELP( configmenu, ID_CONFIG_REQ, _( "&File Ext" ),
_( "Setting Files extension" ), config_xpm );
_( "Set files extensions" ), config_xpm );
ADD_MENUITEM_WITH_HELP( configmenu, ID_COLORS_SETUP, _( "&Colors" ),
_( "Select Colors and Display for layers" ),
_( "Select colors and display for layers" ),
palette_xpm );
ADD_MENUITEM_WITH_HELP( configmenu, ID_OPTIONS_SETUP, _( "&Options" ),
_( " Select general options" ), preference_xpm );
_( "Select general options" ), preference_xpm );
ADD_MENUITEM_WITH_HELP( configmenu, ID_PCB_DISPLAY_OPTIONS_SETUP, _( "Display" ),
_( " Select how items are displayed" ),
ADD_MENUITEM_WITH_HELP( configmenu, ID_PCB_DISPLAY_OPTIONS_SETUP,
_( "Display" ),
_( "Select how items are displayed" ),
display_options_xpm );
wxGetApp().AddMenuLanguageList( configmenu );
@ -100,14 +97,11 @@ void WinEDA_GerberFrame::ReCreateMenuBar( void )
configmenu->AppendSeparator();
AddHotkeyConfigMenu( configmenu );
// Menu drill ( generation fichiers percage)
/* wxMenu *drill_menu = new wxMenu;
/* wxMenu *drill_menu = new wxMenu;
* postprocess_menu->Append(ID_PCB_GEN_DRILL_FILE, "Create &Drill file",
* "Gen Drill (EXCELLON] file and/or Drill sheet");
*/
// Menu d'outils divers
wxMenu* miscellaneous_menu = new wxMenu;
ADD_MENUITEM_WITH_HELP( miscellaneous_menu, ID_GERBVIEW_SHOW_LIST_DCODES,
_( "&List DCodes" ),
@ -133,7 +127,7 @@ void WinEDA_GerberFrame::ReCreateMenuBar( void )
menuBar->Append( configmenu, _( "&Preferences" ) );
menuBar->Append( miscellaneous_menu, _( "&Miscellaneous" ) );
// menuBar->Append(drill_menu, _("&Drill"));
// menuBar->Append(drill_menu, _("&Drill"));
menuBar->Append( helpMenu, _( "&Help" ) );
// Associate the menu bar with the frame
@ -141,9 +135,7 @@ void WinEDA_GerberFrame::ReCreateMenuBar( void )
}
/***********************************************/
void WinEDA_GerberFrame::ReCreateHToolbar( void )
/***********************************************/
{
int layer = 0;
GERBER* gerber = NULL;
@ -151,7 +143,7 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
wxString msg;
// delete and recreate the toolbar
if( m_HToolBar != NULL )
if( m_HToolBar != NULL )
return;
if( GetScreen() )
@ -161,13 +153,15 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
}
m_HToolBar = new WinEDA_Toolbar( TOOLBAR_MAIN, this, ID_H_TOOLBAR, TRUE );
#if !defined(KICAD_AUIMANAGER)
SetToolBar( (wxToolBar*)m_HToolBar );
#endif
// Set up toolbar
m_HToolBar->AddTool( ID_NEW_BOARD, wxEmptyString,
wxBitmap( new_xpm ),
_( "New World" ) );
_( "New world" ) );
m_HToolBar->AddTool( ID_LOAD_FILE, wxEmptyString,
wxBitmap( open_xpm ),
@ -208,7 +202,7 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
m_HToolBar->AddSeparator();
m_HToolBar->AddTool( ID_GEN_PRINT, wxEmptyString,
wxBitmap( print_button ),
_( "Print World" ) );
_( "Print world" ) );
m_HToolBar->AddSeparator();
msg = AddHotkeyName( _( "Zoom in" ), s_Gerbview_Hokeys_Descr, HK_ZOOM_IN );
@ -227,7 +221,8 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
wxBitmap( zoom_redraw_xpm ),
msg );
msg = AddHotkeyName( _( "Zoom auto" ), s_Gerbview_Hokeys_Descr, HK_ZOOM_AUTO );
msg = AddHotkeyName( _( "Zoom auto" ), s_Gerbview_Hokeys_Descr,
HK_ZOOM_AUTO );
m_HToolBar->AddTool( ID_ZOOM_PAGE, wxEmptyString,
wxBitmap( zoom_auto_xpm ),
msg );
@ -256,6 +251,7 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
m_HToolBar->AddSeparator();
choices.Clear();
choices.Add( _( "No tool" ) );
for( ii = 0; ii < MAX_TOOLS; ii++ )
{
wxString msg;
@ -277,12 +273,10 @@ void WinEDA_GerberFrame::ReCreateHToolbar( void )
}
/**********************************************/
void WinEDA_GerberFrame::ReCreateVToolbar( void )
/**********************************************/
/**
create or update the right vertical toolbar
*/
* Create or update the right vertical toolbar
*/
void WinEDA_GerberFrame::ReCreateVToolbar( void )
{
if( m_VToolBar )
return;
@ -298,11 +292,11 @@ create or update the right vertical toolbar
m_VToolBar->AddSeparator();
m_VToolBar->AddTool( ID_COMPONENT_BUTT, wxEmptyString,
wxBitmap( component_button ),
_( "Add Flashes" ) );
_( "Add flashes" ) );
m_VToolBar->AddTool( ID_BUS_BUTT, wxEmptyString,
wxBitmap( bus_button ),
_( "Add Lines" ) );
_( "Add lines" ) );
m_VToolBar->AddTool( ID_JUNCTION_BUTT, wxEmptyString,
wxBitmap( junction_xpm ),
@ -311,7 +305,7 @@ create or update the right vertical toolbar
m_VToolBar->AddSeparator();
m_VToolBar->AddTool( ID_PCB_ADD_TEXT_BUTT, wxEmptyString,
wxBitmap( tool_text_xpm ),
_( "Add Text" ) );
_( "Add text" ) );
#endif
m_VToolBar->AddSeparator();
@ -324,52 +318,51 @@ create or update the right vertical toolbar
}
/************************************************/
void WinEDA_GerberFrame::ReCreateOptToolbar( void )
/************************************************/
/**
create or update the left vertical toolbar (option toolbar
*/
* Create or update the left vertical toolbar (option toolbar
*/
void WinEDA_GerberFrame::ReCreateOptToolbar( void )
{
if( m_OptionsToolBar )
return;
// creation du tool bar options
// creation of tool bar options
m_OptionsToolBar = new WinEDA_Toolbar( TOOLBAR_OPTION, this,
ID_OPT_TOOLBAR, FALSE );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_GRID, wxEmptyString,
wxBitmap( grid_xpm ),
_( "Display Grid OFF" ), wxITEM_CHECK );
_( "Turn grid off" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_POLAR_COORD, wxEmptyString,
wxBitmap( polar_coord_xpm ),
_( "Display Polar Coord ON" ), wxITEM_CHECK );
_( "Turn polar coordinate on" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SELECT_UNIT_INCH, wxEmptyString,
wxBitmap( unit_inch_xpm ),
_( "Units in inches" ), wxITEM_CHECK );
_( "Set units to inches" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SELECT_UNIT_MM, wxEmptyString,
wxBitmap( unit_mm_xpm ),
_( "Units in millimeters" ), wxITEM_CHECK );
_( "Set units to millimeters" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SELECT_CURSOR, wxEmptyString,
wxBitmap( cursor_shape_xpm ),
_( "Change Cursor Shape" ), wxITEM_CHECK );
_( "Change cursor shape" ), wxITEM_CHECK );
m_OptionsToolBar->AddSeparator();
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_PADS_SKETCH, wxEmptyString,
wxBitmap( pad_sketch_xpm ),
_( "Show Spots in Sketch Mode" ), wxITEM_CHECK );
_( "Show spots in sketch mode" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_TRACKS_SKETCH, wxEmptyString,
wxBitmap( showtrack_xpm ),
_( "Show Lines in Sketch Mode" ), wxITEM_CHECK );
_( "Show lines in sketch mode" ), wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_POLYGONS_SKETCH, wxEmptyString,
wxBitmap( opt_show_polygon_xpm ),
_( "Show Polygons in Sketch Mode" ), wxITEM_CHECK );
_( "Show polygons in sketch mode" ),
wxITEM_CHECK );
m_OptionsToolBar->AddTool( ID_TB_OPTIONS_SHOW_DCODES, wxEmptyString,
wxBitmap( show_dcodenumber_xpm ),

218
gerbview/tracepcb.cpp
View File

@ -18,41 +18,44 @@
#include "class_board_design_settings.h"
/************************************************************************************************************/
void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int printmasklayer, bool aPrintMirrorMode )
/*************************************************************************************************************/
/* Draw gerbview layers, for printing
*/
*/
void WinEDA_DrawPanel::PrintPage( wxDC* DC,
bool Print_Sheet_Ref,
int printmasklayer,
bool aPrintMirrorMode )
{
DISPLAY_OPTIONS save_opt;
int DisplayPolygonsModeImg;
int DisplayPolygonsModeImg;
save_opt = DisplayOpt;
if( printmasklayer & ALL_CU_LAYERS )
{
DisplayOpt.DisplayPadFill = true;
DisplayOpt.DisplayViaFill = true;
DisplayOpt.DisplayPadFill = true;
DisplayOpt.DisplayViaFill = true;
}
else
{
DisplayOpt.DisplayPadFill = false;
DisplayOpt.DisplayViaFill = false;
DisplayOpt.DisplayPadFill = false;
DisplayOpt.DisplayViaFill = false;
}
DisplayOpt.DisplayPadNum = 0;
DisplayOpt.DisplayPadNoConn = 0;
DisplayOpt.DisplayPadIsol = 0;
DisplayOpt.DisplayModEdge = FILLED;
DisplayOpt.DisplayModText = FILLED;
DisplayOpt.DisplayPcbTrackFill = FILLED;
DisplayOpt.DisplayPadNum = 0;
DisplayOpt.DisplayPadNoConn = 0;
DisplayOpt.DisplayPadIsol = 0;
DisplayOpt.DisplayModEdge = FILLED;
DisplayOpt.DisplayModText = FILLED;
DisplayOpt.DisplayPcbTrackFill = FILLED;
DisplayOpt.ShowTrackClearanceMode = DO_NOT_SHOW_CLEARANCE;
DisplayOpt.DisplayDrawItems = FILLED;
DisplayOpt.DisplayZonesMode = 0;
DisplayOpt.DisplayDrawItems = FILLED;
DisplayOpt.DisplayZonesMode = 0;
DisplayPolygonsModeImg = g_DisplayPolygonsModeSketch;
g_DisplayPolygonsModeSketch = 0;
m_PrintIsMirrored = aPrintMirrorMode;
( (WinEDA_GerberFrame*) m_Parent )->Trace_Gerber( DC, GR_COPY, printmasklayer );
( (WinEDA_GerberFrame*) m_Parent )->Trace_Gerber( DC,
GR_COPY,
printmasklayer );
if( Print_Sheet_Ref )
m_Parent->TraceWorkSheet( DC, GetScreen(), 0 );
@ -64,14 +67,11 @@ void WinEDA_DrawPanel::PrintPage( wxDC* DC, bool Print_Sheet_Ref, int printmaskl
}
/*******************************************************************/
void WinEDA_GerberFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
/*******************************************************************/
/* Trace le PCB, et les elements complementaires ( axes, grille .. )
/* Trace the PCB, and additional elements (axis, grid ..)
*/
void WinEDA_GerberFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
{
PCB_SCREEN* screen = (PCB_SCREEN*)GetScreen();
PCB_SCREEN* screen = (PCB_SCREEN*) GetScreen();
if( !GetBoard() )
return;
@ -92,62 +92,67 @@ void WinEDA_GerberFrame::RedrawActiveWindow( wxDC* DC, bool EraseBg )
DrawPanel->Trace_Curseur( DC );
}
/********************************************************************/
/* Redraw the BOARD items but not cursors, axis or grid */
// @todo: replace WinEDA_GerberFrame::Trace_Gerber() by this function
void BOARD::Draw( WinEDA_DrawPanel* aPanel, wxDC* DC,
int aDrawMode, const wxPoint& offset )
/********************************************************************/
/* Redraw the BOARD items but not cursors, axis or grid */
// @todo: replace WinEDA_GerberFrame::Trace_Gerber() by this function
{
}
/***********************************************************************************/
void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklayer )
/***********************************************************************************/
/*
* Trace l'ensemble des elements du PCB sur l'ecran actif
* @param DC = device context to draw
* @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR ..)
* @param printmasklayer = mask for allowed layer (=-1 to draw all layers)
*/
* Trace all elements of PCBs on the active screen.
*
* @param DC = device context to draw
* @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR
* ..)
* @param printmasklayer = mask for allowed layer (=-1 to draw all layers)
*/
void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC,
int draw_mode,
int printmasklayer )
{
if( !GetBoard() )
return;
bool erase = false;
int Color;
bool filled;
bool erase = false;
int Color;
bool filled;
// Draw filled polygons
std::vector<wxPoint> points;
std::vector<wxPoint> points;
// minimize reallocations of the vector's internal array by starting with a good sized one.
points.reserve(10000);
// minimize reallocations of the vector's internal array by starting with a
// good sized one.
points.reserve( 10000 );
for( TRACK* track = GetBoard()->m_Zone; track; track = track->Next() )
for( TRACK* track = GetBoard()->m_Zone; track; track = track->Next() )
{
if( !(track->ReturnMaskLayer() & printmasklayer) )
continue;
D(printf("D:%p\n", track );)
D( printf( "D:%p\n", track ); )
if( track->GetNet() == 0 ) // StartPoint
{
if( points.size() ) // we have found a new polygon: Draw the old polygon
if( points.size() ) // we have found a new polygon: Draw the
// old polygon
{
if( erase )
{
Color = g_DrawBgColor;
Color = g_DrawBgColor;
filled = true;
}
else
{
Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
filled = (g_DisplayPolygonsModeSketch == 0);
}
GRClosedPoly( &DrawPanel->m_ClipBox, DC, points.size(), &points[0],
GRClosedPoly( &DrawPanel->m_ClipBox, DC,
points.size(), &points[0],
filled, Color, Color );
}
@ -166,13 +171,13 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
{
if( erase )
{
Color = g_DrawBgColor;
Color = g_DrawBgColor;
filled = true;
}
else
{
Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
filled = (g_DisplayPolygonsModeSketch == 0);
Color = g_DesignSettings.m_LayerColor[track->GetLayer()];
filled = ( g_DisplayPolygonsModeSketch == 0 );
}
GRClosedPoly( &DrawPanel->m_ClipBox, DC, points.size(), &points[0],
@ -180,7 +185,8 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
}
}
// Draw tracks and flashes down here. This will probably not be a final solution to drawing order issues
// Draw tracks and flashes down here. This will probably not be a final
// solution to drawing order issues
Draw_Track_Buffer( DrawPanel, DC, GetBoard(), draw_mode, printmasklayer );
if( DisplayOpt.DisplayPadNum )
@ -189,32 +195,34 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
GetScreen()->ClrRefreshReq();
}
/***************************************************************************************************/
void Draw_Track_Buffer( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int draw_mode,
int printmasklayer )
/***************************************************************************************************/
/* Function to draw the tracks (i.e Spots or lines) in gerbview
* Polygons are not handled here (there are in Pcb->m_Zone)
* @param DC = device context to draw
* @param Pcb = Board to draw (only Pcb->m_Track is used)
* @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR ..)
* @param draw_mode = draw mode for the device context (GR_COPY, GR_OR, GR_XOR
* ..)
* @param printmasklayer = mask for allowed layer (=-1 to draw all layers)
*/
void Draw_Track_Buffer( WinEDA_DrawPanel* panel,
wxDC* DC,
BOARD* Pcb,
int draw_mode,
int printmasklayer )
{
int layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
GERBER* gerber = g_GERBER_List[layer];
int dcode_hightlight = 0;
int layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
GERBER* gerber = g_GERBER_List[layer];
int dcode_hightlight = 0;
if( gerber )
dcode_hightlight = gerber->m_Selected_Tool;
for( TRACK* track = Pcb->m_Track; track; track = track->Next() )
for( TRACK* track = Pcb->m_Track; track; track = track->Next() )
{
if( !(track->ReturnMaskLayer() & printmasklayer) )
continue;
D(printf("D:%p\n", track );)
D( printf( "D:%p\n", track ); )
if( dcode_hightlight == track->GetNet() && track->GetLayer()==layer )
Trace_Segment( panel, DC, track, draw_mode | GR_SURBRILL );
@ -226,15 +234,16 @@ void Draw_Track_Buffer( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int draw_
#if 1
/***********************************************************************************/
void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mode )
/***********************************************************************************/
/* routine de trace de 1 segment de piste.
* Parametres :
* track = adresse de la description de la piste en buflib
* draw_mode = mode ( GR_XOR, GR_OR..)
/* Trace 1 segment of track.
* Parameters:
* Track = address of the description of the track buflib
* Draw_mode = mode (GR_XOR, GR_OR ..)
*/
void Trace_Segment( WinEDA_DrawPanel* panel,
wxDC* DC,
TRACK* track,
int draw_mode )
{
int l_piste;
int color;
@ -243,7 +252,8 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
int halfPenWidth;
static bool show_err;
if( track->m_Flags & DRAW_ERASED ) // draw in background color, used by classs TRACK in gerbview
if( track->m_Flags & DRAW_ERASED ) // draw in background color, used by
// class TRACK in gerbview
{
color = g_DrawBgColor;
}
@ -267,7 +277,6 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
GRSetDrawMode( DC, draw_mode );
fillopt = DisplayOpt.DisplayPcbTrackFill ? FILLED : SKETCH;
switch( track->m_Shape )
@ -285,16 +294,32 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
if( fillopt == SKETCH )
{
// draw the border of the pen's path using two circles, each as narrow as possible
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius - halfPenWidth, 0, color );
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius + halfPenWidth, 0, color );
// draw the border of the pen's path using two circles, each as
// narrow as possible
GRCircle( &panel->m_ClipBox,
DC,
track->m_Start.x,
track->m_Start.y,
radius - halfPenWidth,
0,
color );
GRCircle( &panel->m_ClipBox,
DC,
track->m_Start.x,
track->m_Start.y,
radius + halfPenWidth,
0,
color );
}
else
{
GRCircle( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
radius, track->m_Width, color );
GRCircle( &panel->m_ClipBox,
DC,
track->m_Start.x,
track->m_Start.y,
radius,
track->m_Width,
color );
}
break;
@ -402,12 +427,14 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
}
}
#endif
/*****************************************************************************************/
void Affiche_DCodes_Pistes( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int drawmode )
/*****************************************************************************************/
void Affiche_DCodes_Pistes( WinEDA_DrawPanel* panel,
wxDC* DC,
BOARD* Pcb,
int drawmode )
{
TRACK* track;
wxPoint pos;
@ -418,24 +445,24 @@ void Affiche_DCodes_Pistes( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int d
track = Pcb->m_Track;
for( ; track != NULL; track = track->Next() )
{
if( (track->m_Shape == S_ARC)
|| (track->m_Shape == S_CIRCLE)
|| (track->m_Shape == S_ARC_RECT) )
if( ( track->m_Shape == S_ARC )
|| ( track->m_Shape == S_CIRCLE )
|| ( track->m_Shape == S_ARC_RECT ) )
{
pos.x = track->m_Start.x;
pos.y = track->m_Start.y;
}
else
{
pos.x = (track->m_Start.x + track->m_End.x) / 2;
pos.y = (track->m_Start.y + track->m_End.y) / 2;
pos.x = ( track->m_Start.x + track->m_End.x ) / 2;
pos.y = ( track->m_Start.y + track->m_End.y ) / 2;
}
Line.Printf( wxT( "D%d" ), track->GetNet() );
width = track->m_Width;
orient = TEXT_ORIENT_HORIZ;
if( track->m_Shape >= S_SPOT_CIRCLE ) // forme flash
if( track->m_Shape >= S_SPOT_CIRCLE ) // form flash
{
width /= 3;
}
@ -449,20 +476,19 @@ void Affiche_DCodes_Pistes( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int d
width /= 2;
}
DrawGraphicText( panel, DC,
pos, (EDA_Colors) g_DCodesColor, Line,
DrawGraphicText( panel, DC, pos, (EDA_Colors) g_DCodesColor, Line,
orient, wxSize( width, width ),
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
0, false, false, false);
0, false, false, false );
}
}
/* Virtual fonction needed by the PCB_SCREEN class derived from BASE_SCREEN
* this is a virtual pure function in BASE_SCREEN
* do nothing in gerbview
* could be removed later
*/
void PCB_SCREEN::ClearUndoORRedoList(UNDO_REDO_CONTAINER&, int )
/* Virtual function needed by the PCB_SCREEN class derived from BASE_SCREEN
* this is a virtual pure function in BASE_SCREEN
* do nothing in gerbview
* could be removed later
*/
void PCB_SCREEN::ClearUndoORRedoList( UNDO_REDO_CONTAINER&, int )
{
}

5
gerbview/wxGerberFrame.h
View File

@ -1,5 +1,5 @@
/***********************************************************/
/* wxGerberStruct.h: */
/* wxGerberStruct.h: */
/***********************************************************/
#ifndef WX_GERBER_STRUCT_H
@ -58,7 +58,7 @@ public:
void OnLeftClick( wxDC* DC, const wxPoint& MousePos );
void OnLeftDClick( wxDC* DC, const wxPoint& MousePos );
bool OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu );
int BestZoom(); // Retourne le meilleur zoom
int BestZoom();
void OnSelectOptionToolbar( wxCommandEvent& event );
void OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawStruct );
@ -176,7 +176,6 @@ public:
void CopyDCodesSizeToItems();
void Liste_D_Codes( wxDC* DC );
/* Fonctions specifiques */
void Trace_Gerber( wxDC* DC, int draw_mode, int printmasklayer );
// Copper texts