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

code cleaning

This commit is contained in:
CHARRAS 2008-01-14 19:24:41 +00:00
parent e3a3d16af8
commit 6f2c09c6dc
17 changed files with 3134 additions and 651 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
change_log.txt
View File

@ -3,6 +3,12 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with
email address.
2007-Dec-14 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+pcbnew:
code cleaning:
DRAWSEGMENT class functions moved in the new files class_drawsegment.cpp et .h
2007-Dec-12 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================

1
cvpcb/CMakeLists.txt
View File

@ -37,6 +37,7 @@ SET(CVPCB_EXTRA_SRCS
../pcbnew/basepcbframe.cpp
../pcbnew/class_board.cpp
../pcbnew/class_cotation.cpp
../pcbnew/class_drawsegment.cpp
../pcbnew/class_edge_mod.cpp
../pcbnew/class_equipot.cpp
../pcbnew/class_mire.cpp

4
cvpcb/makefile.include
View File

@ -40,6 +40,7 @@ OBJECTS = $(TARGET).o \
zoom.o \
tracemod.o \
classpcb.o \
class_drawsegment.o \
class_board.o \
class_module.o \
class_pad.o \
@ -86,6 +87,9 @@ class_pcb_text.o: ../pcbnew/class_pcb_text.cpp ../pcbnew/class_pcb_text.h $(COMM
class_board.o: ../pcbnew/class_board.cpp $(DEPEND)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp
class_drawsegment.o: ../pcbnew/class_drawsegment.cpp ../pcbnew/class_drawsegment.h $(DEPEND)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp
class_track.o: ../pcbnew/class_track.cpp $(DEPEND)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp

1
gerbview/CMakeLists.txt
View File

@ -42,6 +42,7 @@ SET(GERBVIEW_SRCS
SET(GERBVIEW_EXTRA_SRCS
../pcbnew/basepcbframe.cpp
../pcbnew/class_board.cpp
../pcbnew/class_drawsegment.cpp
../pcbnew/class_drc_item.cpp
../pcbnew/class_marker.cpp
../pcbnew/class_pcb_text.cpp

4
gerbview/makefile.include
View File

@ -22,6 +22,7 @@ OBJECTS= \
gerberframe.o\
onrightclick.o\
class_board.o\
class_drawsegment.o\
class_track.o \
class_drc_item.o \
drawframe.o\
@ -77,6 +78,9 @@ class_marker.o: ../pcbnew/class_marker.cpp ../pcbnew/class_marker.h $(COMMON)
class_zone.o: ../pcbnew/class_zone.cpp ../pcbnew/class_zone.h $(COMMON)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp
class_drawsegment.o: ../pcbnew/class_drawsegment.cpp ../pcbnew/class_drawsegment.h $(DEPEND)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp
class_drc_item.o: ../pcbnew/class_drc_item.cpp $(COMMON)
$(CXX) -c $(EDACPPFLAGS) -o $@ ../pcbnew/$*.cpp

84
include/pcbstruct.h
View File

@ -250,89 +250,7 @@ public:
/* Description des elements du PCB */
/***********************************/
class DRAWSEGMENT : public BOARD_ITEM
{
public:
int m_Width; // 0 = line. if > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // Shape: line, Circle, Arc
int m_Type; // Used in complex associations ( Dimensions.. )
int m_Angle; // Used only for Arcs: Arc angle in 1/10 deg
public:
DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype = TYPEDRAWSEGMENT );
~DRAWSEGMENT();
/**
* Function GetPosition
* returns the position of this object.
* Required by pure virtual BOARD_ITEM::GetPosition()
* @return const wxPoint& - The position of this object.
*/
wxPoint& GetPosition()
{
return m_Start;
}
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
bool ReadDrawSegmentDescr( FILE* File, int* LineNum );
/* remove this from the linked list */
void UnLink();
void Copy( DRAWSEGMENT* source );
/**
* Function Display_Infos
* has knowledge about the frame and how and where to put status information
* about this object into the frame's message panel.
* Is virtual from EDA_BaseStruct.
* @param frame A WinEDA_BasePcbFrame in which to print status information.
*/
void Display_Infos( WinEDA_DrawFrame* frame );
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param ref_pos A wxPoint to test
* @return bool - true if a hit, else false
*/
bool HitTest( const wxPoint& ref_pos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refPos the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/**
* Function GetClass
* returns the class name.
* @return wxString
*/
wxString GetClass() const
{
return wxT("DRAWSEGMENT");
}
};
#include "class_drawsegment.h"
#include "class_pcb_text.h"
#include "class_cotation.h"
#include "class_mire.h"

1
pcbnew/CMakeLists.txt
View File

@ -23,6 +23,7 @@ SET(PCBNEW_SRCS
class_board.cpp
class_board_item.cpp
class_cotation.cpp
class_drawsegment.cpp
class_drc_item.cpp
class_edge_mod.cpp
class_equipot.cpp

251
pcbnew/class_drawsegment.cpp Normal file
View File

@ -0,0 +1,251 @@
/***************************************************/
/* class and functions to handle a graphic segment */
/****************************************************/
#include "fctsys.h"
#include "wxstruct.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"
#ifdef CVPCB
#include "cvpcb.h"
#endif
#include "trigo.h"
/* DRAWSEGMENT: constructor */
DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype ) :
BOARD_ITEM( StructFather, idtype )
{
m_Width = m_Flags = m_Shape = m_Type = m_Angle = 0;
}
/* destructor */
DRAWSEGMENT:: ~DRAWSEGMENT()
{
}
void DRAWSEGMENT::UnLink()
/**
* Function UnLink
* remove item from linked list.
*/
{
/* ereas back link */
if( Pback )
{
if( Pback->Type() != TYPEPCB )
{
Pback->Pnext = Pnext;
}
else /* Le chainage arriere pointe sur la structure "Pere" */
{
( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
}
}
/* erase forward link */
if( Pnext )
Pnext->Pback = Pback;
Pnext = Pback = NULL;
}
/*******************************************/
void DRAWSEGMENT::Copy( DRAWSEGMENT* source )
/*******************************************/
{
m_Type = source->m_Type;
m_Layer = source->m_Layer;
m_Width = source->m_Width;
m_Start = source->m_Start;
m_End = source->m_End;
m_Shape = source->m_Shape;
m_Angle = source->m_Angle;
m_TimeStamp = source->m_TimeStamp;
}
bool DRAWSEGMENT::Save( FILE* aFile ) const
{
if( GetState( DELETED ) )
return true;
bool rc = false;
if( fprintf( aFile, "$DRAWSEGMENT\n" ) != sizeof("$DRAWSEGMENT\n") - 1 )
goto out;
fprintf( aFile, "Po %d %d %d %d %d %d\n",
m_Shape,
m_Start.x, m_Start.y,
m_End.x, m_End.y, m_Width );
fprintf( aFile, "De %d %d %d %lX %X\n",
m_Layer, m_Type, m_Angle,
m_TimeStamp, ReturnStatus() );
if( fprintf( aFile, "$EndDRAWSEGMENT\n" ) != sizeof("$EndDRAWSEGMENT\n") - 1 )
goto out;
rc = true;
out:
return rc;
}
/******************************************************************/
bool DRAWSEGMENT::ReadDrawSegmentDescr( FILE* File, int* LineNum )
/******************************************************************/
/* Read a DRAWSEGMENT from a file
*/
{
char Line[2048];
while( GetLine( File, Line, LineNum ) != NULL )
{
if( strnicmp( Line, "$End", 4 ) == 0 )
return TRUE; /* End of description */
if( Line[0] == 'P' )
{
sscanf( Line + 2, " %d %d %d %d %d %d",
&m_Shape, &m_Start.x, &m_Start.y,
&m_End.x, &m_End.y, &m_Width );
if( m_Width < 0 )
m_Width = 0;
}
if( Line[0] == 'D' )
{
int status;
sscanf( Line + 2, " %d %d %d %lX %X",
&m_Layer, &m_Type, &m_Angle,
&m_TimeStamp, &status );
if( m_Layer < FIRST_NO_COPPER_LAYER )
m_Layer = FIRST_NO_COPPER_LAYER;
if( m_Layer > LAST_NO_COPPER_LAYER )
m_Layer = LAST_NO_COPPER_LAYER;
SetState( status, ON );
}
}
return FALSE;
}
// see pcbstruct.h
void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
{
int itype;
wxString msg;
frame->MsgPanel->EraseMsgBox();
itype = m_Type & 0x0F;
msg = wxT( "DRAWING" );
Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
Affiche_1_Parametre( frame, 16, _( "Shape" ), wxEmptyString, RED );
if( m_Shape == S_CIRCLE )
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
else if( m_Shape == S_ARC )
{
Affiche_1_Parametre( frame, -1, wxEmptyString, _( " Arc " ), RED );
msg.Printf( wxT( "%d" ), m_Angle );
Affiche_1_Parametre( frame, 32, wxT( " l.arc " ), msg, RED );
}
else
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Segment" ), RED );
Affiche_1_Parametre( frame, 48, _( "Layer" ),
ReturnPcbLayerName( m_Layer ), BROWN );
valeur_param( (unsigned) m_Width, msg );
Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN );
}
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param ref_pos A wxPoint to test
* @return bool - true if a hit, else false
*/
bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
{
int ux0 = m_Start.x;
int uy0 = m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
int dx = m_End.x - ux0;
int dy = m_End.y - uy0;
int spot_cX = ref_pos.x - ux0;
int spot_cY = ref_pos.y - uy0;
if( m_Shape==S_CIRCLE || 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 ) <= (m_Width / 2) )
{
if( m_Shape == S_CIRCLE )
return true;
/* pour un arc, controle complementaire */
mouseAngle = (int) ArcTangente( spot_cY, spot_cX );
stAngle = (int) ArcTangente( dy, dx );
endAngle = stAngle + m_Angle;
if( endAngle > 3600 )
{
stAngle -= 3600;
endAngle -= 3600;
}
if( mouseAngle >= stAngle && mouseAngle <= endAngle )
return true;
}
}
else
{
if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
return true;
}
return false;
}
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool DRAWSEGMENT::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Start ) )
return true;
if( refArea.Inside( m_End ) )
return true;
return false;
}

