1593 lines
54 KiB
C++
1593 lines
54 KiB
C++
/***************************************************************/
|
||
/* Functionbs to create EXCELLON drill files and report files */
|
||
/***************************************************************/
|
||
|
||
#include "fctsys.h"
|
||
|
||
using namespace std;
|
||
|
||
#include <vector>
|
||
|
||
#include "common.h"
|
||
#include "plot_common.h"
|
||
#include "trigo.h"
|
||
#include "pcbnew.h"
|
||
#include "pcbplot.h"
|
||
#include "macros.h"
|
||
|
||
/*
|
||
* 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
|
||
*
|
||
* 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
|
||
*/
|
||
|
||
class DRILL_TOOL
|
||
{
|
||
public:
|
||
int m_Diameter;
|
||
int m_TotalCount;
|
||
int m_OvalCount;
|
||
public:
|
||
DRILL_TOOL( int diametre )
|
||
{
|
||
m_TotalCount = 0;
|
||
m_OvalCount = 0;
|
||
m_Diameter = diametre;
|
||
}
|
||
};
|
||
|
||
/* drill precision format */
|
||
class DrillPrecision
|
||
{
|
||
public:
|
||
int m_lhs;
|
||
int m_rhs;
|
||
|
||
public:
|
||
DrillPrecision( int l, int r ) { m_lhs = l; m_rhs = r; }
|
||
};
|
||
|
||
/* zeros format */
|
||
enum zeros_fmt {
|
||
DECIMAL_FORMAT,
|
||
SUPPRESS_LEADING,
|
||
SUPPRESS_TRAILING,
|
||
KEEP_ZEROS
|
||
};
|
||
|
||
/* 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,
|
||
const wxSize& size,
|
||
int orient,
|
||
int format );
|
||
|
||
/* Local Variables : */
|
||
static float conv_unit; /* coeff de conversion des unites drill / pcb */
|
||
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 );
|
||
|
||
static bool DrillOriginIsAuxAxis; // Axis selection (main / auxiliary) for Drill Origin coordinates
|
||
static wxPoint File_Drill_Offset; /* Offset des coord de percage pour le fichier g<>n<EFBFBD>r<EFBFBD> */
|
||
static bool Minimal = false;
|
||
static bool Mirror = true;
|
||
|
||
static std::vector<DRILL_TOOL> s_ToolListBuffer;
|
||
|
||
// Keywords for read and write config
|
||
#define ZerosFormatKey wxT( "DrillZerosFormat" )
|
||
#define LeftPrecisionKey wxT( "DrillLeftPrecisionOpt" )
|
||
#define RightPrecisionKey wxT( "DrillRightPrecisionOpt" )
|
||
#define MirrorKey wxT( "DrillMirrorYOpt" )
|
||
#define MinimalKey wxT( "DrillMinHeader" )
|
||
#define UnitDrillInchKey wxT( "DrillUnit" )
|
||
#define DrillOriginIsAuxAxisKey wxT( "DrillAuxAxis" )
|
||
|
||
#include "dialog_gendrill.cpp" // Dialog box for drill file generation
|
||
|
||
/* Compare function used for sorting tools */
|
||
static bool CmpDrillDiameterTool( const DRILL_TOOL& a, const DRILL_TOOL& b )
|
||
{
|
||
return a.m_Diameter < b.m_Diameter;
|
||
}
|
||
|
||
|
||
/**********************************************/
|
||
void WinEDA_DrillFrame::InitDisplayParams( void )
|
||
/**********************************************/
|
||
|
||
/* some param values initialisation before display dialog window
|
||
*/
|
||
{
|
||
wxString msg;
|
||
|
||
if( s_Zeros_Format==DECIMAL_FORMAT )
|
||
m_Choice_Precision->Enable( false );
|
||
if( DrillOriginIsAuxAxis )
|
||
m_Choice_Drill_Offset->SetSelection( 1 );
|
||
|
||
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 );
|
||
|
||
msg = ReturnStringFromValue( g_UnitMetric,
|
||
g_DesignSettings.m_ViaDrill,
|
||
m_Parent->m_InternalUnits );
|
||
msg += ReturnUnitSymbol( g_UnitMetric );
|
||
m_ViaDrillValue->SetLabel( msg );
|
||
|
||
msg = ReturnStringFromValue( g_UnitMetric,
|
||
g_DesignSettings.m_MicroViaDrill,
|
||
m_Parent->m_InternalUnits );
|
||
msg += ReturnUnitSymbol( g_UnitMetric );
|
||
m_MicroViaDrillValue->SetLabel( msg );
|
||
|
||
msg.Empty();
|
||
msg << g_HPGL_Pen_Num;
|
||
m_PenNum->SetValue( msg );
|
||
|
||
msg.Empty();
|
||
msg << g_HPGL_Pen_Speed;
|
||
m_PenSpeed->SetValue( msg );
|
||
|
||
// See if we have some buried vias or/and microvias, and display microvias 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 );
|
||
|
||
/* 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 );
|
||
|
||
msg = m_ThroughViasInfoMsg->GetLabel();
|
||
msg << wxT( " " ) << m_ThroughViasCount;
|
||
m_ThroughViasInfoMsg->SetLabel( msg );
|
||
|
||
msg = m_MicroViasInfoMsg->GetLabel();
|
||
msg << wxT( " " ) << m_MicroViasCount;
|
||
m_MicroViasInfoMsg->SetLabel( msg );
|
||
|
||
msg = m_BuriedViasInfoMsg->GetLabel();
|
||
msg << wxT( " " ) << m_BlindOrBuriedViasCount;
|
||
m_BuriedViasInfoMsg->SetLabel( msg );
|
||
}
|
||
|
||
|
||
/**************************************/
|
||
void WinEDA_DrillFrame::SetParams( void )
|
||
/**************************************/
|
||
{
|
||
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();
|
||
|
||
msg = m_PenSpeed->GetValue();
|
||
if( msg.ToLong( <mp ) )
|
||
g_HPGL_Pen_Speed = ltmp;
|
||
msg = m_PenNum->GetValue();
|
||
|
||
if( msg.ToLong( <mp ) )
|
||
g_HPGL_Pen_Num = ltmp;
|
||
if( m_Choice_Drill_Offset->GetSelection() == 0 )
|
||
File_Drill_Offset = wxPoint( 0, 0 );
|
||
else
|
||
File_Drill_Offset = m_Parent->m_Auxiliary_Axis_Position;
|
||
|
||
/* get precision from radio box strings (this just makes it easier to
|
||
* change options later)*/
|
||
wxString ps = m_Choice_Precision->GetStringSelection();
|
||
wxString l = ps.substr( 0, 1 );
|
||
wxString r = ps.substr( 2, 1 );
|
||
|
||
|
||
// a long is not an int on all machines
|
||
long lhs;
|
||
long rhs;
|
||
|
||
l.ToLong( &lhs );
|
||
r.ToLong( &rhs );
|
||
|
||
s_Precision.m_lhs = lhs;
|
||
s_Precision.m_rhs = rhs;
|
||
}
|
||
|
||
|
||
/*****************************************************************/
|
||
void WinEDA_PcbFrame::InstallDrillFrame( wxCommandEvent& event )
|
||
/*****************************************************************/
|
||
|
||
/* This function displays and deletes the dialog frame for drill tools
|
||
*/
|
||
{
|
||
wxConfig* Config = m_Parent->m_EDA_Config;
|
||
|
||
if( Config )
|
||
{
|
||
Config->Read( ZerosFormatKey, &s_Zeros_Format );
|
||
Config->Read( LeftPrecisionKey, &s_Precision.m_lhs );
|
||
Config->Read( RightPrecisionKey, &s_Precision.m_rhs );
|
||
Config->Read( MirrorKey, &Mirror );
|
||
Config->Read( MinimalKey, &Minimal );
|
||
Config->Read( UnitDrillInchKey, &s_Unit_Drill_is_Inch );
|
||
Config->Read( DrillOriginIsAuxAxisKey, &DrillOriginIsAuxAxis );
|
||
}
|
||
|
||
WinEDA_DrillFrame* frame = new WinEDA_DrillFrame( this );
|
||
|
||
frame->ShowModal(); frame->Destroy();
|
||
}
|
||
|
||
|
||
/******************************************/
|
||
void WinEDA_DrillFrame::UpdateConfig()
|
||
/******************************************/
|
||
/* Save drill options: */
|
||
{
|
||
SetParams();
|
||
|
||
wxConfig* Config = m_Parent->m_Parent->m_EDA_Config;
|
||
if( Config )
|
||
{
|
||
Config->Write( ZerosFormatKey, s_Zeros_Format );
|
||
Config->Write( LeftPrecisionKey, s_Precision.m_lhs );
|
||
Config->Write( RightPrecisionKey, s_Precision.m_rhs );
|
||
Config->Write( MirrorKey, Mirror );
|
||
Config->Write( MinimalKey, Minimal );
|
||
Config->Write( UnitDrillInchKey, s_Unit_Drill_is_Inch );
|
||
Config->Write( DrillOriginIsAuxAxisKey, DrillOriginIsAuxAxis );
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************************************/
|
||
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;
|
||
wxString msg;
|
||
|
||
UpdateConfig(); /* set params and Save drill options */
|
||
|
||
m_Parent->MsgPanel->EraseMsgBox();
|
||
|
||
/* Set conversion scale depending on drill file units */
|
||
conv_unit = 0.0001; /* unites = INCHES */
|
||
if( !s_Unit_Drill_is_Inch )
|
||
conv_unit = 0.000254; /* unites = mm */
|
||
|
||
/* Get the file name */
|
||
FullFileName = m_Parent->m_CurrentScreen->m_FileName;
|
||
ChangeFileNameExt( FullFileName, Ext );
|
||
Mask += Ext;
|
||
|
||
FullFileName = EDA_FileSelector( _( "Drill file" ),
|
||
wxEmptyString, /* Chemin par defaut */
|
||
FullFileName, /* nom fichier par defaut */
|
||
Ext, /* extension par defaut */
|
||
Mask, /* Masque d'affichage */
|
||
this,
|
||
wxFD_SAVE,
|
||
TRUE
|
||
);
|
||
if( FullFileName != wxEmptyString )
|
||
{
|
||
dest = wxFopen( FullFileName, wxT( "w" ) );
|
||
if( dest == 0 )
|
||
{
|
||
msg = _( "Unable to create file " ) + FullFileName;
|
||
DisplayError( this, msg );
|
||
EndModal( 0 );
|
||
return;
|
||
}
|
||
|
||
/* 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_Tools( s_ToolListBuffer, TRUE );
|
||
|
||
msg.Printf( wxT( "%d" ), ii );
|
||
Affiche_1_Parametre( m_Parent, 30, _( "Tools" ), msg, BROWN );
|
||
|
||
ii = Create_Drill_File_EXCELLON( s_ToolListBuffer );
|
||
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() )
|
||
{
|
||
case 0:
|
||
break;
|
||
|
||
case 1:
|
||
GenDrillMap( s_ToolListBuffer, PLOT_FORMAT_HPGL );
|
||
break;
|
||
|
||
case 2:
|
||
GenDrillMap( s_ToolListBuffer, PLOT_FORMAT_POST );
|
||
break;
|
||
}
|
||
|
||
if( m_Choice_Drill_Report->GetSelection() > 0 )
|
||
GenDrillReport( s_ToolListBuffer );
|
||
|
||
EndModal( 0 );
|
||
}
|
||
|
||
|
||
/********************************************************************/
|
||
void WinEDA_DrillFrame::UpdatePrecisionOptions( wxCommandEvent& event )
|
||
/********************************************************************/
|
||
{
|
||
if( m_Choice_Unit->GetSelection()==1 )
|
||
{ /* inch options */
|
||
m_Choice_Precision->SetString( 0, _( "2:3" ) );
|
||
m_Choice_Precision->SetString( 1, _( "2:4" ) );
|
||
}
|
||
else
|
||
{
|
||
/* metric options */
|
||
m_Choice_Precision->SetString( 0, _( "3:2" ) );
|
||
m_Choice_Precision->SetString( 1, _( "3:3" ) );
|
||
}
|
||
if( m_Choice_Zeros_Format->GetSelection()==DECIMAL_FORMAT )
|
||
m_Choice_Precision->Enable( false );
|
||
else
|
||
m_Choice_Precision->Enable( true );
|
||
}
|
||
|
||
|
||
/**********************************************************************************/
|
||
int WinEDA_DrillFrame::Create_Drill_File_EXCELLON( std::vector<DRILL_TOOL>& buffer )
|
||
/**********************************************************************************/
|
||
|
||
/* Create the drill file in EXCELLON format
|
||
* Return hole count
|
||
* buffer: Drill tools list
|
||
*/
|
||
{
|
||
TRACK* pt_piste;
|
||
D_PAD* pt_pad;
|
||
MODULE* Module;
|
||
int diam, holes_count;
|
||
int x0, y0, xf, yf, xc, yc;
|
||
float xt, yt;
|
||
char line[1024];
|
||
|
||
/* Create the pad drill list : */
|
||
holes_count = 0;
|
||
|
||
/* Read the hole file */
|
||
for( unsigned ii = 0; ii < buffer.size(); ii++ )
|
||
{
|
||
sprintf( line, "T%d\n", ii + 1 ); fputs( line, dest );
|
||
/* Read the via list */
|
||
{
|
||
pt_piste = m_Parent->m_Pcb->m_Track;
|
||
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
|
||
{
|
||
if( pt_piste->Type() != TYPEVIA )
|
||
continue;
|
||
int via_drill = pt_piste->GetDrillValue();
|
||
if( via_drill == 0 )
|
||
continue;
|
||
|
||
if( buffer[ii].m_Diameter != via_drill )
|
||
continue;
|
||
|
||
x0 = pt_piste->m_Start.x - File_Drill_Offset.x;
|
||
y0 = pt_piste->m_Start.y - File_Drill_Offset.y;
|
||
|
||
if( !Mirror )
|
||
y0 *= -1;
|
||
|
||
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
|
||
if( s_Unit_Drill_is_Inch )
|
||
{
|
||
Gen_Line_EXCELLON( line, xt, yt );
|
||
}
|
||
else
|
||
{
|
||
/* metric 3:3 */
|
||
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
|
||
}
|
||
|
||
fputs( line, dest );
|
||
holes_count++;
|
||
}
|
||
}
|
||
|
||
/* Read pad list and create Drill infos for round holes only: */
|
||
Module = m_Parent->m_Pcb->m_Modules;
|
||
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
|
||
{
|
||
/* Read and analyse pads */
|
||
pt_pad = (D_PAD*) Module->m_Pads;
|
||
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
|
||
{
|
||
if( pt_pad->m_DrillShape != PAD_CIRCLE )
|
||
continue;
|
||
diam = pt_pad->m_Drill.x;
|
||
if( diam == 0 )
|
||
continue;
|
||
if( diam != buffer[ii].m_Diameter )
|
||
continue;
|
||
|
||
/* Compute the hole coordinates: */
|
||
x0 = pt_pad->m_Pos.x - File_Drill_Offset.x;
|
||
y0 = pt_pad->m_Pos.y - File_Drill_Offset.y;
|
||
|
||
if( !Mirror )
|
||
y0 *= -1;
|
||
|
||
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
|
||
if( s_Unit_Drill_is_Inch )
|
||
Gen_Line_EXCELLON( line, xt, yt );
|
||
else
|
||
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
|
||
|
||
fputs( line, dest );
|
||
holes_count++;
|
||
}
|
||
|
||
/* ens analyse one module */
|
||
}
|
||
|
||
// End analyse module list
|
||
|
||
|
||
/* 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 )
|
||
{
|
||
/* Analyse pad list for the module */
|
||
pt_pad = (D_PAD*) Module->m_Pads;
|
||
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
|
||
{
|
||
if( pt_pad->m_DrillShape != PAD_OVAL )
|
||
continue;
|
||
|
||
diam = MIN( pt_pad->m_Drill.x, pt_pad->m_Drill.y );
|
||
if( diam == 0 )
|
||
continue;
|
||
if( diam != buffer[ii].m_Diameter )
|
||
continue;
|
||
|
||
/* Compute the hole coordinates: */
|
||
xc = x0 = xf = pt_pad->m_Pos.x - File_Drill_Offset.x;
|
||
yc = y0 = yf = pt_pad->m_Pos.y - File_Drill_Offset.y;
|
||
|
||
/* Compute the start and end coordinates for the shape */
|
||
if( pt_pad->m_Drill.x < pt_pad->m_Drill.y )
|
||
{
|
||
int delta = (pt_pad->m_Drill.y - pt_pad->m_Drill.x) / 2;
|
||
y0 -= delta; yf += delta;
|
||
}
|
||
else
|
||
{
|
||
int delta = (pt_pad->m_Drill.x - pt_pad->m_Drill.y) / 2;
|
||
x0 -= delta; xf += delta;
|
||
}
|
||
RotatePoint( &x0, &y0, xc, yc, pt_pad->m_Orient );
|
||
RotatePoint( &xf, &yf, xc, yc, pt_pad->m_Orient );
|
||
|
||
|
||
if( !Mirror )
|
||
{
|
||
y0 *= -1; yf *= -1;
|
||
}
|
||
|
||
xt = float (x0) * conv_unit; yt = float (y0) * conv_unit;
|
||
if( s_Unit_Drill_is_Inch )
|
||
Gen_Line_EXCELLON( line, xt, yt );
|
||
else
|
||
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
|
||
/* 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' )
|
||
line[kk] = 0;
|
||
|
||
fputs( line, dest );
|
||
|
||
fputs( "G85", dest ); // add the "G85" command
|
||
|
||
xt = float (xf) * conv_unit; yt = float (yf) * conv_unit;
|
||
if( s_Unit_Drill_is_Inch )
|
||
Gen_Line_EXCELLON( line, xt, yt );
|
||
else
|
||
Gen_Line_EXCELLON( line, xt * 10, yt * 10 );
|
||
fputs( "G05\n", dest );
|
||
holes_count++;
|
||
}
|
||
|
||
/* End Analyse pad list for the module */
|
||
}
|
||
|
||
/* End analyse modules for the current tool */
|
||
}
|
||
|
||
return holes_count;
|
||
}
|
||
|
||
|
||
/*****************************************************/
|
||
void Gen_Line_EXCELLON( char* line, float x, float y )
|
||
/*****************************************************/
|
||
{
|
||
wxString xs, ys;
|
||
int xpad = s_Precision.m_lhs + s_Precision.m_rhs;
|
||
int ypad = xpad;
|
||
|
||
/* I need to come up with an algorithm that handles any lhs:rhs format.*/
|
||
/* one idea is to take more inputs for xpad/ypad when metric is used. */
|
||
|
||
switch( s_Zeros_Format )
|
||
{
|
||
default:
|
||
case DECIMAL_FORMAT:
|
||
sprintf( line, "X%.3fY%.3f\n", x, y );
|
||
break;
|
||
|
||
case SUPPRESS_LEADING: /* that should work now */
|
||
for( int i = 0; i< s_Precision.m_rhs; i++ )
|
||
{
|
||
x *= 10; y *= 10;
|
||
}
|
||
|
||
sprintf( line, "X%dY%d\n", (int) round( x ), (int) round( y ) );
|
||
break;
|
||
|
||
case SUPPRESS_TRAILING:
|
||
{
|
||
for( int i = 0; i< s_Precision.m_rhs; i++ )
|
||
{
|
||
x *= 10; y *= 10;
|
||
}
|
||
|
||
if( x<0 )
|
||
xpad++;
|
||
if( y<0 )
|
||
ypad++;
|
||
|
||
xs.Printf( wxT( "%0*d" ), xpad, (int) round( x ) );
|
||
ys.Printf( wxT( "%0*d" ), ypad, (int) round( y ) );
|
||
|
||
size_t j = xs.Len() - 1;
|
||
while( xs[j] == '0' && j )
|
||
xs.Truncate( j-- );
|
||
|
||
j = ys.Len() - 1;
|
||
while( ys[j] == '0' && j )
|
||
ys.Truncate( j-- );
|
||
|
||
sprintf( line, "X%sY%s\n", CONV_TO_UTF8( xs ), CONV_TO_UTF8( ys ) );
|
||
break;
|
||
}
|
||
|
||
case KEEP_ZEROS:
|
||
for( int i = 0; i< s_Precision.m_rhs; i++ )
|
||
{
|
||
x *= 10; y *= 10;
|
||
}
|
||
|
||
if( x<0 )
|
||
xpad++;
|
||
if( y<0 )
|
||
ypad++;
|
||
xs.Printf( wxT( "%0*d" ), xpad, (int) round( x ) );
|
||
ys.Printf( wxT( "%0*d" ), ypad, (int) round( y ) );
|
||
sprintf( line, "X%sY%s\n", CONV_TO_UTF8( xs ), CONV_TO_UTF8( ys ) );
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/*************************************************************************/
|
||
int GetOrAddForet( std::vector<DRILL_TOOL>& buffer, int diameter )
|
||
/*************************************************************************/
|
||
|
||
/* Search the drill tool for the diameter "diameter"
|
||
* Create a new one if not found
|
||
* return the index in buffer
|
||
*/
|
||
{
|
||
unsigned ii;
|
||
|
||
if( diameter == 0 )
|
||
return -1;
|
||
|
||
/* Search for an existing tool: */
|
||
for( ii = 0; ii < buffer.size(); ii++ )
|
||
{
|
||
if( buffer[ii].m_Diameter == diameter ) /* found */
|
||
return ii;
|
||
}
|
||
|
||
/* No tool found, we must create a new one */
|
||
DRILL_TOOL new_tool( diameter );
|
||
buffer.push_back( new_tool );
|
||
return buffer.size() - 1;
|
||
}
|
||
|
||
|
||
/*********************************************************************************************/
|
||
int WinEDA_DrillFrame::Gen_Liste_Tools( std::vector<DRILL_TOOL>& buffer, bool print_header )
|
||
/*********************************************************************************************/
|
||
|
||
/* Etablit la liste des drill_tools de percage, dans l'ordre croissant des
|
||
* diametres
|
||
* Retourne:
|
||
* Nombre de Forets
|
||
*
|
||
* Fills the list of tools buffer
|
||
*/
|
||
{
|
||
D_PAD* pt_pad;
|
||
MODULE* Module;
|
||
unsigned ii;
|
||
int diam;
|
||
char line[1024];
|
||
|
||
buffer.clear();
|
||
|
||
/* Creates the via tools list*/
|
||
TRACK* pt_piste = m_Parent->m_Pcb->m_Track;
|
||
|
||
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
|
||
{
|
||
if( pt_piste->Type() != TYPEVIA )
|
||
continue;
|
||
int via_drill = pt_piste->GetDrillValue();
|
||
if( via_drill == 0 )
|
||
continue;
|
||
|
||
ii = GetOrAddForet( buffer, via_drill );
|
||
if ( ii >= 0 )
|
||
buffer[ii].m_TotalCount++;
|
||
}
|
||
|
||
/* Create the pad tools : */
|
||
Module = m_Parent->m_Pcb->m_Modules;
|
||
for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
|
||
{
|
||
/* See the pad list for hole sizes */
|
||
pt_pad = (D_PAD*) Module->m_Pads;
|
||
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
|
||
{
|
||
if( pt_pad->m_DrillShape == PAD_CIRCLE )
|
||
diam = pt_pad->m_Drill.x;
|
||
else
|
||
diam = MIN( pt_pad->m_Drill.x, pt_pad->m_Drill.y );
|
||
|
||
if( diam == 0 )
|
||
continue;
|
||
|
||
ii = GetOrAddForet( buffer, diam );
|
||
if ( ii >= 0 )
|
||
{
|
||
buffer[ii].m_TotalCount++;
|
||
if( pt_pad->m_DrillShape == PAD_OVAL )
|
||
buffer[ii].m_OvalCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Sort drill_tools by increasing size */
|
||
sort( buffer.begin(), buffer.end(), CmpDrillDiameterTool );
|
||
|
||
/* Write the tool list in excellon file */
|
||
if( print_header )
|
||
{
|
||
for( ii = 0; ii < buffer.size(); ii++ )
|
||
{
|
||
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 (buffer[ii].m_Diameter) * conv_unit );
|
||
else
|
||
sprintf( line, "T%dC%.3f\n", ii + 1,
|
||
float (buffer[ii].m_Diameter) * conv_unit * 10.0 );
|
||
|
||
fputs( line, dest );
|
||
}
|
||
|
||
fputs( "%\n", dest );
|
||
if( !Minimal )
|
||
fputs( "M47\n", dest ); /* Operator message */
|
||
fputs( "G05\n", dest ); /* Drill mode */
|
||
/* Units : */
|
||
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 buffer.size();
|
||
}
|
||
|
||
|
||
/***************************************/
|
||
void WinEDA_DrillFrame::Init_Drill()
|
||
/***************************************/
|
||
/* Print the DRILL file header */
|
||
{
|
||
char Line[256];
|
||
|
||
fputs( "M48\n", dest );
|
||
|
||
if( !Minimal )
|
||
{
|
||
DateAndTime( Line );
|
||
wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion();
|
||
fprintf( dest, ";DRILL file {%s} date %s\n", CONV_TO_UTF8( Title ), Line );
|
||
fputs( ";FORMAT={", dest );
|
||
fprintf( dest, "%s / absolute / ",
|
||
CONV_TO_UTF8( m_Choice_Precision->GetStringSelection() ) );
|
||
fprintf( dest, "%s / ", CONV_TO_UTF8( m_Choice_Unit->GetStringSelection() ) );
|
||
fprintf( dest, "%s}\n", CONV_TO_UTF8( m_Choice_Zeros_Format->GetStringSelection() ) );
|
||
|
||
fputs( "R,T\nVER,1\nFMAT,2\n", dest );
|
||
}
|
||
|
||
if( s_Unit_Drill_is_Inch )
|
||
fputs( "INCH", dest ); // Si unites en INCHES
|
||
else
|
||
fputs( "METRIC", dest ); // Si unites en mm
|
||
|
||
switch( s_Zeros_Format )
|
||
{
|
||
case SUPPRESS_LEADING:
|
||
case DECIMAL_FORMAT:
|
||
fputs( ",TZ\n", dest );
|
||
break;
|
||
|
||
case SUPPRESS_TRAILING:
|
||
fputs( ",LZ\n", dest );
|
||
break;
|
||
|
||
case KEEP_ZEROS:
|
||
fputs( ",TZ\n", dest ); // TZ is acceptable when all zeros are kept
|
||
break;
|
||
}
|
||
|
||
if( !Minimal )
|
||
fputs( "TCST,OFF\nICI,OFF\nATC,ON\n", dest );
|
||
}
|
||
|
||
|
||
/*****************************/
|
||
void Write_End_Of_File_Drill()
|
||
/*****************************/
|
||
{
|
||
//add if minimal here
|
||
fputs( "T0\nM30\n", dest ); fclose( dest );
|
||
}
|
||
|
||
|
||
/**********************************************************************************/
|
||
void WinEDA_DrillFrame::GenDrillMap( std::vector<DRILL_TOOL>& buffer, int format )
|
||
/**********************************************************************************/
|
||
|
||
/* Genere le plan de percage (Drill map) format HPGL ou POSTSCRIPT
|
||
*/
|
||
{
|
||
unsigned ii;
|
||
int x, y;
|
||
int plotX, plotY, TextWidth;
|
||
int intervalle = 0, CharSize = 0;
|
||
EDA_BaseStruct* PtStruct;
|
||
int old_g_PlotOrient = g_PlotOrient;
|
||
wxString FullFileName, Mask( wxT( "*" ) ), Ext;
|
||
char line[1024];
|
||
int dX, dY;
|
||
wxPoint BoardCentre;
|
||
int PlotMarge_in_mils = 400; // Margin in 1/1000 inch
|
||
int marge = PlotMarge_in_mils * U_PCB;
|
||
wxSize SheetSize;
|
||
float fTextScale = 1.0;
|
||
double scale_x = 1.0, scale_y = 1.0;
|
||
Ki_PageDescr* SheetPS = NULL;
|
||
wxString msg;
|
||
|
||
/* Init extension */
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
Ext = wxT( "-drl.plt" );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
Ext = wxT( "-drl.ps" );
|
||
break;
|
||
|
||
default:
|
||
DisplayError( this, wxT( "WinEDA_DrillFrame::GenDrillMap() error" ) );
|
||
return;
|
||
}
|
||
|
||
/* Init file name */
|
||
FullFileName = m_Parent->m_CurrentScreen->m_FileName;
|
||
ChangeFileNameExt( FullFileName, Ext );
|
||
Mask += Ext;
|
||
|
||
FullFileName = EDA_FileSelector( _( "Drill Map file" ),
|
||
wxEmptyString, /* Chemin par defaut */
|
||
FullFileName, /* nom fichier par defaut */
|
||
Ext, /* extension par defaut */
|
||
Mask, /* Masque d'affichage */
|
||
this,
|
||
wxFD_SAVE,
|
||
TRUE
|
||
);
|
||
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();
|
||
|
||
dX = m_Parent->m_Pcb->m_BoundaryBox.GetWidth();
|
||
dY = m_Parent->m_Pcb->m_BoundaryBox.GetHeight();
|
||
BoardCentre = m_Parent->m_Pcb->m_BoundaryBox.Centre();
|
||
|
||
// Calcul de l'echelle du dessin du PCB,
|
||
// Echelle 1 en HPGL, dessin sur feuille A4 en PS, + texte description des symboles
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL: /* Calcul des echelles de conversion format HPGL */
|
||
Scale_X = Scale_Y = 1.0;
|
||
scale_x = Scale_X * SCALE_HPGL;
|
||
scale_y = Scale_Y * SCALE_HPGL;
|
||
fTextScale = SCALE_HPGL;
|
||
SheetSize = m_Parent->m_CurrentScreen->m_CurrentSheet->m_Size;
|
||
SheetSize.x *= U_PCB;
|
||
SheetSize.y *= U_PCB;
|
||
g_PlotOffset.x = 0;
|
||
g_PlotOffset.y = (int) (SheetSize.y * scale_y);
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
{
|
||
// calcul en unites internes des dimensions de la feuille ( connues en 1/1000 pouce )
|
||
SheetPS = &g_Sheet_A4;
|
||
SheetSize.x = SheetPS->m_Size.x * U_PCB;
|
||
SheetSize.y = SheetPS->m_Size.y * U_PCB;
|
||
float Xscale = (float) ( SheetSize.x - (marge * 2) ) / dX;
|
||
float Yscale = (float) ( SheetSize.y * 0.6 - (marge * 2) ) / dY;
|
||
|
||
scale_x = scale_y = MIN( Xscale, Yscale );
|
||
|
||
g_PlotOffset.x = -(SheetSize.x / 2) +
|
||
(int) (BoardCentre.x * scale_x) + marge;
|
||
g_PlotOffset.y = SheetSize.y / 2 +
|
||
(int) (BoardCentre.y * scale_y) - marge;
|
||
g_PlotOffset.y += SheetSize.y / 8; /* decalage pour legende */
|
||
break;
|
||
}
|
||
}
|
||
|
||
dest = wxFopen( FullFileName, wxT( "wt" ) );
|
||
if( dest == 0 )
|
||
{
|
||
msg.Printf( _( "Unable to create file <%s>" ), FullFileName.GetData() );
|
||
DisplayError( this, msg ); return;
|
||
}
|
||
|
||
/* Init : */
|
||
m_Parent->MsgPanel->EraseMsgBox();
|
||
Affiche_1_Parametre( m_Parent, 0, _( "File" ), FullFileName, BLUE );
|
||
|
||
/* Calcul de la liste des diametres de percage (liste des drill_tools) */
|
||
ii = Gen_Liste_Tools( s_ToolListBuffer, FALSE );
|
||
msg.Printf( wxT( "%d" ), ii );
|
||
Affiche_1_Parametre( m_Parent, 48, _( "Tools" ), msg, BROWN );
|
||
|
||
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_y );
|
||
PrintHeaderHPGL( dest, g_HPGL_Pen_Speed, g_HPGL_Pen_Num );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
{
|
||
int BBox[4];
|
||
BBox[0] = BBox[1] = PlotMarge_in_mils;
|
||
BBox[2] = SheetPS->m_Size.x - PlotMarge_in_mils;
|
||
BBox[3] = SheetPS->m_Size.y - PlotMarge_in_mils;
|
||
InitPlotParametresPS( g_PlotOffset, SheetPS,
|
||
(double) 1.0 / PCB_INTERNAL_UNIT, (double) 1.0 / PCB_INTERNAL_UNIT );
|
||
SetDefaultLineWidthPS( 10 ); // Set line with to 10/1000 inch
|
||
PrintHeaderPS( dest, wxT( "PCBNEW-PS" ), FullFileName, 1, BBox, wxLANDSCAPE );
|
||
InitPlotParametresPS( g_PlotOffset, SheetPS, scale_x, scale_y );
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
/* Draw items on edge layer */
|
||
PtStruct = m_Parent->m_Pcb->m_Drawings;
|
||
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
|
||
{
|
||
switch( PtStruct->Type() )
|
||
{
|
||
case TYPEDRAWSEGMENT:
|
||
PlotDrawSegment( (DRAWSEGMENT*) PtStruct, format, EDGE_LAYER );
|
||
break;
|
||
|
||
case TYPETEXTE:
|
||
PlotTextePcb( (TEXTE_PCB*) PtStruct, format, EDGE_LAYER );
|
||
break;
|
||
|
||
case TYPECOTATION:
|
||
PlotCotation( (COTATION*) PtStruct, format, EDGE_LAYER );
|
||
break;
|
||
|
||
case TYPEMIRE:
|
||
PlotMirePcb( (MIREPCB*) PtStruct, format, EDGE_LAYER );
|
||
break;
|
||
|
||
case TYPEMARKER: // do not draw
|
||
break;
|
||
|
||
default:
|
||
DisplayError( this, wxT( "WinEDA_DrillFrame::GenDrillMap() : Unexpected Draw Type" ) );
|
||
break;
|
||
}
|
||
}
|
||
|
||
TextWidth = 50; // Set Drill Symbols width in 1/10000 mils
|
||
|
||
if( format == PLOT_FORMAT_POST )
|
||
{
|
||
sprintf( line, "%d setlinewidth\n", TextWidth );
|
||
fputs( line, dest );
|
||
}
|
||
|
||
ii = Plot_Drill_PcbMap( s_ToolListBuffer, format );
|
||
msg.Printf( wxT( "%d" ), ii );
|
||
Affiche_1_Parametre( m_Parent, 64, _( "Drill" ), msg, GREEN );
|
||
|
||
/* Impression de la liste des symboles utilises */
|
||
CharSize = 800; /* text size in 1/10000 mils */
|
||
float CharScale = 1.0 / scale_x; /* real scale will be CharScale * scale_x,
|
||
* because the global plot scale is scale_x */
|
||
TextWidth = (int) (50 * CharScale); // Set text width
|
||
intervalle = (int) (CharSize * CharScale) + TextWidth;
|
||
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
{
|
||
/* 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 );
|
||
sprintf( line, "SI %s, %s;\n", csize, csize );
|
||
break;
|
||
}
|
||
|
||
case PLOT_FORMAT_POST:
|
||
/* Reglage de l'epaisseur de traits des textes */
|
||
sprintf( line, "%d setlinewidth\n", TextWidth );
|
||
break;
|
||
|
||
default:
|
||
*line = 0;
|
||
break;
|
||
}
|
||
|
||
fputs( line, dest );
|
||
|
||
switch( format )
|
||
{
|
||
default:
|
||
case PLOT_FORMAT_POST:
|
||
g_PlotOffset.x = 0;
|
||
g_PlotOffset.y = 0;
|
||
InitPlotParametresPS( g_PlotOffset, SheetPS, scale_x, scale_x );
|
||
break;
|
||
|
||
case PLOT_FORMAT_HPGL:
|
||
InitPlotParametresHPGL( g_PlotOffset, scale_x, scale_x );
|
||
break;
|
||
}
|
||
|
||
/* Trace des informations */
|
||
|
||
/* Trace de "Infos" */
|
||
plotX = marge + 1000;
|
||
plotY = CharSize + 1000;
|
||
x = plotX; y = plotY;
|
||
x = +g_PlotOffset.x + (int) (x * fTextScale);
|
||
y = g_PlotOffset.y - (int) (y * fTextScale);
|
||
|
||
plotY += (int) ( intervalle * 1.2) + 200;
|
||
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
sprintf( line, "PU %d, %d; LBInfos\03;\n",
|
||
x + (int) (intervalle * CharScale * fTextScale),
|
||
y - (int) (CharSize / 2 * CharScale * fTextScale) );
|
||
fputs( line, dest );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
wxString Text = wxT( "Infos" );
|
||
Plot_1_texte( format, Text, 0, TextWidth,
|
||
x, y,
|
||
(int) (CharSize * CharScale), (int) (CharSize * CharScale),
|
||
FALSE );
|
||
break;
|
||
}
|
||
|
||
|
||
for( ii = 0; ii < buffer.size(); ii++ )
|
||
{
|
||
int plot_diam;
|
||
if( buffer[ii].m_TotalCount == 0 )
|
||
continue;
|
||
|
||
plot_diam = (int) (buffer[ii].m_Diameter);
|
||
x = plotX; y = plotY;
|
||
x = -g_PlotOffset.x + (int) (x * fTextScale);
|
||
y = g_PlotOffset.y - (int) (y * fTextScale);
|
||
PlotDrillSymbol( wxPoint( x, y ), plot_diam, ii, format );
|
||
|
||
intervalle = (int) (CharSize * CharScale) + TextWidth;
|
||
intervalle = (int) ( intervalle * 1.2);
|
||
|
||
if( intervalle < (plot_diam + 200 + TextWidth) )
|
||
intervalle = plot_diam + 200 + TextWidth;
|
||
|
||
int rayon = plot_diam / 2;
|
||
x = plotX + rayon + (int) (CharSize * CharScale); y = plotY;
|
||
x = -g_PlotOffset.x + (int) (x * fTextScale);
|
||
y = g_PlotOffset.y - (int) (y * fTextScale);
|
||
|
||
/* Trace de la legende associee */
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
|
||
// List the diameter of each drill in the selected Drill Unit,
|
||
// and then its diameter in the other Drill Unit.
|
||
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),
|
||
float (buffer[ii].m_Diameter) * 0.0001,
|
||
float (buffer[ii].m_Diameter) * 0.00254 );
|
||
else
|
||
sprintf( line, "PU %d, %d; LB%2.2fmm / %2.3f\" ",
|
||
x + (int) (intervalle * CharScale * fTextScale),
|
||
y - (int) (CharSize / 2 * CharScale * fTextScale),
|
||
float (buffer[ii].m_Diameter) * 0.00254,
|
||
float (buffer[ii].m_Diameter) * 0.0001 );
|
||
fputs( line, dest );
|
||
|
||
// Now list how many holes and ovals are associated with each drill.
|
||
if( ( buffer[ii].m_TotalCount == 1 ) && ( buffer[ii].m_OvalCount == 0 ) )
|
||
sprintf( line, "(1 hole)\n" );
|
||
else if( buffer[ii].m_TotalCount == 1 ) // && ( buffer[ii]m_OvalCount == 1 )
|
||
sprintf( line, "(1 hole) (with 1 oblong)\n" );
|
||
else if( buffer[ii].m_OvalCount == 0 )
|
||
sprintf( line, "(%d holes)\n",
|
||
buffer[ii].m_TotalCount );
|
||
else if( buffer[ii].m_OvalCount == 1 )
|
||
sprintf( line, "(%d holes) (with 1 oblong)\n",
|
||
buffer[ii].m_TotalCount );
|
||
else // if ( buffer[ii]m_OvalCount > 1 )
|
||
sprintf( line, "(%d holes) (with %d oblongs)\n",
|
||
buffer[ii].m_TotalCount,
|
||
buffer[ii].m_OvalCount );
|
||
fputs( line, dest );
|
||
fputs( "\03;\n", dest );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
|
||
// List the diameter of each drill in the selected Drill Unit,
|
||
// and then its diameter in the other Drill Unit.
|
||
if( s_Unit_Drill_is_Inch )
|
||
sprintf( line, "%2.3f\" / %2.2fmm ",
|
||
float (buffer[ii].m_Diameter) * 0.0001,
|
||
float (buffer[ii].m_Diameter) * 0.00254 );
|
||
else
|
||
sprintf( line, "%2.2fmm / %2.3f\" ",
|
||
float (buffer[ii].m_Diameter) * 0.00254,
|
||
float (buffer[ii].m_Diameter) * 0.0001 );
|
||
msg = CONV_FROM_UTF8( line );
|
||
|
||
// Now list how many holes and ovals are associated with each drill.
|
||
if( ( buffer[ii].m_TotalCount == 1 ) && ( buffer[ii].m_OvalCount == 0 ) )
|
||
sprintf( line, "(1 hole)" );
|
||
else if( buffer[ii].m_TotalCount == 1 ) // && ( buffer[ii]m_OvalCount == 1 )
|
||
sprintf( line, "(1 hole) (with 1 oblong)" );
|
||
else if( buffer[ii].m_OvalCount == 0 )
|
||
sprintf( line, "(%d holes)",
|
||
buffer[ii].m_TotalCount );
|
||
else if( buffer[ii].m_OvalCount == 1 )
|
||
sprintf( line, "(%d holes) (with 1 oblong)",
|
||
buffer[ii].m_TotalCount );
|
||
else // if ( buffer[ii]m_OvalCount > 1 )
|
||
sprintf( line, "(%d holes) (with %d oblongs)",
|
||
buffer[ii].m_TotalCount,
|
||
buffer[ii].m_OvalCount );
|
||
msg += CONV_FROM_UTF8( line );
|
||
Plot_1_texte( format, msg, 0, TextWidth,
|
||
x, y,
|
||
(int) (CharSize * CharScale),
|
||
(int) (CharSize * CharScale),
|
||
FALSE );
|
||
break;
|
||
}
|
||
|
||
plotY += intervalle;
|
||
}
|
||
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
CloseFileHPGL( dest );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
CloseFilePS( dest );
|
||
break;
|
||
}
|
||
|
||
setlocale( LC_NUMERIC, "" ); // Revert to local notation for float numbers
|
||
|
||
g_PlotOrient = old_g_PlotOrient;
|
||
}
|
||
|
||
|
||
/****************************************************************************************/
|
||
int WinEDA_DrillFrame::Plot_Drill_PcbMap( std::vector<DRILL_TOOL>& buffer, int format )
|
||
/****************************************************************************************/
|
||
|
||
/** Creates the drill map file in HPGL or POSTSCRIPT format
|
||
* @return drill count
|
||
* @param buffer = drill list buffer
|
||
* @param format = ouput format (hpgl / ps)
|
||
*/
|
||
{
|
||
TRACK* pt_piste;
|
||
D_PAD* pt_pad;
|
||
MODULE* Module;
|
||
unsigned shape_id;
|
||
int diam, holes_count;
|
||
wxPoint pos;
|
||
wxSize size;
|
||
|
||
holes_count = 0;
|
||
|
||
/* create the drill list */
|
||
if( buffer.size() > 13 )
|
||
{
|
||
DisplayInfo( this,
|
||
_(
|
||
" Drill map: Too many diameter values to draw to draw one symbol per drill value (max 13)\nPlot uses circle shape for some drill values" ),
|
||
10 );
|
||
}
|
||
|
||
// Plot the drill map:
|
||
for( shape_id = 0; shape_id < buffer.size(); shape_id++ )
|
||
{
|
||
/* create the via drill map */
|
||
{
|
||
pt_piste = m_Parent->m_Pcb->m_Track;
|
||
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
|
||
{
|
||
if( pt_piste->Type() != TYPEVIA )
|
||
continue;
|
||
int via_drill = pt_piste->GetDrillValue();
|
||
if( via_drill != buffer[shape_id].m_Diameter )
|
||
continue;
|
||
pos = pt_piste->m_Start;
|
||
PlotDrillSymbol( pos, via_drill, shape_id, format );
|
||
|
||
holes_count++;
|
||
}
|
||
}
|
||
/* create the pad drill map: */
|
||
for( Module = m_Parent->m_Pcb->m_Modules; Module != NULL; Module = Module->Next() )
|
||
{
|
||
pt_pad = (D_PAD*) Module->m_Pads;
|
||
for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
|
||
{
|
||
switch( pt_pad->m_DrillShape )
|
||
{
|
||
case PAD_CIRCLE:
|
||
diam = pt_pad->m_Drill.x;
|
||
if( diam != buffer[shape_id].m_Diameter )
|
||
continue;
|
||
PlotDrillSymbol( pt_pad->m_Pos, diam, shape_id, format );
|
||
break;
|
||
|
||
case PAD_OVAL:
|
||
if( pt_pad->m_DrillShape != PAD_OVAL )
|
||
continue;
|
||
diam = MIN( pt_pad->m_Drill.x, pt_pad->m_Drill.y );
|
||
if( diam != buffer[shape_id].m_Diameter )
|
||
continue;
|
||
PlotOvalDrillSymbol( pt_pad->m_Pos, pt_pad->m_Drill, pt_pad->m_Orient, format );
|
||
break;
|
||
}
|
||
|
||
holes_count++;
|
||
}
|
||
|
||
/* Fin examen 1 module */
|
||
}
|
||
|
||
/* Fin 1 passe de drill_tool */
|
||
}
|
||
|
||
/* fin analyse des trous de modules */
|
||
|
||
return holes_count;
|
||
}
|
||
|
||
|
||
/************************************************************************************/
|
||
void PlotDrillSymbol( const wxPoint& position, int diametre, int num_forme, int format )
|
||
/************************************************************************************/
|
||
|
||
/* 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 generer des formes caract )
|
||
*/
|
||
{
|
||
int rayon = diametre / 2;
|
||
|
||
void (*FctPlume)( wxPoint pos, int state );
|
||
int x0, y0;
|
||
|
||
x0 = position.x; y0 = position.y;
|
||
FctPlume = Move_Plume_HPGL;
|
||
if( format == PLOT_FORMAT_POST )
|
||
FctPlume = LineTo_PS;
|
||
|
||
switch( num_forme )
|
||
{
|
||
case 0: /* vias : forme en X */
|
||
FctPlume( wxPoint( x0 - rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 + rayon ), 'D' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 - rayon, y0 + rayon ), 'D' );
|
||
break;
|
||
|
||
case 1: /* Cercle */
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
break;
|
||
|
||
case 2: /* forme en + */
|
||
FctPlume( wxPoint( x0, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0, y0 + rayon ), 'D' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 ), 'U' );
|
||
FctPlume( wxPoint( x0 - rayon, y0 ), 'D' );
|
||
break;
|
||
|
||
case 3: /* forme en X cercle */
|
||
FctPlume( wxPoint( x0 - rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 + rayon ), 'D' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 - rayon, y0 + rayon ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
break;
|
||
|
||
case 4: /* forme en cercle barre de - */
|
||
FctPlume( wxPoint( x0 - rayon, y0 ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
break;
|
||
|
||
case 5: /* forme en cercle barre de | */
|
||
FctPlume( wxPoint( x0, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0, y0 + rayon ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
break;
|
||
|
||
case 6: /* forme en carre */
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 7: /* forme en losange */
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 8: /* forme en carre barre par un X*/
|
||
FctPlume( wxPoint( x0 - rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 + rayon ), 'D' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 - rayon, y0 + rayon ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 9: /* forme en losange barre par un +*/
|
||
FctPlume( wxPoint( x0, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0, y0 + rayon ), 'D' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 ), 'U' );
|
||
FctPlume( wxPoint( x0 - rayon, y0 ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 10: /* forme en carre barre par un '/' */
|
||
FctPlume( wxPoint( x0 - rayon, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 + rayon ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 0,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 11: /* forme en losange barre par un |*/
|
||
FctPlume( wxPoint( x0, y0 - rayon ), 'U' );
|
||
FctPlume( wxPoint( x0, y0 + rayon ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
break;
|
||
|
||
case 12: /* forme en losange barre par un -*/
|
||
FctPlume( wxPoint( x0 - rayon, y0 ), 'U' );
|
||
FctPlume( wxPoint( x0 + rayon, y0 ), 'D' );
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pad_TRAPEZE_HPGL( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pad_TRAPEZE_POST( wxPoint( x0, y0 ), wxSize( rayon, rayon ), wxSize( 0,
|
||
0 ), 450,
|
||
FILAIRE );
|
||
break;
|
||
|
||
default:
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
trace_1_pastille_RONDE_HPGL( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
if( format == PLOT_FORMAT_POST )
|
||
trace_1_pastille_RONDE_POST( wxPoint( x0, y0 ), diametre, FILAIRE );
|
||
break;
|
||
}
|
||
|
||
if( format == PLOT_FORMAT_HPGL )
|
||
Plume_HPGL( 'U' );
|
||
}
|
||
|
||
|
||
/*********************************************************************************************/
|
||
void PlotOvalDrillSymbol( const wxPoint& position, const wxSize& size, int orient, int format )
|
||
/*********************************************************************************************/
|
||
|
||
/* Draws an oblong hole.
|
||
* because functions to draw oblong shapes exist to draw oblong pads, Use they.
|
||
*/
|
||
{
|
||
switch( format )
|
||
{
|
||
case PLOT_FORMAT_HPGL:
|
||
trace_1_pastille_OVALE_HPGL( position, size, orient, FILAIRE );
|
||
break;
|
||
|
||
case PLOT_FORMAT_POST:
|
||
trace_1_pastille_OVALE_POST( position, size, orient, FILAIRE );
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/***************************************************************************/
|
||
void WinEDA_DrillFrame::GenDrillReport( std::vector<DRILL_TOOL>& buffer )
|
||
/***************************************************************************/
|
||
|
||
/*
|
||
* Create a list of drill values and drill count
|
||
*/
|
||
{
|
||
wxString FileName, Mask( wxT( "*" ) ), Ext( wxT( ".rpt" ) );
|
||
unsigned ii, TotalHoleCount;
|
||
char line[1024];
|
||
wxString msg;
|
||
|
||
FileName = m_Parent->m_CurrentScreen->m_FileName;
|
||
ChangeFileNameExt( FileName, wxT( "-drl" ) + Ext );
|
||
Mask += Ext;
|
||
|
||
FileName = EDA_FileSelector( _( "Drill Report file" ),
|
||
wxEmptyString, /* Chemin par defaut */
|
||
FileName, /* nom fichier par defaut */
|
||
Ext, /* extension par defaut */
|
||
Mask, /* Masque d'affichage */
|
||
this,
|
||
wxFD_SAVE,
|
||
TRUE
|
||
);
|
||
if( FileName.IsEmpty() )
|
||
return;
|
||
|
||
dest = wxFopen( FileName, wxT( "w" ) );
|
||
if( dest == 0 )
|
||
{
|
||
msg = _( "Unable to create file " ) + FileName;
|
||
DisplayError( this, msg );
|
||
return;
|
||
}
|
||
|
||
m_Parent->MsgPanel->EraseMsgBox();
|
||
Affiche_1_Parametre( m_Parent, 0, _( "File" ), FileName, BLUE );
|
||
|
||
/* Determine the list of the different drill diameters. */
|
||
ii = Gen_Liste_Tools( buffer, FALSE );
|
||
msg.Printf( wxT( "%d" ), ii );
|
||
Affiche_1_Parametre( m_Parent, 30, _( "Tools" ), msg, BROWN );
|
||
|
||
fprintf( dest, "Drill report for %s\n", CONV_TO_UTF8( m_Parent->m_CurrentScreen->m_FileName ) );
|
||
|
||
fprintf( dest, "Created on %s\n", DateAndTime( line ) );
|
||
|
||
// List which Drill Unit option had been selected for the associated drill file.
|
||
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; ii < buffer.size(); ii++ )
|
||
{
|
||
// 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( s_Unit_Drill_is_Inch )
|
||
sprintf( line, "T%d %2.3f\" %2.2fmm ",
|
||
ii + 1,
|
||
float (buffer[ii].m_Diameter) * 0.0001,
|
||
float (buffer[ii].m_Diameter) * 0.00254 );
|
||
else
|
||
sprintf( line, "T%d %2.2fmm %2.3f\" ",
|
||
ii + 1,
|
||
float (buffer[ii].m_Diameter) * 0.00254,
|
||
float (buffer[ii].m_Diameter) * 0.0001 );
|
||
fputs( line, dest );
|
||
|
||
// Now list how many holes and ovals are associated with each drill.
|
||
if( ( buffer[ii].m_TotalCount == 1 ) && ( buffer[ii].m_OvalCount == 0 ) )
|
||
sprintf( line, "(1 hole)\n" );
|
||
else if( buffer[ii].m_TotalCount == 1 )
|
||
sprintf( line, "(1 hole) (with 1 oblong)\n" );
|
||
else if( buffer[ii].m_OvalCount == 0 )
|
||
sprintf( line, "(%d holes)\n",
|
||
buffer[ii].m_TotalCount );
|
||
else if( buffer[ii].m_OvalCount == 1 )
|
||
sprintf( line, "(%d holes) (with 1 oblong)\n",
|
||
buffer[ii].m_TotalCount );
|
||
else // if ( buffer[ii]m_OvalCount > 1 )
|
||
sprintf( line, "(%d holes) (with %d oblongs)\n",
|
||
buffer[ii].m_TotalCount,
|
||
buffer[ii].m_OvalCount );
|
||
fputs( line, dest );
|
||
|
||
TotalHoleCount += buffer[ii].m_TotalCount;
|
||
}
|
||
|
||
|
||
|
||
sprintf( line, "\ntotal holes count %d\n", TotalHoleCount );
|
||
fputs( line, dest );
|
||
|
||
fclose( dest );
|
||
}
|