91
pcbnew/class_drawsegment.h Normal file
View File

@ -0,0 +1,91 @@
/*************************************/
/* class to handle a graphic segment */
/**************************************/
#ifndef CLASS_DRAWSEGMENT_H
#define CLASS_DRAWSEGMENT_H
class DRAWSEGMENT : public BOARD_ITEM
{
public:
int m_Width; // 0 = line. if > 0 = tracks, bus ...
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // Shape: line, Circle, Arc
int m_Type; // Used in complex associations ( Dimensions.. )
int m_Angle; // Used only for Arcs: Arc angle in 1/10 deg
public:
DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype = TYPEDRAWSEGMENT );
~DRAWSEGMENT();
/**
* Function GetPosition
* returns the position of this object.
* Required by pure virtual BOARD_ITEM::GetPosition()
* @return const wxPoint& - The position of this object.
*/
wxPoint& GetPosition()
{
return m_Start;
}
/**
* Function Save
* writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to.
* @return bool - true if success writing else false.
*/
bool Save( FILE* aFile ) const;
bool ReadDrawSegmentDescr( FILE* File, int* LineNum );
/* remove this from the linked list */
void UnLink();
void Copy( DRAWSEGMENT* source );
/**
* Function Display_Infos
* has knowledge about the frame and how and where to put status information
* about this object into the frame's message panel.
* Is virtual from EDA_BaseStruct.
* @param frame A WinEDA_BasePcbFrame in which to print status information.
*/
void Display_Infos( WinEDA_DrawFrame* frame );
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param ref_pos A wxPoint to test
* @return bool - true if a hit, else false
*/
bool HitTest( const wxPoint& ref_pos );
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refPos the given EDA_Rect to test
* @return bool - true if a hit, else false
*/
bool HitTest( EDA_Rect& refArea );
/**
* Function GetClass
* returns the class name.
* @return wxString
*/
wxString GetClass() const
{
return wxT( "DRAWSEGMENT" );
}
};
#endif // #ifndef CLASS_DRAWSEGMENT_H

248
pcbnew/classpcb.cpp
View File

@ -19,8 +19,6 @@
#include "trigo.h"
/**************************************************************/
void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/**************************************************************/
@ -32,242 +30,6 @@ void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
}
/**********************/
/* Classe DRAWSEGMENT */
/**********************/
/* Classe DRAWSEGMENT: constructeur */
DRAWSEGMENT::DRAWSEGMENT( BOARD_ITEM* StructFather, KICAD_T idtype ) :
BOARD_ITEM( StructFather, idtype )
{
m_Width = m_Flags = m_Shape = m_Type = m_Angle = 0;
}
/* Effacement memoire de la structure */
DRAWSEGMENT:: ~DRAWSEGMENT()
{
}
void DRAWSEGMENT::UnLink()
{
/* Modification du chainage arriere */
if( Pback )
{
if( Pback->Type() != TYPEPCB )
{
Pback->Pnext = Pnext;
}
else /* Le chainage arriere pointe sur la structure "Pere" */
{
( (BOARD*) Pback )->m_Drawings = (BOARD_ITEM*) Pnext;
}
}
/* Modification du chainage avant */
if( Pnext )
Pnext->Pback = Pback;
Pnext = Pback = NULL;
}
/*******************************************/
void DRAWSEGMENT::Copy( DRAWSEGMENT* source )
/*******************************************/
{
m_Type = source->m_Type;
m_Layer = source->m_Layer;
m_Width = source->m_Width;
m_Start = source->m_Start;
m_End = source->m_End;
m_Shape = source->m_Shape;
m_Angle = source->m_Angle;
m_TimeStamp = source->m_TimeStamp;
}
bool DRAWSEGMENT::Save( FILE* aFile ) const
{
if( GetState( DELETED ) )
return true;
bool rc = false;
if( fprintf( aFile, "$DRAWSEGMENT\n" ) != sizeof("$DRAWSEGMENT\n")-1 )
goto out;
fprintf( aFile, "Po %d %d %d %d %d %d\n",
m_Shape,
m_Start.x, m_Start.y,
m_End.x, m_End.y, m_Width );
fprintf( aFile, "De %d %d %d %lX %X\n",
m_Layer, m_Type, m_Angle,
m_TimeStamp, ReturnStatus() );
if( fprintf( aFile, "$EndDRAWSEGMENT\n" ) != sizeof("$EndDRAWSEGMENT\n")-1 )
goto out;
rc = true;
out:
return rc;
}
/******************************************************************/
bool DRAWSEGMENT::ReadDrawSegmentDescr( FILE* File, int* LineNum )
/******************************************************************/
/* Lecture de la description de 1 segment type Drawing PCB
*/
{
char Line[2048];
while( GetLine( File, Line, LineNum ) != NULL )
{
if( strnicmp( Line, "$End", 4 ) == 0 )
return TRUE; /* fin de liste */
if( Line[0] == 'P' )
{
sscanf( Line + 2, " %d %d %d %d %d %d",
&m_Shape, &m_Start.x, &m_Start.y,
&m_End.x, &m_End.y, &m_Width );
if( m_Width < 0 )
m_Width = 0;
}
if( Line[0] == 'D' )
{
int status;
sscanf( Line + 2, " %d %d %d %lX %X",
&m_Layer, &m_Type, &m_Angle,
&m_TimeStamp, &status );
if( m_Layer < FIRST_NO_COPPER_LAYER )
m_Layer = FIRST_NO_COPPER_LAYER;
if( m_Layer > LAST_NO_COPPER_LAYER )
m_Layer = LAST_NO_COPPER_LAYER;
SetState( status, ON );
}
}
return FALSE;
}
// see pcbstruct.h
void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
{
int itype;
wxString msg;
frame->MsgPanel->EraseMsgBox();
itype = m_Type & 0x0F;
msg = wxT( "DRAWING" );
Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
Affiche_1_Parametre( frame, 16, _( "Shape" ), wxEmptyString, RED );
if( m_Shape == S_CIRCLE )
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
else if( m_Shape == S_ARC )
{
Affiche_1_Parametre( frame, -1, wxEmptyString, _( " Arc " ), RED );
msg.Printf( wxT( "%d" ), m_Angle );
Affiche_1_Parametre( frame, 32, wxT( " l.arc " ), msg, RED );
}
else
Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Segment" ), RED );
Affiche_1_Parametre( frame, 48, _( "Layer" ),
ReturnPcbLayerName( m_Layer ), BROWN );
/* Affiche Epaisseur */
valeur_param( (unsigned) m_Width, msg );
Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN );
}
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param ref_pos A wxPoint to test
* @return bool - true if a hit, else false
*/
bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
{
int ux0 = m_Start.x;
int uy0 = m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
int dx = m_End.x - ux0;
int dy = m_End.y - uy0;
int spot_cX = ref_pos.x - ux0;
int spot_cY = ref_pos.y - uy0;
if( m_Shape==S_CIRCLE || 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 ) <= (m_Width / 2) )
{
if( m_Shape == S_CIRCLE )
return true;
/* pour un arc, controle complementaire */
mouseAngle = (int) ArcTangente( spot_cY, spot_cX );
stAngle = (int) ArcTangente( dy, dx );
endAngle = stAngle + m_Angle;
if( endAngle > 3600 )
{
stAngle -= 3600;
endAngle -= 3600;
}
if( mouseAngle >= stAngle && mouseAngle <= endAngle )
return true;
}
}
else
{
if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
return true;
}
return false;
}
/**
* Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object.
* For now, an ending point must be inside this rect.
* @param refArea : the given EDA_Rect
* @return bool - true if a hit, else false
*/
bool DRAWSEGMENT::HitTest( EDA_Rect& refArea )
{
if( refArea.Inside( m_Start ) )
return true;
if( refArea.Inside( m_End ) )
return true;
return false;
}
/**************************************************/
/* Class SCREEN: classe de gestion d'un affichage */
/***************************************************/
@ -317,15 +79,16 @@ bool PCB_SCREEN::IsMicroViaAcceptable(void)
return false; // Obvious..
if( copperlayercnt < 4 )
return false; // Only on multilayer boards..
if ( (m_Active_Layer == COPPER_LAYER_N) ||
(m_Active_Layer == LAYER_CMP_N) ||
(m_Active_Layer == g_DesignSettings.m_CopperLayerCount - 2) ||
(m_Active_Layer == LAYER_N_2) )
if( (m_Active_Layer == COPPER_LAYER_N)
|| (m_Active_Layer == LAYER_CMP_N)
|| (m_Active_Layer == g_DesignSettings.m_CopperLayerCount - 2)
|| (m_Active_Layer == LAYER_N_2) )
return true;
return false;
}
/*************************/
/* class DISPLAY_OPTIONS */
/*************************/
@ -433,4 +196,3 @@ int EDA_BoardDesignSettings::GetVisibleLayers() const
return layerMask;
}

385
pcbnew/dialog_gendrill.cpp Normal file
View File

@ -0,0 +1,385 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog_gendrill.cpp
// Purpose:
// Author: jean-pierre Charras
// Modified by:
// Created: 13/01/2008 17:26:27
// RCS-ID:
// Copyright: License GNU
// Licence:
/////////////////////////////////////////////////////////////////////////////
// Generated by DialogBlocks (unregistered), 13/01/2008 17:26:27
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
////@begin includes
////@end includes
#include "dialog_gendrill.h"
////@begin XPM images
////@end XPM images
/*!
* WinEDA_DrillFrame type definition
*/
IMPLEMENT_DYNAMIC_CLASS( WinEDA_DrillFrame, wxDialog )
/*!
* WinEDA_DrillFrame event table definition
*/
BEGIN_EVENT_TABLE( WinEDA_DrillFrame, wxDialog )
////@begin WinEDA_DrillFrame event table entries
EVT_CLOSE( WinEDA_DrillFrame::OnCloseWindow )
EVT_RADIOBOX( ID_SEL_DRILL_UNITS, WinEDA_DrillFrame::OnSelDrillUnitsSelected )
EVT_RADIOBOX( ID_SEL_ZEROS_FMT, WinEDA_DrillFrame::OnSelZerosFmtSelected )
EVT_BUTTON( wxID_OK, WinEDA_DrillFrame::OnOkClick )
EVT_BUTTON( wxID_CLOSE, WinEDA_DrillFrame::OnCloseClick )
////@end WinEDA_DrillFrame event table entries
END_EVENT_TABLE()
/*!
* WinEDA_DrillFrame constructors
*/
WinEDA_DrillFrame::WinEDA_DrillFrame()
{
Init();
}
WinEDA_DrillFrame::WinEDA_DrillFrame( WinEDA_PcbFrame* parent, wxWindowID id,
const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
m_Parent = parent;
SetFont( *g_DialogFont );
SetReturnCode( 1 );
Init();
Create(parent, id, caption, pos, size, style);
}
/*!
* WinEDA_DrillFrame creator
*/
bool WinEDA_DrillFrame::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
////@begin WinEDA_DrillFrame creation
SetExtraStyle(wxWS_EX_BLOCK_EVENTS);
wxDialog::Create( parent, id, caption, pos, size, style );
CreateControls();
if (GetSizer())
{
GetSizer()->SetSizeHints(this);
}
Centre();
////@end WinEDA_DrillFrame creation
return true;
}
/*!
* WinEDA_DrillFrame destructor
*/
WinEDA_DrillFrame::~WinEDA_DrillFrame()
{
////@begin WinEDA_DrillFrame destruction
////@end WinEDA_DrillFrame destruction
}
/*!
* Member initialisation
*/
void WinEDA_DrillFrame::Init()
{
////@begin WinEDA_DrillFrame member initialisation
m_LeftBoxSizer = NULL;
m_Choice_Unit = NULL;
m_Choice_Zeros_Format = NULL;
m_Choice_Precision = NULL;
m_Choice_Drill_Offset = NULL;
m_Choice_Drill_Map = NULL;
m_Choice_Drill_Report = NULL;
m_PenSpeed = NULL;
m_PenNum = NULL;
m_Check_Mirror = NULL;
m_Check_Minimal = NULL;
m_DefaultViasDrillSizer = NULL;
m_ViaDrillValue = NULL;
m_MicroViasDrillSizer = NULL;
m_MicroViaDrillValue = NULL;
m_PadsCountInfoMsg = NULL;
m_ThroughViasInfoMsg = NULL;
m_MicroViasInfoMsg = NULL;
m_BuriedViasInfoMsg = NULL;
////@end WinEDA_DrillFrame member initialisation
}
/*!
* Control creation for WinEDA_DrillFrame
*/
void WinEDA_DrillFrame::CreateControls()
{
////@begin WinEDA_DrillFrame content construction
// Generated by DialogBlocks, 14/01/2008 08:32:06 (unregistered)
WinEDA_DrillFrame* itemDialog1 = this;
wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxHORIZONTAL);
itemDialog1->SetSizer(itemBoxSizer2);
m_LeftBoxSizer = new wxBoxSizer(wxVERTICAL);
itemBoxSizer2->Add(m_LeftBoxSizer, 0, wxGROW|wxALL, 5);
wxArrayString m_Choice_UnitStrings;
m_Choice_UnitStrings.Add(_("Millimeters"));
m_Choice_UnitStrings.Add(_("Inches"));
m_Choice_Unit = new wxRadioBox( itemDialog1, ID_SEL_DRILL_UNITS, _("Drill Units:"), wxDefaultPosition, wxDefaultSize, m_Choice_UnitStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Unit->SetSelection(0);
m_LeftBoxSizer->Add(m_Choice_Unit, 0, wxGROW|wxALL, 5);
wxArrayString m_Choice_Zeros_FormatStrings;
m_Choice_Zeros_FormatStrings.Add(_("decimal format"));
m_Choice_Zeros_FormatStrings.Add(_("suppress leading zeros"));
m_Choice_Zeros_FormatStrings.Add(_("suppress trailing zeros"));
m_Choice_Zeros_FormatStrings.Add(_("keep zeros"));
m_Choice_Zeros_Format = new wxRadioBox( itemDialog1, ID_SEL_ZEROS_FMT, _("Zeros Format"), wxDefaultPosition, wxDefaultSize, m_Choice_Zeros_FormatStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Zeros_Format->SetSelection(0);
m_LeftBoxSizer->Add(m_Choice_Zeros_Format, 0, wxALIGN_LEFT|wxALL, 5);
wxArrayString m_Choice_PrecisionStrings;
m_Choice_PrecisionStrings.Add(_("2:3"));
m_Choice_PrecisionStrings.Add(_("2:4"));
m_Choice_Precision = new wxRadioBox( itemDialog1, ID_SEL_PRECISION, _("Precision"), wxDefaultPosition, wxDefaultSize, m_Choice_PrecisionStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Precision->SetSelection(0);
m_LeftBoxSizer->Add(m_Choice_Precision, 0, wxGROW|wxALL, 5);
wxArrayString m_Choice_Drill_OffsetStrings;
m_Choice_Drill_OffsetStrings.Add(_("absolute"));
m_Choice_Drill_OffsetStrings.Add(_("auxiliary axis"));
m_Choice_Drill_Offset = new wxRadioBox( itemDialog1, ID_SEL_DRILL_SHEET, _("Drill Origin:"), wxDefaultPosition, wxDefaultSize, m_Choice_Drill_OffsetStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Drill_Offset->SetSelection(0);
m_LeftBoxSizer->Add(m_Choice_Drill_Offset, 0, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer2->Add(itemBoxSizer8, 0, wxGROW|wxALL, 5);
wxArrayString m_Choice_Drill_MapStrings;
m_Choice_Drill_MapStrings.Add(_("None"));
m_Choice_Drill_MapStrings.Add(_("drill sheet (HPGL)"));
m_Choice_Drill_MapStrings.Add(_("drill sheet (PostScript)"));
m_Choice_Drill_Map = new wxRadioBox( itemDialog1, ID_SEL_DRILL_SHEET, _("Drill Sheet:"), wxDefaultPosition, wxDefaultSize, m_Choice_Drill_MapStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Drill_Map->SetSelection(0);
itemBoxSizer8->Add(m_Choice_Drill_Map, 0, wxGROW|wxALL, 5);
wxArrayString m_Choice_Drill_ReportStrings;
m_Choice_Drill_ReportStrings.Add(_("None"));
m_Choice_Drill_ReportStrings.Add(_("Drill report"));
m_Choice_Drill_Report = new wxRadioBox( itemDialog1, ID_SEL_DRILL_REPORT, _("Drill Report:"), wxDefaultPosition, wxDefaultSize, m_Choice_Drill_ReportStrings, 1, wxRA_SPECIFY_COLS );
m_Choice_Drill_Report->SetSelection(0);
itemBoxSizer8->Add(m_Choice_Drill_Report, 0, wxGROW|wxALL, 5);
wxStaticBox* itemStaticBoxSizer11Static = new wxStaticBox(itemDialog1, wxID_ANY, _("HPGL plotter Options:"));
wxStaticBoxSizer* itemStaticBoxSizer11 = new wxStaticBoxSizer(itemStaticBoxSizer11Static, wxVERTICAL);
itemBoxSizer8->Add(itemStaticBoxSizer11, 0, wxGROW|wxALL, 5);
wxStaticText* itemStaticText12 = new wxStaticText( itemDialog1, wxID_STATIC, _("Speed (cm/s)"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer11->Add(itemStaticText12, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
m_PenSpeed = new wxTextCtrl( itemDialog1, ID_TEXTCTRL2, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer11->Add(m_PenSpeed, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxStaticText* itemStaticText14 = new wxStaticText( itemDialog1, wxID_STATIC, _("Pen Number"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer11->Add(itemStaticText14, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
m_PenNum = new wxTextCtrl( itemDialog1, ID_TEXTCTRL, _T(""), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer11->Add(m_PenNum, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxStaticBox* itemStaticBoxSizer16Static = new wxStaticBox(itemDialog1, wxID_ANY, _("Options:"));
wxStaticBoxSizer* itemStaticBoxSizer16 = new wxStaticBoxSizer(itemStaticBoxSizer16Static, wxVERTICAL);
itemStaticBoxSizer11->Add(itemStaticBoxSizer16, 0, wxGROW|wxALL, 5);
m_Check_Mirror = new wxCheckBox( itemDialog1, ID_CHECKBOX2, _("mirror y axis"), wxDefaultPosition, wxDefaultSize, 0 );
m_Check_Mirror->SetValue(false);
itemStaticBoxSizer16->Add(m_Check_Mirror, 0, wxGROW|wxALL, 5);
m_Check_Minimal = new wxCheckBox( itemDialog1, ID_CHECKBOX3, _("minimal header"), wxDefaultPosition, wxDefaultSize, 0 );
m_Check_Minimal->SetValue(false);
itemStaticBoxSizer16->Add(m_Check_Minimal, 0, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer19 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer2->Add(itemBoxSizer19, 0, wxGROW|wxALL, 5);
wxStaticBox* itemStaticBoxSizer20Static = new wxStaticBox(itemDialog1, wxID_ANY, _("Info:"));
wxStaticBoxSizer* itemStaticBoxSizer20 = new wxStaticBoxSizer(itemStaticBoxSizer20Static, wxVERTICAL);
itemBoxSizer19->Add(itemStaticBoxSizer20, 0, wxGROW|wxALL, 5);
m_DefaultViasDrillSizer = new wxStaticBox(itemDialog1, wxID_ANY, _("Default Vias Drill:"));
wxStaticBoxSizer* itemStaticBoxSizer21 = new wxStaticBoxSizer(m_DefaultViasDrillSizer, wxVERTICAL);
itemStaticBoxSizer20->Add(itemStaticBoxSizer21, 0, wxGROW|wxALL, 5);
m_ViaDrillValue = new wxStaticText( itemDialog1, wxID_STATIC, _("Via Drill Value"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer21->Add(m_ViaDrillValue, 0, wxGROW|wxALL, 5);
m_MicroViasDrillSizer = new wxStaticBox(itemDialog1, wxID_ANY, _("Micro Vias Drill:"));
wxStaticBoxSizer* itemStaticBoxSizer23 = new wxStaticBoxSizer(m_MicroViasDrillSizer, wxVERTICAL);
itemStaticBoxSizer20->Add(itemStaticBoxSizer23, 0, wxGROW|wxALL, 5);
m_MicroViaDrillValue = new wxStaticText( itemDialog1, wxID_STATIC, _("Micro Via Drill Value"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer23->Add(m_MicroViaDrillValue, 0, wxGROW|wxALL, 5);
wxStaticBox* itemStaticBoxSizer25Static = new wxStaticBox(itemDialog1, wxID_ANY, _("Holes Count:"));
wxStaticBoxSizer* itemStaticBoxSizer25 = new wxStaticBoxSizer(itemStaticBoxSizer25Static, wxVERTICAL);
itemStaticBoxSizer20->Add(itemStaticBoxSizer25, 0, wxGROW|wxALL, 5);
m_PadsCountInfoMsg = new wxStaticText( itemDialog1, wxID_STATIC, _("Pads:"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer25->Add(m_PadsCountInfoMsg, 0, wxGROW|wxALL, 5);
m_ThroughViasInfoMsg = new wxStaticText( itemDialog1, wxID_STATIC, _("Through Vias:"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer25->Add(m_ThroughViasInfoMsg, 0, wxGROW|wxALL, 5);
m_MicroViasInfoMsg = new wxStaticText( itemDialog1, wxID_STATIC, _("Micro Vias:"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer25->Add(m_MicroViasInfoMsg, 0, wxGROW|wxALL, 5);
m_BuriedViasInfoMsg = new wxStaticText( itemDialog1, wxID_STATIC, _("Buried Vias:"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticBoxSizer25->Add(m_BuriedViasInfoMsg, 0, wxGROW|wxALL, 5);
itemBoxSizer19->Add(5, 5, 1, wxGROW|wxALL, 5);
wxButton* itemButton31 = new wxButton( itemDialog1, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );
itemButton31->SetForegroundColour(wxColour(156, 1, 5));
itemBoxSizer19->Add(itemButton31, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxButton* itemButton32 = new wxButton( itemDialog1, wxID_CLOSE, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
itemButton32->SetForegroundColour(wxColour(16, 1, 205));
itemBoxSizer19->Add(itemButton32, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
// Set validators
m_Choice_Unit->SetValidator( wxGenericValidator(& s_Unit_Drill_is_Inch) );
m_Choice_Zeros_Format->SetValidator( wxGenericValidator(& s_Zeros_Format) );
m_Check_Mirror->SetValidator( wxGenericValidator(& Mirror) );
m_Check_Minimal->SetValidator( wxGenericValidator(& Minimal) );
////@end WinEDA_DrillFrame content construction
InitDisplayParams();
}
/*!
* wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_RADIOBOX
*/
void WinEDA_DrillFrame::OnSelDrillUnitsSelected( wxCommandEvent& event )
{
UpdatePrecisionOptions(event);
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_OK
*/
void WinEDA_DrillFrame::OnOkClick( wxCommandEvent& event )
{
GenDrillFiles(event);
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CLOSE
*/
void WinEDA_DrillFrame::OnCloseClick( wxCommandEvent& event )
{
UpdateConfig(); /* Save drill options: */
Close( true ); // true is to force the frame to close
}
/*!
* Should we show tooltips?
*/
bool WinEDA_DrillFrame::ShowToolTips()
{
return true;
}
/*!
* Get bitmap resources
*/
wxBitmap WinEDA_DrillFrame::GetBitmapResource( const wxString& name )
{
// Bitmap retrieval
////@begin WinEDA_DrillFrame bitmap retrieval
wxUnusedVar(name);
return wxNullBitmap;
////@end WinEDA_DrillFrame bitmap retrieval
}
/*!
* Get icon resources
*/
wxIcon WinEDA_DrillFrame::GetIconResource( const wxString& name )
{
// Icon retrieval
////@begin WinEDA_DrillFrame icon retrieval
wxUnusedVar(name);
return wxNullIcon;
////@end WinEDA_DrillFrame icon retrieval
}
/*!
* wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_SEL_ZEROS_FMT
*/
void WinEDA_DrillFrame::OnSelZerosFmtSelected( wxCommandEvent& event )
{
UpdatePrecisionOptions(event);
}
/*!
* wxEVT_CLOSE_WINDOW event handler for ID_WINEDA_DRILLFRAME
*/
void WinEDA_DrillFrame::OnCloseWindow( wxCloseEvent& event )
{
////@begin wxEVT_CLOSE_WINDOW event handler for ID_WINEDA_DRILLFRAME in WinEDA_DrillFrame.
// Before editing this code, remove the block markers.
event.Skip();
////@end wxEVT_CLOSE_WINDOW event handler for ID_WINEDA_DRILLFRAME in WinEDA_DrillFrame.
}

163
pcbnew/dialog_gendrill.h Normal file
View File

@ -0,0 +1,163 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog_gendrill.h
// Purpose:
// Author: jean-pierre Charras
// Modified by:
// Created: 13/01/2008 17:26:27
// RCS-ID:
// Copyright: License GNU
// Licence:
/////////////////////////////////////////////////////////////////////////////
// Generated by DialogBlocks (unregistered), 13/01/2008 17:26:27
#ifndef _DIALOG_GENDRILL_H_
#define _DIALOG_GENDRILL_H_
/*!
* Includes
*/
////@begin includes
#include "wx/valgen.h"
////@end includes
/*!
* Forward declarations
*/
////@begin forward declarations
class wxBoxSizer;
////@end forward declarations
/*!
* Control identifiers
*/
////@begin control identifiers
#define ID_WINEDA_DRILLFRAME 10000
#define ID_SEL_DRILL_UNITS 10002
#define ID_SEL_ZEROS_FMT 10001
#define ID_SEL_PRECISION 10003
#define ID_SEL_DRILL_SHEET 10004
#define ID_SEL_DRILL_REPORT 10010
#define ID_TEXTCTRL2 10007
#define ID_TEXTCTRL 10006
#define ID_CHECKBOX2 10011
#define ID_CHECKBOX3 10012
#define SYMBOL_WINEDA_DRILLFRAME_STYLE wxCAPTION|wxRESIZE_BORDER|wxSYSTEM_MENU|wxCLOSE_BOX|wxTAB_TRAVERSAL
#define SYMBOL_WINEDA_DRILLFRAME_TITLE _("WinEDA_DrillFrame")
#define SYMBOL_WINEDA_DRILLFRAME_IDNAME ID_WINEDA_DRILLFRAME
#define SYMBOL_WINEDA_DRILLFRAME_SIZE wxSize(400, 300)
#define SYMBOL_WINEDA_DRILLFRAME_POSITION wxDefaultPosition
////@end control identifiers
/*!
* WinEDA_DrillFrame class declaration
*/
class WinEDA_DrillFrame: public wxDialog
{
DECLARE_DYNAMIC_CLASS( WinEDA_DrillFrame )
DECLARE_EVENT_TABLE()
public:
/// Constructors
WinEDA_DrillFrame();
WinEDA_DrillFrame( WinEDA_PcbFrame* parent,
wxWindowID id = SYMBOL_WINEDA_DRILLFRAME_IDNAME,
const wxString& caption = SYMBOL_WINEDA_DRILLFRAME_TITLE,
const wxPoint& pos = SYMBOL_WINEDA_DRILLFRAME_POSITION,
const wxSize& size = SYMBOL_WINEDA_DRILLFRAME_SIZE,
long style = SYMBOL_WINEDA_DRILLFRAME_STYLE );
/// Creation
bool Create( wxWindow* parent, wxWindowID id = SYMBOL_WINEDA_DRILLFRAME_IDNAME, const wxString& caption = SYMBOL_WINEDA_DRILLFRAME_TITLE, const wxPoint& pos = SYMBOL_WINEDA_DRILLFRAME_POSITION, const wxSize& size = SYMBOL_WINEDA_DRILLFRAME_SIZE, long style = SYMBOL_WINEDA_DRILLFRAME_STYLE );
/// Destructor
~WinEDA_DrillFrame();
/// Initialises member variables
void Init();
/// Creates the controls and sizers
void CreateControls();
////@begin WinEDA_DrillFrame event handler declarations
/// wxEVT_CLOSE_WINDOW event handler for ID_WINEDA_DRILLFRAME
void OnCloseWindow( wxCloseEvent& event );
/// wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_SEL_DRILL_UNITS
void OnSelDrillUnitsSelected( wxCommandEvent& event );
/// wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_SEL_ZEROS_FMT
void OnSelZerosFmtSelected( wxCommandEvent& event );
/// wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_OK
void OnOkClick( wxCommandEvent& event );
/// wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CLOSE
void OnCloseClick( wxCommandEvent& event );
////@end WinEDA_DrillFrame event handler declarations
////@begin WinEDA_DrillFrame member function declarations
/// Retrieves bitmap resources
wxBitmap GetBitmapResource( const wxString& name );
/// Retrieves icon resources
wxIcon GetIconResource( const wxString& name );
////@end WinEDA_DrillFrame member function declarations
/// Should we show tooltips?
static bool ShowToolTips();
////@begin WinEDA_DrillFrame member variables
wxBoxSizer* m_LeftBoxSizer;
wxRadioBox* m_Choice_Unit;
wxRadioBox* m_Choice_Zeros_Format;
wxRadioBox* m_Choice_Precision;
wxRadioBox* m_Choice_Drill_Offset;
wxRadioBox* m_Choice_Drill_Map;
wxRadioBox* m_Choice_Drill_Report;
wxTextCtrl* m_PenSpeed;
wxTextCtrl* m_PenNum;
wxCheckBox* m_Check_Mirror;
wxCheckBox* m_Check_Minimal;
wxStaticBox* m_DefaultViasDrillSizer;
wxStaticText* m_ViaDrillValue;
wxStaticBox* m_MicroViasDrillSizer;
wxStaticText* m_MicroViaDrillValue;
wxStaticText* m_PadsCountInfoMsg;
wxStaticText* m_ThroughViasInfoMsg;
wxStaticText* m_MicroViasInfoMsg;
wxStaticText* m_BuriedViasInfoMsg;
////@end WinEDA_DrillFrame member variables
private:
WinEDA_PcbFrame* m_Parent;
int m_PadsHoleCount;
int m_ThroughViasCount;
int m_MicroViasCount;
int m_BlindOrBuriedViasCount;
private:
void InitDisplayParams(void);
void SetParams(void);
void GenDrillFiles( wxCommandEvent& event );
void GenDrillMap( int format );
void UpdatePrecisionOptions( wxCommandEvent& event );
void UpdateConfig();
int Plot_Drill_PcbMap( FORET* buffer, int format );
void GenDrillReport();
int Gen_Liste_Forets( FORET* buffer, bool print_header );
int Create_Drill_File_EXCELLON( FORET* buffer );
void Init_Drill();
};
#endif
// _DIALOG_GENDRILL_H_

2015
pcbnew/dialog_gendrill.pjd Normal file
View File

File diff suppressed because it is too large Load Diff

452
pcbnew/gendrill.cpp
View File

@ -1,35 +1,32 @@
/***********************************************/
/* Routine de Generation du fichier de percage */
/***********************************************/
/***************************************************************/
/* Functionbs to create EXCELLON drill files and report files */
/***************************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "plot_common.h"
#include "trigo.h"
#include "pcbnew.h"
#include "pcbplot.h"
#include "autorout.h"
#include "macros.h"
#include "protos.h"
#include "wx/defs.h"
/*
* Generation du fichier de percage en format EXCELLON
* Variantes supportees:
* - Decimal : coord flottantes en pouces
* - Metric : coord entieres en 1/10000 mm
* format "Trailling Zero" ( TZ )
* Creates the drill files in EXCELLON format
* Number format:
* - Floating point format
* - integer format
* - integer format: "Trailling Zero" ( TZ ) or "Leading Zero"
* Units
* - Decimal
* - Metric
*
* On peut aussi generer le plan de percage en format HPGL ou PS
* The drill maps can be created in HPGL or PS format
*
* dialog_gendrill.cpp is the file (included in this file) which handles the Dialog box for drill file generation
*/
/* Routines importees */
class FORET
class DRILL_TOOL
{
public:
int m_TotalCount;
@ -56,7 +53,8 @@ enum zeros_fmt {
KEEP_ZEROS
};
/* Routines Locales */
/* Local Function */
static void Gen_Line_EXCELLON( char* line, float x, float y );
static void Write_End_Of_File_Drill();
static void PlotDrillSymbol( const wxPoint& position, int diametre, int num_forme, int format );
static void PlotOvalDrillSymbol( const wxPoint& position,
@ -64,10 +62,10 @@ static void PlotOvalDrillSymbol( const wxPoint& position,
int orient,
int format );
/* Variables locales : */
static int DrillToolsCount; /* Nombre de forets a utiliser */
/* Local Variables : */
static int s_DrillToolsCount; /* Nombre de forets a utiliser */
static float conv_unit; /* coeff de conversion des unites drill / pcb */
static bool Unit_Drill_is_Inch = TRUE; /* INCH,LZ (2:4) */
static int s_Unit_Drill_is_Inch = TRUE; /* INCH,LZ (2:4) */
static int s_Zeros_Format = DECIMAL_FORMAT;
static DrillPrecision s_Precision( 2, 4 );
@ -85,205 +83,108 @@ static bool Mirror = true;
#define UnitDrillInchKey wxT( "DrillUnit" )
#define DrillOriginIsAuxAxisKey wxT( "DrillAuxAxis" )
/****************************************/
/* Dialog box for drill file generation */
/****************************************/
enum id_drill {
ID_CREATE_DRILL_FILES = 1370,
ID_CLOSE_DRILL,
ID_SEL_DRILL_UNITS,
ID_SEL_DRILL_SHEET,
ID_SEL_DRILL_REPORT,
ID_SEL_ZEROS_FMT,
ID_SEL_PRECISION
};
#include "dialog_gendrill.cpp" // Dialog box for drill file generation
class WinEDA_DrillFrame : public wxDialog
/**********************************************/
void WinEDA_DrillFrame::InitDisplayParams(void)
/**********************************************/
/* some param values befor display dialog
*/
{
WinEDA_PcbFrame* m_Parent;
wxRadioBox* m_Choice_Drill_Map;
wxRadioBox* m_Choice_Drill_Report;
wxRadioBox* m_Choice_Unit;
wxRadioBox* m_Choice_Drill_Offset;
WinEDA_EnterText* m_EnterFileNameDrill;
WinEDA_ValueCtrl* m_ViaDrillCtrl;
WinEDA_ValueCtrl* m_PenSpeed;
WinEDA_ValueCtrl* m_PenNum;
wxCheckBox* m_Check_Mirror;
wxCheckBox* m_Check_Minimal;
wxRadioBox* m_Choice_Zeros_Format;
wxRadioBox* m_Choice_Precision;
wxString msg;
if( s_Zeros_Format==DECIMAL_FORMAT )
m_Choice_Precision->Enable( false );
if( DrillOriginIsAuxAxis )
m_Choice_Drill_Offset->SetSelection( 1 );
// Constructor and destructor
public:
WinEDA_DrillFrame( WinEDA_PcbFrame* parent );
~WinEDA_DrillFrame() { };
private:
void OnQuit( wxCommandEvent& event );
void SetParams();
void GenDrillFiles( wxCommandEvent& event );
void GenDrillMap( int format );
void UpdatePrecisionOptions( wxCommandEvent& event );
void UpdateConfig();
int Plot_Drill_PcbMap( FORET* buffer, int format );
void GenDrillReport();
int Gen_Liste_Forets( FORET* buffer, bool print_header );
int Gen_Drill_File_EXCELLON( FORET* buffer );
void Gen_Line_EXCELLON( char* line, float x, float y );
void Init_Drill();
DECLARE_EVENT_TABLE()
};
BEGIN_EVENT_TABLE( WinEDA_DrillFrame, wxDialog )
EVT_BUTTON( ID_CLOSE_DRILL, WinEDA_DrillFrame::OnQuit )
EVT_BUTTON( ID_CREATE_DRILL_FILES, WinEDA_DrillFrame::GenDrillFiles )
EVT_RADIOBOX( ID_SEL_DRILL_UNITS, WinEDA_DrillFrame::UpdatePrecisionOptions )
EVT_RADIOBOX( ID_SEL_ZEROS_FMT, WinEDA_DrillFrame::UpdatePrecisionOptions )
END_EVENT_TABLE()
#define H_SIZE 550
#define V_SIZE 250
/*************************************************************************/
WinEDA_DrillFrame::WinEDA_DrillFrame( WinEDA_PcbFrame* parent ) :
wxDialog( parent, -1, _( "Drill tools" ), wxDefaultPosition, wxSize( H_SIZE, V_SIZE ),
DIALOG_STYLE )
/*************************************************************************/
{
m_Parent = parent;
SetFont( *g_DialogFont );
SetReturnCode( 1 );
wxBoxSizer* MainBoxSizer = new wxBoxSizer( wxHORIZONTAL );
SetSizer( MainBoxSizer );
wxBoxSizer* LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer* MiddleBoxSizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer* RightBoxSizer = new wxBoxSizer( wxVERTICAL );
MainBoxSizer->Add( LeftBoxSizer, 0, wxGROW | wxALL, 5 );
MainBoxSizer->Add( MiddleBoxSizer, 0, wxGROW | wxALL, 5 );
MainBoxSizer->Add( RightBoxSizer, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5 );
/* first column, NC drill options */
wxString choice_unit_msg[] =
{ _( "millimeters" ), _( "inches" ) };
m_Choice_Unit = new wxRadioBox( this, ID_SEL_DRILL_UNITS,
_( "Drill Units:" ),
wxDefaultPosition, wxSize( -1, -1 ),
2, choice_unit_msg, 1, wxRA_SPECIFY_COLS );
if( Unit_Drill_is_Inch )
m_Choice_Unit->SetSelection( 1 );
LeftBoxSizer->Add( m_Choice_Unit, 0, wxGROW | wxALL, 5 );
wxString choice_zeros_format_msg[] = {
_( "decimal format" ),
_( "suppress leading zeros" ), _( "suppress trailing zeros" ), _( "keep zeros" )
};
m_Choice_Zeros_Format = new wxRadioBox( this, ID_SEL_ZEROS_FMT,
_( "Zeros Format" ),
wxDefaultPosition, wxSize( -1, -1 ),
4, choice_zeros_format_msg, 1, wxRA_SPECIFY_COLS );
m_Choice_Zeros_Format->SetSelection( s_Zeros_Format );
LeftBoxSizer->Add( m_Choice_Zeros_Format, 0, wxGROW | wxALL, 5 );
wxString* choice_precision_msg;
wxString choice_precision_inch_msg[] = { _( "2:3" ), _( "2:4" ) };
wxString choice_precision_metric_msg[] = { _( "3:2" ), _( "3:3" ) };
if( Unit_Drill_is_Inch )
choice_precision_msg = choice_precision_inch_msg;
else
choice_precision_msg = choice_precision_metric_msg;
m_Choice_Precision = new wxRadioBox( this, ID_SEL_PRECISION,
_( "Precision" ),
wxDefaultPosition, wxSize( -1, -1 ),
2, choice_precision_msg, 1, wxRA_SPECIFY_COLS );
LeftBoxSizer->Add( m_Choice_Precision, 0, wxGROW | wxALL, 5 );
wxString ps;
ps << s_Precision.m_lhs << wxT( ":" ) << s_Precision.m_rhs;
m_Choice_Precision->SetStringSelection( ps );
msg << s_Precision.m_lhs << wxT( ":" ) << s_Precision.m_rhs;
m_Choice_Precision->SetStringSelection( msg );
if( s_Zeros_Format==DECIMAL_FORMAT )
m_Choice_Precision->Enable( false );
wxString choice_drill_offset_msg[] =
{ _( "absolute" ), _( "auxiliary axis" ) };
m_Choice_Drill_Offset = new wxRadioBox( this, ID_SEL_DRILL_SHEET,
_( "Drill Origin:" ),
wxDefaultPosition, wxSize( -1, -1 ),
2, choice_drill_offset_msg, 1, wxRA_SPECIFY_COLS );
if( DrillOriginIsAuxAxis )
m_Choice_Drill_Offset->SetSelection( 1 );
LeftBoxSizer->Add( m_Choice_Drill_Offset, 0, wxGROW | wxALL, 5 );
msg = ReturnStringFromValue( g_UnitMetric, g_DesignSettings.m_ViaDrill, m_Parent->m_InternalUnits );
msg += ReturnUnitSymbol( g_UnitMetric );
m_ViaDrillValue->SetLabel(msg);
/* second column */
wxString choice_drill_map_msg[] =
{ _( "None" ), _( "drill sheet (HPGL)" ), _( "drill sheet (PostScript)" ) };
m_Choice_Drill_Map = new wxRadioBox( this, ID_SEL_DRILL_SHEET,
_( "Drill Sheet:" ),
wxDefaultPosition, wxSize( -1, -1 ),
3, choice_drill_map_msg, 1, wxRA_SPECIFY_COLS );
MiddleBoxSizer->Add( m_Choice_Drill_Map, 0, wxGROW | wxALL, 5 );
msg = ReturnStringFromValue( g_UnitMetric, g_DesignSettings.m_MicroViaDrill, m_Parent->m_InternalUnits );
msg += ReturnUnitSymbol( g_UnitMetric );
m_MicroViaDrillValue->SetLabel(msg);
wxString choice_drill_report_msg[] =
{ _( "None" ), _( "Drill report" ) };
m_Choice_Drill_Report = new wxRadioBox( this, ID_SEL_DRILL_REPORT,
_( "Drill Report:" ),
wxDefaultPosition, wxSize( -1, -1 ),
2, choice_drill_report_msg, 1, wxRA_SPECIFY_COLS );
MiddleBoxSizer->Add( m_Choice_Drill_Report, 0, wxGROW | wxALL, 5 );
msg.Empty();
msg << g_HPGL_Pen_Num;
m_PenNum->SetValue(msg);
m_ViaDrillCtrl = new WinEDA_ValueCtrl( this, _(
"Via Drill" ),
g_DesignSettings.m_ViaDrill, g_UnitMetric,
MiddleBoxSizer,
m_Parent->m_InternalUnits );
msg.Empty();
msg << g_HPGL_Pen_Speed;
m_PenSpeed->SetValue(msg);
m_PenNum = new WinEDA_ValueCtrl( this, _( "Pen Number" ),
g_HPGL_Pen_Num, 2, MiddleBoxSizer, 1 );
// See if we have some microvias, and display drill value if so
m_ThroughViasCount = 0;
m_MicroViasCount = 0;
m_BlindOrBuriedViasCount = 0;
for ( TRACK * track = m_Parent->m_Pcb->m_Track; track != NULL; track = track->Next() )
{
if ( track->Type() != TYPEVIA ) continue;
if ( track->Shape() == VIA_THROUGH )
m_ThroughViasCount++;
else if ( track->Shape() == VIA_MICROVIA )
m_MicroViasCount++;
else if ( track->Shape() == VIA_BLIND_BURIED )
m_BlindOrBuriedViasCount++;
}
m_MicroViasDrillSizer->Enable(m_MicroViasCount);
m_MicroViaDrillValue->Enable(m_MicroViasCount);
m_PenSpeed = new WinEDA_ValueCtrl( this, _( "Speed (cm/s)" ),
g_HPGL_Pen_Speed, CENTIMETRE, MiddleBoxSizer, 1 );
/* Display statistics */
// Pads holes cound:
m_PadsHoleCount = 0;
for ( MODULE * module = m_Parent->m_Pcb->m_Modules; module != NULL; module=module->Next() )
{
for ( D_PAD * pad = module->m_Pads; pad != NULL; pad = pad->Next() )
{
if( pad->m_DrillShape == PAD_CIRCLE )
if( pad->m_Drill.x != 0) m_PadsHoleCount++;
else
if ( MIN( pad->m_Drill.x, pad->m_Drill.y ) != 0 ) m_PadsHoleCount++;
}
}
msg = m_PadsCountInfoMsg->GetLabel();
msg << wxT(" ") << m_PadsHoleCount;
m_PadsCountInfoMsg->SetLabel(msg);
m_Check_Mirror = new wxCheckBox( this, -1, _( "mirror y axis" ) );
m_Check_Mirror->SetValue( Mirror );
MiddleBoxSizer->Add( m_Check_Mirror, 0, wxGROW | wxALL, 5 );
msg = m_ThroughViasInfoMsg->GetLabel();
msg << wxT(" ") << m_ThroughViasCount;
m_ThroughViasInfoMsg->SetLabel(msg);
m_Check_Minimal = new wxCheckBox( this, -1, _( "minimal header" ) );
m_Check_Minimal->SetValue( Minimal );
MiddleBoxSizer->Add( m_Check_Minimal, 0, wxGROW | wxALL, 5 );
msg = m_MicroViasInfoMsg->GetLabel();
msg << wxT(" ") << m_MicroViasCount;
m_MicroViasInfoMsg->SetLabel(msg);
/* third column, buttons */
wxButton* Button = new wxButton( this, ID_CREATE_DRILL_FILES,
_( "&Execute" ) );
Button->SetForegroundColour( *wxRED );
RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
Button = new wxButton( this, ID_CLOSE_DRILL, _( "&Close" ) );
Button->SetForegroundColour( *wxBLUE );
RightBoxSizer->Add( Button, 0, wxGROW | wxALL, 5 );
GetSizer()->Fit( this );
GetSizer()->SetSizeHints( this );
Centre();
msg = m_BuriedViasInfoMsg->GetLabel();
msg << wxT(" ") << m_BlindOrBuriedViasCount;
m_BuriedViasInfoMsg->SetLabel(msg);
}
/**************************************/
void WinEDA_DrillFrame::SetParams()
void WinEDA_DrillFrame::SetParams(void)
/**************************************/
{
Unit_Drill_is_Inch = (m_Choice_Unit->GetSelection() == 0) ? FALSE : TRUE;
wxString msg;
long ltmp;
s_Unit_Drill_is_Inch = (m_Choice_Unit->GetSelection() == 0) ? FALSE : TRUE;
Minimal = m_Check_Minimal->IsChecked();
Mirror = m_Check_Mirror->IsChecked();
s_Zeros_Format = m_Choice_Zeros_Format->GetSelection();
DrillOriginIsAuxAxis = m_Choice_Drill_Offset->GetSelection();
g_DesignSettings.m_ViaDrill = m_ViaDrillCtrl->GetValue();
Unit_Drill_is_Inch = m_Choice_Unit->GetSelection();
g_HPGL_Pen_Speed = m_PenSpeed->GetValue();
g_HPGL_Pen_Num = m_PenNum->GetValue();
msg = m_PenSpeed->GetValue();
if ( msg.ToLong(&ltmp) ) g_HPGL_Pen_Speed = ltmp;
msg = m_PenNum->GetValue();
if ( msg.ToLong(&ltmp) ) g_HPGL_Pen_Num = ltmp;
if( m_Choice_Drill_Offset->GetSelection() == 0 )
File_Drill_Offset = wxPoint( 0, 0 );
else
@ -324,7 +225,7 @@ void WinEDA_PcbFrame::InstallDrillFrame( wxCommandEvent& event )
Config->Read( RightPrecisionKey, &s_Precision.m_rhs );
Config->Read( MirrorKey, &Mirror );
Config->Read( MinimalKey, &Minimal );
Config->Read( UnitDrillInchKey, &Unit_Drill_is_Inch );
Config->Read( UnitDrillInchKey, &s_Unit_Drill_is_Inch );
Config->Read( DrillOriginIsAuxAxisKey, &DrillOriginIsAuxAxis );
}
@ -349,24 +250,17 @@ void WinEDA_DrillFrame::UpdateConfig()
Config->Write( RightPrecisionKey, s_Precision.m_rhs );
Config->Write( MirrorKey, Mirror );
Config->Write( MinimalKey, Minimal );
Config->Write( UnitDrillInchKey, Unit_Drill_is_Inch );
Config->Write( UnitDrillInchKey, s_Unit_Drill_is_Inch );
Config->Write( DrillOriginIsAuxAxisKey, DrillOriginIsAuxAxis );
}
}
/****************************************************************/
void WinEDA_DrillFrame::OnQuit( wxCommandEvent& WXUNUSED (event) )
/****************************************************************/
{
UpdateConfig(); /* Save drill options: */
Close( true ); // true is to force the frame to close
}
/*************************************************************/
void WinEDA_DrillFrame::GenDrillFiles( wxCommandEvent& event )
/*************************************************************/
/* Calls the functions to create EXCELLOn drill files and/od drill map files
*/
{
wxString FullFileName, Mask( wxT( "*" ) ), Ext( wxT( ".drl" ) );
int ii;
@ -376,12 +270,12 @@ void WinEDA_DrillFrame::GenDrillFiles( wxCommandEvent& event )
m_Parent->MsgPanel->EraseMsgBox();
/* Calcul des echelles de conversion */
/* Set conversion scale depending on drill file units */
conv_unit = 0.0001; /* unites = INCHES */
if( !Unit_Drill_is_Inch )
if( !s_Unit_Drill_is_Inch )
conv_unit = 0.000254; /* unites = mm */
/* Init nom fichier */
/* Get the file name */
FullFileName = m_Parent->m_CurrentScreen->m_FileName;
ChangeFileNameExt( FullFileName, Ext );
Mask += Ext;
@ -409,17 +303,19 @@ void WinEDA_DrillFrame::GenDrillFiles( wxCommandEvent& event )
/* Init : */
Affiche_1_Parametre( m_Parent, 0, _( "File" ), FullFileName, BLUE );
setlocale (LC_NUMERIC, "C"); // Use the standard notation for float numbers
Init_Drill();
ii = Gen_Liste_Forets( (FORET*) adr_lowmem, TRUE );
ii = Gen_Liste_Forets( (DRILL_TOOL*) adr_lowmem, TRUE );
msg.Printf( wxT( "%d" ), ii );
Affiche_1_Parametre( m_Parent, 30, _( "Tools" ), msg, BROWN );
ii = Gen_Drill_File_EXCELLON( (FORET*) adr_lowmem );
ii = Create_Drill_File_EXCELLON( (DRILL_TOOL*) adr_lowmem );
msg.Printf( wxT( "%d" ), ii );
Affiche_1_Parametre( m_Parent, 45, _( "Drill" ), msg, GREEN );
Write_End_Of_File_Drill();
setlocale (LC_NUMERIC, ""); // Revert to locale float notation
}
switch( m_Choice_Drill_Map->GetSelection() )
@ -466,7 +362,7 @@ void WinEDA_DrillFrame::UpdatePrecisionOptions( wxCommandEvent& event )
/***************************************************************/
int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
int WinEDA_DrillFrame::Create_Drill_File_EXCELLON( DRILL_TOOL* buffer )
/***************************************************************/
/* Create the drill file in EXCELLON format
@ -474,7 +370,7 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
* buffer: Drill tools list
*/
{
FORET* foret;
DRILL_TOOL* foret;
TRACK* pt_piste;
D_PAD* pt_pad;
MODULE* Module;
@ -486,8 +382,8 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
/* Create the pad drill list : */
nb_trous = 0;
/* Examen de la liste des forets */
for( ii = 0, foret = buffer; ii < DrillToolsCount; ii++, foret++ )
/* Read the hole file */
for( ii = 0, foret = buffer; ii < s_DrillToolsCount; ii++, foret++ )
{
sprintf( line, "T%d\n", ii + 1 ); fputs( line, dest );
/* Read the via list */
@ -507,25 +403,21 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
x0 = pt_piste->m_Start.x - File_Drill_Offset.x;
y0 = pt_piste->m_Start.y - File_Drill_Offset.y;
//<ryan's edit>
if( !Mirror )
y0 *= -1;
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
{
Gen_Line_EXCELLON( line, xt, yt );
}
//</ryan's edit>
else
{
/* metric 3:3 */
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
}
// si les flottants sont ecrits avec , au lieu de .
// conversion , -> . necessaire !
to_point( line );
fputs( line, dest );
nb_trous++;
}
@ -535,7 +427,7 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
Module = m_Parent->m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{
/* Examen des pastilles */
/* Read and analyse pads */
pt_pad = (D_PAD*) Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
@ -551,31 +443,26 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
x0 = pt_pad->m_Pos.x - File_Drill_Offset.x;
y0 = pt_pad->m_Pos.y - File_Drill_Offset.y;
//<ryan's edit>
if( !Mirror )
y0 *= -1;
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
Gen_Line_EXCELLON( line, xt, yt );
else
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
to_point( line ); // Internationalization compensation (, to . for floats)
fputs( line, dest );
nb_trous++;
}
} /* ens analyse one module */
} // End analyse module list
/* Fin examen 1 module */
}
/* Fin 1 passe de foret */
/* Read pad list and create Drill infos for oblong holes only: */
Module = m_Parent->m_Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
{
/* Examen des pastilles */
/* Analyse pad list for the module */
pt_pad = (D_PAD*) Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
@ -606,20 +493,17 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
RotatePoint( &x0, &y0, xc, yc, pt_pad->m_Orient );
RotatePoint( &xf, &yf, xc, yc, pt_pad->m_Orient );
//<ryan's edit>
if( !Mirror )
{
y0 *= -1; yf *= -1;
}
// sprintf(line,"T%d\n",ii+1); fputs(line,dest);
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
Gen_Line_EXCELLON( line, xt, yt );
else
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
to_point( line );
/* remove the '\n' from end of line, because we must add the "G85" command to the line: */
for( int kk = 0; line[kk] != 0; kk++ )
if( line[kk] == '\n' || line[kk] =='\r' )
@ -630,30 +514,23 @@ int WinEDA_DrillFrame::Gen_Drill_File_EXCELLON( FORET* buffer )
fputs( "G85", dest ); // add the "G85" command
xt = float (xf) * conv_unit; yt = float (yf) * conv_unit;
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
Gen_Line_EXCELLON( line, xt, yt );
else
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
to_point( line ); fputs( line, dest );
fputs( "G05\n", dest );
nb_trous++;
} /* End Analyse pad list for the module */
} /* End analyse modules for the current tool */
}
/* Fin examen 1 module */
}
/* fin analyse des trous de modules pour le foret en cours*/
}
/* fin analyse des forets */
return nb_trous;
}
/**********************************************************************/
void WinEDA_DrillFrame::Gen_Line_EXCELLON( char* line, float x, float y )
/**********************************************************************/
/*****************************************************/
void Gen_Line_EXCELLON( char* line, float x, float y )
/*****************************************************/
{
wxString xs, ys;
int xpad = s_Precision.m_lhs + s_Precision.m_rhs;
@ -726,7 +603,7 @@ void WinEDA_DrillFrame::Gen_Line_EXCELLON( char* line, float x, float y )
/***************************************************/
FORET* GetOrAddForet( FORET* buffer, int diameter )
DRILL_TOOL* GetOrAddForet( DRILL_TOOL* buffer, int diameter )
/***************************************************/
/* Search the drill tool for the diameter "diameter"
@ -734,20 +611,20 @@ FORET* GetOrAddForet( FORET* buffer, int diameter )
*/
{
int ii;
FORET* foret;
DRILL_TOOL* foret;
if( diameter == 0 )
return NULL;
/* Search for an existing tool: */
for( ii = 0, foret = buffer; ii < DrillToolsCount; ii++, foret++ )
for( ii = 0, foret = buffer; ii < s_DrillToolsCount; ii++, foret++ )
{
if( foret->m_Diameter == diameter ) /* found */
return foret;
}
/* No tool found, we must create a new one */
DrillToolsCount++;
s_DrillToolsCount++;
foret->m_TotalCount = 0;
foret->m_OvalCount = 0;
foret->m_Diameter = diameter;
@ -758,12 +635,12 @@ FORET* GetOrAddForet( FORET* buffer, int diameter )
/* Sort function by drill value */
int Sort_by_Drill_Value( void* foret1, void* foret2 )
{
return ( (FORET*) foret1 )->m_Diameter - ( (FORET*) foret2 )->m_Diameter;
return ( (DRILL_TOOL*) foret1 )->m_Diameter - ( (DRILL_TOOL*) foret2 )->m_Diameter;
}
/*********************************************************************/
int WinEDA_DrillFrame::Gen_Liste_Forets( FORET* buffer, bool print_header )
int WinEDA_DrillFrame::Gen_Liste_Forets( DRILL_TOOL* buffer, bool print_header )
/**********************************************************************/
/* Etablit la liste des forets de percage, dans l'ordre croissant des
@ -771,17 +648,17 @@ int WinEDA_DrillFrame::Gen_Liste_Forets( FORET* buffer, bool print_header )
* Retourne:
* Nombre de Forets
*
* Mise a jour: DrillToolsCount = nombre de forets differents
* Genere une liste de DrillToolsCount structures FORET a partir de buffer
* Mise a jour: s_DrillToolsCount = nombre de forets differents
* Genere une liste de s_DrillToolsCount structures DRILL_TOOL a partir de buffer
*/
{
FORET* foret;
DRILL_TOOL* foret;
D_PAD* pt_pad;
MODULE* Module;
int ii, diam;
char line[1024];
DrillToolsCount = 0; foret = buffer;
s_DrillToolsCount = 0; foret = buffer;
/* Create the via tools */
TRACK* pt_piste = m_Parent->m_Pcb->m_Track;
@ -826,24 +703,21 @@ int WinEDA_DrillFrame::Gen_Liste_Forets( FORET* buffer, bool print_header )
}
/* tri des forets par ordre de diametre croissant */
qsort( buffer, DrillToolsCount, sizeof(FORET),
qsort( buffer, s_DrillToolsCount, sizeof(DRILL_TOOL),
( int( * ) ( const void*, const void* ) )Sort_by_Drill_Value );
/* Generation de la section liste des outils */
if( print_header )
{
for( ii = 0, foret = (FORET*) buffer; ii < DrillToolsCount; ii++, foret++ )
for( ii = 0, foret = (DRILL_TOOL*) buffer; ii < s_DrillToolsCount; ii++, foret++ )
{
//<ryan's edit>
if( Unit_Drill_is_Inch ) /* does it need T01, T02 or is T1,T2 ok?*/
if( s_Unit_Drill_is_Inch ) /* does it need T01, T02 or is T1,T2 ok?*/
sprintf( line, "T%dC%.3f\n", ii + 1,
float (foret->m_Diameter) * conv_unit );
else
sprintf( line, "T%dC%.3f\n", ii + 1,
float (foret->m_Diameter) * conv_unit * 10.0 );
//</ryan's edit>
to_point( line );
fputs( line, dest );
}
@ -852,13 +726,13 @@ int WinEDA_DrillFrame::Gen_Liste_Forets( FORET* buffer, bool print_header )
fputs( "M47\n", dest ); /* Operator message */
fputs( "G05\n", dest ); /* Drill mode */
/* Units : */
if( Unit_Drill_is_Inch && !Minimal )
if( s_Unit_Drill_is_Inch && !Minimal )
fputs( "M72\n", dest ); /* M72 = inch mode */
else if( !Minimal )
fputs( "M71\n", dest ); /* M71 = metric mode */
}
return DrillToolsCount;
return s_DrillToolsCount;
}
@ -885,7 +759,7 @@ void WinEDA_DrillFrame::Init_Drill()
fputs( "R,T\nVER,1\nFMAT,2\n", dest );
}
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
fputs( "INCH", dest ); // Si unites en INCHES
else
fputs( "METRIC", dest ); // Si unites en mm
@ -929,7 +803,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
{
int ii, x, y;
int plotX, plotY, TextWidth;
FORET* foret;
DRILL_TOOL* foret;
int intervalle = 0, CharSize = 0;
EDA_BaseStruct* PtStruct;
int old_g_PlotOrient = g_PlotOrient;
@ -978,6 +852,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
if( FullFileName.IsEmpty() )
return;
setlocale (LC_NUMERIC, "C"); // Use the standard notation for float numbers
g_PlotOrient = 0;
/* calcul des dimensions et centre du PCB */
m_Parent->m_Pcb->ComputeBoundaryBox();
@ -1034,7 +909,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
Affiche_1_Parametre( m_Parent, 0, _( "File" ), FullFileName, BLUE );
/* Calcul de la liste des diametres de percage (liste des forets) */
ii = Gen_Liste_Forets( (FORET*) adr_lowmem, FALSE );
ii = Gen_Liste_Forets( (DRILL_TOOL*) adr_lowmem, FALSE );
msg.Printf( wxT( "%d" ), ii );
Affiche_1_Parametre( m_Parent, 48, _( "Tools" ), msg, BROWN );
@ -1103,7 +978,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
fputs( line, dest );
}
ii = Plot_Drill_PcbMap( (FORET*) adr_lowmem, format );
ii = Plot_Drill_PcbMap( (DRILL_TOOL*) adr_lowmem, format );
msg.Printf( wxT( "%d" ), ii );
Affiche_1_Parametre( m_Parent, 64, _( "Drill" ), msg, GREEN );
@ -1121,7 +996,6 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
/* generation des dim: commande SI x,y; x et y = dim en cm */
char csize[256];
sprintf( csize, "%2.3f", (float) CharSize * CharScale * 0.000254 );
to_point( csize );
sprintf( line, "SI %s, %s;\n", csize, csize );
break;
}
@ -1182,7 +1056,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
}
for( ii = 0, foret = (FORET*) adr_lowmem; ii < DrillToolsCount; ii++, foret++ )
for( ii = 0, foret = (DRILL_TOOL*) adr_lowmem; ii < s_DrillToolsCount; ii++, foret++ )
{
int plot_diam;
if( foret->m_TotalCount == 0 )
@ -1212,7 +1086,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
// List the diameter of each drill in the selected Drill Unit,
// and then its diameter in the other Drill Unit.
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
sprintf( line, "PU %d, %d; LB%2.3f\" / %2.2fmm ",
x + (int) (intervalle * CharScale * fTextScale),
y - (int) (CharSize / 2 * CharScale * fTextScale),
@ -1249,7 +1123,7 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
// List the diameter of each drill in the selected Drill Unit,
// and then its diameter in the other Drill Unit.
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
sprintf( line, "%2.3f\" / %2.2fmm ",
float (foret->m_Diameter) * 0.0001,
float (foret->m_Diameter) * 0.00254 );
@ -1298,12 +1172,14 @@ void WinEDA_DrillFrame::GenDrillMap( int format )
break;
}
setlocale (LC_NUMERIC, ""); // Revert to local notation for float numbers
g_PlotOrient = old_g_PlotOrient;
}
/********************************************************************/
int WinEDA_DrillFrame::Plot_Drill_PcbMap( FORET* buffer, int format )
int WinEDA_DrillFrame::Plot_Drill_PcbMap( DRILL_TOOL* buffer, int format )
/*********************************************************************/
/** Trace la liste des trous a percer en format HPGL ou POSTSCRIPT
@ -1312,7 +1188,7 @@ int WinEDA_DrillFrame::Plot_Drill_PcbMap( FORET* buffer, int format )
* @param format = ouput format (hpgl / ps)
*/
{
FORET* foret;
DRILL_TOOL* foret;
TRACK* pt_piste;
D_PAD* pt_pad;
MODULE* Module;
@ -1323,7 +1199,7 @@ int WinEDA_DrillFrame::Plot_Drill_PcbMap( FORET* buffer, int format )
nb_trous = 0;
/* create the drill list */
if( DrillToolsCount > 13 )
if( s_DrillToolsCount > 13 )
{
DisplayInfo( this,
_(
@ -1332,7 +1208,7 @@ int WinEDA_DrillFrame::Plot_Drill_PcbMap( FORET* buffer, int format )
}
// Plot the drill map:
for( shape_id = 0, foret = (FORET*) buffer; shape_id < DrillToolsCount; shape_id++, foret++ )
for( shape_id = 0, foret = (DRILL_TOOL*) buffer; shape_id < s_DrillToolsCount; shape_id++, foret++ )
{
/* create the via drill map */
{
@ -1397,7 +1273,7 @@ void PlotDrillSymbol( const wxPoint& position, int diametre, int num_forme, int
/* Trace un motif de numero de forme num_forme, aux coord x0, y0.
* x0, y0 = coordonnees tables
* diametre = diametre (coord table) du trou
* num_forme = index ( permet de gererer des formes caract )
* num_forme = index ( permet de generer des formes caract )
*/
{
int rayon = diametre / 2;
@ -1594,7 +1470,7 @@ void WinEDA_DrillFrame::GenDrillReport()
wxString FileName, Mask( wxT( "*" ) ), Ext( wxT( ".rpt" ) );
int ii, TotalHoleCount;
char line[1024];
FORET* foret;
DRILL_TOOL* foret;
wxString msg;
FileName = m_Parent->m_CurrentScreen->m_FileName;
@ -1625,7 +1501,7 @@ void WinEDA_DrillFrame::GenDrillReport()
Affiche_1_Parametre( m_Parent, 0, _( "File" ), FileName, BLUE );
/* Determine the list of the different drill diameters. */
ii = Gen_Liste_Forets( (FORET*) adr_lowmem, FALSE );
ii = Gen_Liste_Forets( (DRILL_TOOL*) adr_lowmem, FALSE );
msg.Printf( wxT( "%d" ), ii );
Affiche_1_Parametre( m_Parent, 30, _( "Tools" ), msg, BROWN );
@ -1634,19 +1510,19 @@ void WinEDA_DrillFrame::GenDrillReport()
fprintf( dest, "Created on %s\n", DateAndTime( line ) );
// List which Drill Unit option had been selected for the associated drill file.
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
fputs( "Selected Drill Unit: Imperial (\")\n\n", dest );
else
fputs( "Selected Drill Unit: Metric (mm)\n\n", dest );
TotalHoleCount = 0;
for( ii = 0, foret = (FORET*) adr_lowmem; ii < DrillToolsCount; ii++, foret++ )
for( ii = 0, foret = (DRILL_TOOL*) adr_lowmem; ii < s_DrillToolsCount; ii++, foret++ )
{
// List the tool number assigned to each drill,
// then its diameter in the selected Drill Unit,
// and then its diameter in the other Drill Unit.
if( Unit_Drill_is_Inch )
if( s_Unit_Drill_is_Inch )
sprintf( line, "T%d %2.3f\" %2.2fmm ",
ii + 1,
float (foret->m_Diameter) * 0.0001,
@ -1661,7 +1537,7 @@ void WinEDA_DrillFrame::GenDrillReport()
// Now list how many holes and ovals are associated with each drill.
if( ( foret->m_TotalCount == 1 ) && ( foret->m_OvalCount == 0 ) )
sprintf( line, "(1 hole)\n" );
else if( foret->m_TotalCount == 1 ) // && ( foret->m_OvalCount == 1 )
else if( foret->m_TotalCount == 1 )
sprintf( line, "(1 hole) (with 1 oblong)\n" );
else if( foret->m_OvalCount == 0 )
sprintf( line, "(%d holes)\n",

3
pcbnew/makefile.include
View File

@ -32,6 +32,7 @@ OBJECTS= $(TARGET).o classpcb.o\
setpage.o \
tool_pcb.o \
pcbframe.o \
class_drawsegment.o \
class_track.o \
class_mire.o\
class_cotation.o\
@ -265,7 +266,7 @@ readgerb.o: readgerb.cpp pcbplot.h $(COMMON)
plot_rtn.o: plot_rtn.cpp pcbplot.h $(COMMON)
gendrill.o: gendrill.cpp pcbplot.h $(COMMON)
gendrill.o: gendrill.cpp dialog_gendrill.cpp dialog_gendrill.h pcbplot.h $(COMMON)
librairi.o: librairi.cpp $(COMMON)

2
pcbnew/onleftclick.cpp
View File

@ -89,7 +89,7 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
if( m_ID_current_state == 0 )
{
DisplayError( this,
wxT( "WinEDA_PcbFrame::OnLeftClick() err: m_Flags != 0" ) );
wxT( "WinEDA_PcbFrame::OnLeftClick() err: DrawType %d m_Flags != 0" ), DrawStruct->Type() );
exit = true;
}
break;

4
pcbnew/onrightclick.cpp
View File

@ -329,6 +329,7 @@ bool WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu )
wxT( "WinEDA_PcbFrame::OnRightClick() Error: illegal DrawType %d" ),
item->Type() );
DisplayError( this, msg );
SetCurItem(NULL);
break;
default:
@ -336,6 +337,9 @@ bool WinEDA_PcbFrame::OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu )
wxT( "WinEDA_PcbFrame::OnRightClick() Error: unknown DrawType %d" ),
item->Type() );
DisplayError( this, msg );
// Attempt to clear error (but should no occurs )
if ( item->Type() >= MAX_STRUCT_TYPE_ID )
SetCurItem(NULL);
break;
}