GERBER_WRITER Class Reference

Used to create Gerber drill files. More...

#include <gendrill_gerber_writer.h>

Inheritance diagram for GERBER_WRITER:

Public Types
enum	ZEROS_FMT { DECIMAL_FORMAT , SUPPRESS_LEADING , SUPPRESS_TRAILING , KEEP_ZEROS }
enum	TYPE_FILE { PTH_FILE , NPTH_FILE , MIXED_FILE }

Public Member Functions
	GERBER_WRITER (BOARD *aPcb)
virtual	~GERBER_WRITER ()
void	SetFormat (int aRightDigits=6)
	Initialize internal parameters to match the given format. More...
void	SetOptions (const VECTOR2I &aOffset)
	Initialize internal parameters to match drill options. More...
void	CreateDrillandMapFilesSet (const wxString &aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER *aReporter=nullptr)
	Create the full set of Excellon drill file for the board filenames are computed from the board name, and layers id. More...
void	SetMergeOption (bool aMerge)
	Set the option to make separate drill files for PTH and NPTH. More...
VECTOR2I	GetOffset ()
	Return the plot offset (usually the position of the drill/place origin). More...
void	SetPageInfo (const PAGE_INFO *aPageInfo)
	Set the page info used to plot drill maps. More...
void	SetMapFileFormat (PLOT_FORMAT aMapFmt)
	Initialize the format for the drill map file. More...
void	CreateMapFilesSet (const wxString &aPlotDirectory, REPORTER *aReporter=nullptr)
	Create the full set of map files for the board, in PS, PDF ... format (use SetMapFileFormat() to select the format). More...
bool	GenDrillReportFile (const wxString &aFullFileName)
	Create a plain text report file giving a list of drill values and drill count for through holes, oblong holes, and for buried vias, drill values and drill count per layer pair there is only one report for all drill files even when buried or blinds vias exist. More...
wxString	GetDrillFileExt () const
	Returns the file extension of the drill writer format. More...

Protected Member Functions
bool	genDrillMapFile (const wxString &aFullFileName, PLOT_FORMAT aFormat)
	Plot a map of drill marks for holes. More...
void	buildHolesList (DRILL_LAYER_PAIR aLayerPair, bool aGenerateNPTH_list)
	Create the list of holes and tools for a given board. More...
int	getHolesCount () const
bool	plotDrillMarks (PLOTTER *aPlotter)
	Write the drill marks in HPGL, POSTSCRIPT or other supported formats/. More...
std::vector< DRILL_LAYER_PAIR >	getUniqueLayerPairs () const
	Get unique layer pairs by examining the micro and blind_buried vias. More...
unsigned	printToolSummary (OUTPUTFORMATTER &aOut, bool aSummaryNPTH) const
	Print m_toolListBuffer[] tools to aOut and returns total hole count. More...
const std::string	layerPairName (DRILL_LAYER_PAIR aPair) const
const std::string	layerName (PCB_LAYER_ID aLayer) const
const wxString	BuildFileFunctionAttributeString (DRILL_LAYER_PAIR aLayerPair, TYPE_FILE aHoleType, bool aCompatNCdrill=false) const

Protected Attributes
BOARD *	m_pcb
wxString	m_drillFileExtension
bool	m_unitsMetric
ZEROS_FMT	m_zeroFormat
DRILL_PRECISION	m_precision
double	m_conversionUnits
VECTOR2I	m_offset
bool	m_merge_PTH_NPTH
std::vector< HOLE_INFO >	m_holeListBuffer
std::vector< DRILL_TOOL >	m_toolListBuffer
PLOT_FORMAT	m_mapFileFmt
const PAGE_INFO *	m_pageInfo

Private Member Functions
int	createDrillFile (wxString &aFullFilename, bool aIsNpth, DRILL_LAYER_PAIR aLayerPair)
	Create an Excellon drill file. More...
virtual const wxString	getDrillFileName (DRILL_LAYER_PAIR aPair, bool aNPTH, bool aMerge_PTH_NPTH) const override

Detailed Description

Used to create Gerber drill files.

Definition at line 40 of file gendrill_gerber_writer.h.

Member Enumeration Documentation

TYPE_FILE

enum GENDRILL_WRITER_BASE::TYPE_FILE

inherited

Enumerator
PTH_FILE
NPTH_FILE
MIXED_FILE

Definition at line 162 of file gendrill_file_writer_base.h.

 { // type of holes in file: PTH, NPTH, mixed
 PTH_FILE, // PTH only, this is the default also for blind/buried holes
 NPTH_FILE, // NPTH only
 MIXED_FILE // PHT+NPTH (mixed)
 };

ZEROS_FMT

enum GENDRILL_WRITER_BASE::ZEROS_FMT

inherited

Enumerator
DECIMAL_FORMAT
SUPPRESS_LEADING
SUPPRESS_TRAILING
KEEP_ZEROS

Definition at line 155 of file gendrill_file_writer_base.h.

 { // Zero format in coordinates
 DECIMAL_FORMAT, // Floating point coordinates
 SUPPRESS_LEADING, // Suppress leading zeros
 SUPPRESS_TRAILING, // Suppress trailing zeros
 KEEP_ZEROS // keep zeros
 };

Constructor & Destructor Documentation

GERBER_WRITER()

GERBER_WRITER::GERBER_WRITER

(

BOARD *

aPcb

)

Definition at line 46 of file gendrill_gerber_writer.cpp.

 : GENDRILL_WRITER_BASE( aPcb )
{
 m_zeroFormat = SUPPRESS_LEADING;
 m_conversionUnits = 1.0;
 m_unitsMetric = true;
 m_drillFileExtension = wxT( "gbr" );
 m_merge_PTH_NPTH = false;
}

References GENDRILL_WRITER_BASE::m_conversionUnits, GENDRILL_WRITER_BASE::m_drillFileExtension, GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, GENDRILL_WRITER_BASE::m_unitsMetric, GENDRILL_WRITER_BASE::m_zeroFormat, and GENDRILL_WRITER_BASE::SUPPRESS_LEADING.

~GERBER_WRITER()

virtual GERBER_WRITER::~GERBER_WRITER ( )

inlinevirtual

Definition at line 45 of file gendrill_gerber_writer.h.

 {
 }

Member Function Documentation

BuildFileFunctionAttributeString()

const wxString GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString ( DRILL_LAYER_PAIR  aLayerPair, TYPE_FILE  aHoleType, bool  aCompatNCdrill = false  ) const

protectedinherited

Parameters

aLayerPair	is the layer pair (Drill from rom first layer to second layer)
aHoleType	is type of drill file (PTH, NPTH, mixed)
aCompatNCdrill	is true when generating NC (Excellon) compatible drill file

Returns

a wxString containing the .FileFunction attribute. the standard X2 FileFunction for drill files is TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried], Drill[Route][Mixed]*% There is no X1 version, as the Gerber drill files uses only X2 format There is a compatible NC drill version.

Definition at line 359 of file gendrill_file_writer_base.cpp.

{
// Build a wxString containing the .FileFunction attribute for drill files.
// %TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried],Drill[Route][Mixed]*%
 wxString text;
 
 if( aCompatNCdrill )
 text = wxT( "; #@! " );
 else
 text = wxT( "%" );
 
 text << wxT( "TF.FileFunction," );
 
 if( aHoleType == NPTH_FILE )
 text << wxT( "NonPlated," );
 else if( aHoleType == MIXED_FILE ) // only for Excellon format
 text << wxT( "MixedPlating," );
 else
 text << wxT( "Plated," );
 
 int layer1 = aLayerPair.first;
 int layer2 = aLayerPair.second;
 // In Gerber files, layers num are 1 to copper layer count instead of F_Cu to B_Cu
 // (0 to copper layer count-1)
 // Note also for a n copper layers board, gerber layers num are 1 ... n
 layer1 += 1;
 
 if( layer2 == B_Cu )
 layer2 = m_pcb->GetCopperLayerCount();
 else
 layer2 += 1;
 
 text << layer1 << wxT( "," ) << layer2;
 
 // Now add PTH or NPTH or Blind or Buried attribute
 int toplayer = 1;
 int bottomlayer = m_pcb->GetCopperLayerCount();
 
 if( aHoleType == NPTH_FILE )
 text << wxT( ",NPTH" );
 else if( aHoleType == MIXED_FILE ) // only for Excellon format
 {
 // write nothing
 }
 else if( layer1 == toplayer && layer2 == bottomlayer )
 text << wxT( ",PTH" );
 else if( layer1 == toplayer || layer2 == bottomlayer )
 text << wxT( ",Blind" );
 else
 text << wxT( ",Buried" );
 
 // In NC drill file, these previous parameters should be enough:
 if( aCompatNCdrill )
 return text;
 
 
 // Now add Drill or Route or Mixed:
 // file containing only round holes have Drill attribute
 // file containing only oblong holes have Routed attribute
 // file containing both holes have Mixed attribute
 bool hasOblong = false;
 bool hasDrill = false;
 
 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
 {
 const HOLE_INFO& hole_descr = m_holeListBuffer[ii];
 
 if( hole_descr.m_Hole_Shape ) // m_Hole_Shape not 0 is an oblong hole)
 hasOblong = true;
 else
 hasDrill = true;
 }
 
 if( hasOblong && hasDrill )
 text << wxT( ",Mixed" );
 else if( hasDrill )
 text << wxT( ",Drill" );
 else if( hasOblong )
 text << wxT( ",Route" );
 
 // else: empty file.
 
 // End of .FileFunction attribute:
 text << wxT( "*%" );
 
 return text;
}

References B_Cu, BOARD::GetCopperLayerCount(), HOLE_INFO::m_Hole_Shape, GENDRILL_WRITER_BASE::m_holeListBuffer, GENDRILL_WRITER_BASE::m_pcb, GENDRILL_WRITER_BASE::MIXED_FILE, GENDRILL_WRITER_BASE::NPTH_FILE, and text.

Referenced by createDrillFile(), and EXCELLON_WRITER::writeEXCELLONHeader().

buildHolesList()

void GENDRILL_WRITER_BASE::buildHolesList ( DRILL_LAYER_PAIR  aLayerPair, bool  aGenerateNPTH_list  )

protectedinherited

Create the list of holes and tools for a given board.

The list is sorted by increasing drill size. Only holes included within aLayerPair are listed. If aLayerPair identifies with [F_Cu, B_Cu], then pad holes are always included also.

Parameters

aLayerPair	is an inclusive range of layers.
aGenerateNPTH_list	: true to create NPTH only list (with no plated holes) false to created plated holes list (with no NPTH )

Definition at line 66 of file gendrill_file_writer_base.cpp.

{
 HOLE_INFO new_hole;
 
 m_holeListBuffer.clear();
 m_toolListBuffer.clear();
 
 wxASSERT( aLayerPair.first < aLayerPair.second ); // fix the caller
 
 // build hole list for vias
 if( ! aGenerateNPTH_list ) // vias are always plated !
 {
 for( auto track : m_pcb->Tracks() )
 {
 if( track->Type() != PCB_VIA_T )
 continue;
 
 PCB_VIA* via = static_cast<PCB_VIA*>( track );
 int hole_sz = via->GetDrillValue();
 
 if( hole_sz == 0 ) // Should not occur.
 continue;
 
 new_hole.m_ItemParent = via;
 
 if( aLayerPair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 new_hole.m_HoleAttribute = HOLE_ATTRIBUTE::HOLE_VIA_THROUGH;
 else
 new_hole.m_HoleAttribute = HOLE_ATTRIBUTE::HOLE_VIA_BURIED;
 
 new_hole.m_Tool_Reference = -1; // Flag value for Not initialized
 new_hole.m_Hole_Orient = ANGLE_0;
 new_hole.m_Hole_Diameter = hole_sz;
 new_hole.m_Hole_NotPlated = false;
 new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
 
 new_hole.m_Hole_Shape = 0; // hole shape: round
 new_hole.m_Hole_Pos = via->GetStart();
 
 via->LayerPair( &new_hole.m_Hole_Top_Layer, &new_hole.m_Hole_Bottom_Layer );
 
 // LayerPair() returns params with m_Hole_Bottom_Layer > m_Hole_Top_Layer
 // Remember: top layer = 0 and bottom layer = 31 for through hole vias
 // Any captured via should be from aLayerPair.first to aLayerPair.second exactly.
 if( new_hole.m_Hole_Top_Layer != aLayerPair.first ||
 new_hole.m_Hole_Bottom_Layer != aLayerPair.second )
 continue;
 
 m_holeListBuffer.push_back( new_hole );
 }
 }
 
 if( aLayerPair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 {
 // add holes for thru hole pads
 for( FOOTPRINT* footprint : m_pcb->Footprints() )
 {
 for( PAD* pad : footprint->Pads() )
 {
 if( !m_merge_PTH_NPTH )
 {
 if( !aGenerateNPTH_list && pad->GetAttribute() == PAD_ATTRIB::NPTH )
 continue;
 
 if( aGenerateNPTH_list && pad->GetAttribute() != PAD_ATTRIB::NPTH )
 continue;
 }
 
 if( pad->GetDrillSize().x == 0 )
 continue;
 
 new_hole.m_ItemParent = pad;
 new_hole.m_Hole_NotPlated = (pad->GetAttribute() == PAD_ATTRIB::NPTH);
 new_hole.m_HoleAttribute = new_hole.m_Hole_NotPlated
 ? HOLE_ATTRIBUTE::HOLE_MECHANICAL
 : HOLE_ATTRIBUTE::HOLE_PAD;
 new_hole.m_Tool_Reference = -1; // Flag is: Not initialized
 new_hole.m_Hole_Orient = pad->GetOrientation();
 new_hole.m_Hole_Shape = 0; // hole shape: round
 new_hole.m_Hole_Diameter = std::min( pad->GetDrillSize().x, pad->GetDrillSize().y );
 new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
 
 // Convert oblong holes that are actually circular into drill hits
 if( pad->GetDrillShape() != PAD_DRILL_SHAPE_CIRCLE &&
 pad->GetDrillSizeX() != pad->GetDrillSizeY() )
 {
 new_hole.m_Hole_Shape = 1; // oval flag set
 }
 
 new_hole.m_Hole_Size = pad->GetDrillSize();
 new_hole.m_Hole_Pos = pad->GetPosition(); // hole position
 new_hole.m_Hole_Bottom_Layer = B_Cu;
 new_hole.m_Hole_Top_Layer = F_Cu; // pad holes are through holes
 m_holeListBuffer.push_back( new_hole );
 }
 }
 }
 
 // Sort holes per increasing diameter value (and for each dimater, by position)
 sort( m_holeListBuffer.begin(), m_holeListBuffer.end(), cmpHoleSorting );
 
 // build the tool list
 int last_hole = -1; // Set to not initialized (this is a value not used
 // for m_holeListBuffer[ii].m_Hole_Diameter)
 bool last_notplated_opt = false;
 HOLE_ATTRIBUTE last_attribute = HOLE_ATTRIBUTE::HOLE_UNKNOWN;
 
 DRILL_TOOL new_tool( 0, false );
 unsigned jj;
 
 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
 {
 if( m_holeListBuffer[ii].m_Hole_Diameter != last_hole
 || m_holeListBuffer[ii].m_Hole_NotPlated != last_notplated_opt
#if USE_ATTRIB_FOR_HOLES
 || m_holeListBuffer[ii].m_HoleAttribute != last_attribute
#endif
 )
 {
 new_tool.m_Diameter = m_holeListBuffer[ii].m_Hole_Diameter;
 new_tool.m_Hole_NotPlated = m_holeListBuffer[ii].m_Hole_NotPlated;
 new_tool.m_HoleAttribute = m_holeListBuffer[ii].m_HoleAttribute;
 m_toolListBuffer.push_back( new_tool );
 last_hole = new_tool.m_Diameter;
 last_notplated_opt = new_tool.m_Hole_NotPlated;
 last_attribute = new_tool.m_HoleAttribute;
 }
 
 jj = m_toolListBuffer.size();
 
 if( jj == 0 )
 continue; // Should not occurs
 
 m_holeListBuffer[ii].m_Tool_Reference = jj; // Tool value Initialized (value >= 1)
 
 m_toolListBuffer.back().m_TotalCount++;
 
 if( m_holeListBuffer[ii].m_Hole_Shape )
 m_toolListBuffer.back().m_OvalCount++;
 }
}

References ANGLE_0, B_Cu, cmpHoleSorting(), F_Cu, BOARD::Footprints(), HOLE_MECHANICAL, HOLE_PAD, HOLE_UNKNOWN, HOLE_VIA_BURIED, HOLE_VIA_THROUGH, DRILL_TOOL::m_Diameter, HOLE_INFO::m_Hole_Bottom_Layer, HOLE_INFO::m_Hole_Diameter, DRILL_TOOL::m_Hole_NotPlated, HOLE_INFO::m_Hole_NotPlated, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, HOLE_INFO::m_Hole_Top_Layer, DRILL_TOOL::m_HoleAttribute, HOLE_INFO::m_HoleAttribute, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_ItemParent, GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, GENDRILL_WRITER_BASE::m_pcb, HOLE_INFO::m_Tool_Reference, GENDRILL_WRITER_BASE::m_toolListBuffer, NPTH, pad, PAD_DRILL_SHAPE_CIRCLE, PCB_VIA_T, BOARD::Tracks(), USE_ATTRIB_FOR_HOLES, via, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateDrillandMapFilesSet(), GENDRILL_WRITER_BASE::CreateMapFilesSet(), and GENDRILL_WRITER_BASE::GenDrillReportFile().

CreateDrillandMapFilesSet()

void GERBER_WRITER::CreateDrillandMapFilesSet	(	const wxString &	aPlotDirectory,
		bool	aGenDrill,
		bool	aGenMap,
		REPORTER *	aReporter = nullptr
	)

Create the full set of Excellon drill file for the board filenames are computed from the board name, and layers id.

Parameters

aPlotDirectory	is the output folder.
aGenDrill	set to true to generate the EXCELLON drill file.
aGenMap	set to true to generate a drill map file.
aReporter	is a REPORTER to return activity or any message (can be NULL).

Definition at line 57 of file gendrill_gerber_writer.cpp.

{
 // Note: In Gerber drill files, NPTH and PTH are always separate files
 m_merge_PTH_NPTH = false;
 
 wxFileName fn;
 wxString msg;
 
 std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
 
 // append a pair representing the NPTH set of holes, for separate drill files.
 // (Gerber drill files are separate files for PTH and NPTH)
 hole_sets.emplace_back( F_Cu, B_Cu );
 
 for( std::vector<DRILL_LAYER_PAIR>::const_iterator it = hole_sets.begin();
 it != hole_sets.end(); ++it )
 {
 DRILL_LAYER_PAIR pair = *it;
 // For separate drill files, the last layer pair is the NPTH drill file.
 bool doing_npth = ( it == hole_sets.end() - 1 );
 
 buildHolesList( pair, doing_npth );
 
 // The file is created if it has holes, or if it is the non plated drill file
 // to be sure the NPTH file is up to date in separate files mode.
 // Also a PTH drill/map file is always created, to be sure at least one plated hole drill
 // file is created (do not create any PTH drill file can be seen as not working drill
 // generator).
 if( getHolesCount() > 0 || doing_npth || pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 {
 fn = getDrillFileName( pair, doing_npth, false );
 fn.SetPath( aPlotDirectory );
 
 if( aGenDrill )
 {
 wxString fullFilename = fn.GetFullPath();
 
 int result = createDrillFile( fullFilename, doing_npth, pair );
 
 if( result < 0 )
 {
 if( aReporter )
 {
 msg.Printf( _( "Failed to create file '%s'." ), fullFilename );
 aReporter->Report( msg, RPT_SEVERITY_ERROR );
 }
 
 break;
 }
 else
 {
 if( aReporter )
 {
 msg.Printf( _( "Created file '%s'." ), fullFilename );
 aReporter->Report( msg, RPT_SEVERITY_ACTION );
 }
 }
 
 }
 }
 }
 
 if( aGenMap )
 CreateMapFilesSet( aPlotDirectory, aReporter );
 
 if( aReporter )
 aReporter->ReportTail( _( "Done." ), RPT_SEVERITY_INFO );
}

References _, B_Cu, GENDRILL_WRITER_BASE::buildHolesList(), createDrillFile(), GENDRILL_WRITER_BASE::CreateMapFilesSet(), F_Cu, getDrillFileName(), GENDRILL_WRITER_BASE::getHolesCount(), GENDRILL_WRITER_BASE::getUniqueLayerPairs(), GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, REPORTER::Report(), REPORTER::ReportTail(), RPT_SEVERITY_ACTION, RPT_SEVERITY_ERROR, and RPT_SEVERITY_INFO.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

createDrillFile()

int GERBER_WRITER::createDrillFile ( wxString &  aFullFilename, bool  aIsNpth, DRILL_LAYER_PAIR  aLayerPair  )

private

Create an Excellon drill file.

Parameters

aFullFilename	is the full file name.
aIsNpth	set to true for a NPTH file or false for a PTH file.
aLayerPair	is the first board layer and the last board layer for this drill file for blind buried vias, they are not always top and bottom layers/

Returns

hole count or -1 if the file cannot be created.

Definition at line 134 of file gendrill_gerber_writer.cpp.

{
 int holes_count;
 
 LOCALE_IO dummy; // Use the standard notation for double numbers
 
 GERBER_PLOTTER plotter;
 
 // Gerber drill file imply X2 format:
 plotter.UseX2format( true );
 plotter.UseX2NetAttributes( true );
 plotter.DisableApertMacros( false );
 
 // Add the standard X2 header, without FileFunction
 AddGerberX2Header( &plotter, m_pcb );
 plotter.SetViewport( m_offset, pcbIUScale.IU_PER_MILS/10, /* scale */ 1.0, /* mirror */false );
 
 // has meaning only for gerber plotter. Must be called only after SetViewport
 plotter.SetGerberCoordinatesFormat( 6 );
 plotter.SetCreator( wxT( "PCBNEW" ) );
 
 // Add the standard X2 FileFunction for drill files
 // %TF.FileFunction,Plated[NonPlated],layer1num,layer2num,PTH[NPTH][Blind][Buried],Drill[Route][Mixed]*%
 wxString text = BuildFileFunctionAttributeString( aLayerPair,
 aIsNpth ? TYPE_FILE::NPTH_FILE
 : TYPE_FILE::PTH_FILE );
 plotter.AddLineToHeader( text );
 
 // Add file polarity (positive)
 text = wxT( "%TF.FilePolarity,Positive*%" );
 plotter.AddLineToHeader( text );
 
 if( !plotter.OpenFile( aFullFilename ) )
 return -1;
 
 plotter.StartPlot( wxT( "1" ) );
 
 holes_count = 0;
 
 VECTOR2I hole_pos;
 bool last_item_is_via = true; // a flag to clear object attributes when a via hole is created.
 
 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
 {
 HOLE_INFO& hole_descr = m_holeListBuffer[ii];
 hole_pos = hole_descr.m_Hole_Pos;
 
 // Manage the aperture attributes: in drill files 3 attributes can be used:
 // "ViaDrill", only for vias, not pads
 // "ComponentDrill", only for Through Holes pads
 // "Slot" for oblong holes;
 GBR_METADATA gbr_metadata;
 
 if( dyn_cast<const PCB_VIA*>( hole_descr.m_ItemParent ) )
 {
 gbr_metadata.SetApertureAttrib( GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIADRILL );
 
 if( !last_item_is_via )
 {
 // be sure the current object attribute is cleared for vias
 plotter.EndBlock( nullptr );
 }
 
 last_item_is_via = true;
 }
 else if( dyn_cast<const PAD*>( hole_descr.m_ItemParent ) )
 {
 last_item_is_via = false;
 const PAD* pad = dyn_cast<const PAD*>( hole_descr.m_ItemParent );
 
 if( pad->GetProperty() == PAD_PROP::CASTELLATED )
 {
 gbr_metadata.SetApertureAttrib(
 GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CASTELLATEDDRILL );
 }
 else
 {
 // Good practice of oblong pad holes (slots) is to use a specific aperture for
 // routing, not used in drill commands.
 if( hole_descr.m_Hole_Shape )
 gbr_metadata.SetApertureAttrib(
 GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_OBLONG_DRILL );
 else
 gbr_metadata.SetApertureAttrib(
 GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_DRILL );
 }
 
 // Add object attribute: component reference to pads (mainly useful for users)
 wxString ref = pad->GetParent()->GetReference();
 
 gbr_metadata.SetCmpReference( ref );
 gbr_metadata.SetNetAttribType( GBR_NETLIST_METADATA::GBR_NETINFO_CMP );
 }
 
 if( hole_descr.m_Hole_Shape )
 {
#if FLASH_OVAL_HOLE // set to 1 to use flashed oblong holes,
 // 0 to draw them as a line.
 plotter.FlashPadOval( hole_pos, hole_descr.m_Hole_Size, hole_descr.m_Hole_Orient,
 FILLED, &gbr_metadata );
#else
 // Use routing for oblong hole (Slots)
 VECTOR2I start, end;
 convertOblong2Segment( hole_descr.m_Hole_Size, hole_descr.m_Hole_Orient, start, end );
 int width = std::min( hole_descr.m_Hole_Size.x, hole_descr.m_Hole_Size.y );
 
 if ( width == 0 )
 continue;
 
 plotter.ThickSegment( start+hole_pos, end+hole_pos, width, FILLED, &gbr_metadata );
#endif
 }
 else
 {
 int diam = std::min( hole_descr.m_Hole_Size.x, hole_descr.m_Hole_Size.y );
 plotter.FlashPadCircle( hole_pos, diam, FILLED, &gbr_metadata );
 }
 
 holes_count++;
 }
 
 plotter.EndPlot();
 
 return holes_count;
}

References AddGerberX2Header(), PLOTTER::AddLineToHeader(), GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString(), CASTELLATED, GERBER_PLOTTER::DisableApertMacros(), dummy, GERBER_PLOTTER::EndBlock(), GERBER_PLOTTER::EndPlot(), FILLED, GERBER_PLOTTER::FlashPadCircle(), GERBER_PLOTTER::FlashPadOval(), GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CASTELLATEDDRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_DRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_CMP_OBLONG_DRILL, GBR_APERTURE_METADATA::GBR_APERTURE_ATTRIB_VIADRILL, GBR_NETLIST_METADATA::GBR_NETINFO_CMP, EDA_IU_SCALE::IU_PER_MILS, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_ItemParent, GENDRILL_WRITER_BASE::m_offset, GENDRILL_WRITER_BASE::m_pcb, PLOTTER::OpenFile(), pad, pcbIUScale, GBR_METADATA::SetApertureAttrib(), GBR_METADATA::SetCmpReference(), PLOTTER::SetCreator(), GERBER_PLOTTER::SetGerberCoordinatesFormat(), GBR_METADATA::SetNetAttribType(), GERBER_PLOTTER::SetViewport(), GERBER_PLOTTER::StartPlot(), text, GERBER_PLOTTER::ThickSegment(), GERBER_PLOTTER::UseX2format(), GERBER_PLOTTER::UseX2NetAttributes(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by CreateDrillandMapFilesSet().

CreateMapFilesSet()

void GENDRILL_WRITER_BASE::CreateMapFilesSet ( const wxString &  aPlotDirectory, REPORTER *  aReporter = nullptr  )

inherited

Create the full set of map files for the board, in PS, PDF ... format (use SetMapFileFormat() to select the format).

File names are computed from the board name and layer ID.

Parameters

aPlotDirectory	is the output folder.
aReporter	is a REPORTER to return activity or any message (can be NULL)

Definition at line 300 of file gendrill_file_writer_base.cpp.

{
 wxFileName fn;
 wxString msg;
 
 std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
 
 // append a pair representing the NPTH set of holes, for separate drill files.
 if( !m_merge_PTH_NPTH )
 hole_sets.emplace_back( F_Cu, B_Cu );
 
 for( std::vector<DRILL_LAYER_PAIR>::const_iterator it = hole_sets.begin();
 it != hole_sets.end(); ++it )
 {
 DRILL_LAYER_PAIR pair = *it;
 // For separate drill files, the last layer pair is the NPTH drill file.
 bool doing_npth = m_merge_PTH_NPTH ? false : ( it == hole_sets.end() - 1 );
 
 buildHolesList( pair, doing_npth );
 
 // The file is created if it has holes, or if it is the non plated drill file
 // to be sure the NPTH file is up to date in separate files mode.
 // Also a PTH drill file is always created, to be sure at least one plated hole drill file
 // is created (do not create any PTH drill file can be seen as not working drill generator).
 if( getHolesCount() > 0 || doing_npth || pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 {
 fn = GENDRILL_WRITER_BASE::getDrillFileName( pair, doing_npth, m_merge_PTH_NPTH );
 fn.SetPath( aPlotDirectory );
 
 fn.SetExt( wxEmptyString ); // Will be added by GenDrillMap
 wxString fullfilename = fn.GetFullPath() + wxT( "-drl_map" );
 fullfilename << wxT(".") << GetDefaultPlotExtension( m_mapFileFmt );
 
 bool success = genDrillMapFile( fullfilename, m_mapFileFmt );
 
 if( ! success )
 {
 if( aReporter )
 {
 msg.Printf( _( "Failed to create file '%s'." ), fullfilename );
 aReporter->Report( msg, RPT_SEVERITY_ERROR );
 }
 
 return;
 }
 else
 {
 if( aReporter )
 {
 msg.Printf( _( "Created file '%s'." ), fullfilename );
 aReporter->Report( msg, RPT_SEVERITY_ACTION );
 }
 }
 }
 }
}

References _, B_Cu, GENDRILL_WRITER_BASE::buildHolesList(), F_Cu, GENDRILL_WRITER_BASE::genDrillMapFile(), GetDefaultPlotExtension(), GENDRILL_WRITER_BASE::getDrillFileName(), GENDRILL_WRITER_BASE::getHolesCount(), GENDRILL_WRITER_BASE::getUniqueLayerPairs(), GENDRILL_WRITER_BASE::m_mapFileFmt, GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, REPORTER::Report(), RPT_SEVERITY_ACTION, and RPT_SEVERITY_ERROR.

Referenced by EXCELLON_WRITER::CreateDrillandMapFilesSet(), and CreateDrillandMapFilesSet().

genDrillMapFile()

bool GENDRILL_WRITER_BASE::genDrillMapFile ( const wxString &  aFullFileName, PLOT_FORMAT  aFormat  )

protectedinherited

Plot a map of drill marks for holes.

Hole list must be created before calling this function, by buildHolesList() for the right holes set (PTH, NPTH, buried/blind vias ...) the paper sheet to use to plot the map is set in m_pageInfo ( calls SetPageInfo() to set it ). If NULL, A4 format will be used.

Parameters

aFullFileName	is the full filename of the map file to create.
aFormat	is one of the supported plot formats (see enum PlotFormat ).

Definition at line 64 of file gen_drill_report_files.cpp.

{
 // Remark:
 // Hole list must be created before calling this function, by buildHolesList(),
 // for the right holes set (PTH, NPTH, buried/blind vias ...)
 
 double scale = 1.0;
 VECTOR2I offset = GetOffset();
 PLOTTER* plotter = nullptr;
 PAGE_INFO dummy( PAGE_INFO::A4, false );
 int bottom_limit = 0; // Y coord limit of page. 0 mean do not use
 
 PCB_PLOT_PARAMS plot_opts; // starts plotting with default options
 
 LOCALE_IO toggle; // use standard C notation for float numbers
 
 const PAGE_INFO& page_info = m_pageInfo ? *m_pageInfo : dummy;
 
 // Calculate dimensions and center of PCB. The Edge_Cuts layer must be visible
 // to calculate the board edges bounding box
 LSET visibleLayers = m_pcb->GetVisibleLayers();
 m_pcb->SetVisibleLayers( visibleLayers | LSET( Edge_Cuts ) );
 BOX2I bbbox = m_pcb->GetBoardEdgesBoundingBox();
 m_pcb->SetVisibleLayers( visibleLayers );
 
 // Some formats cannot be used to generate a document like the map files
 // Currently HPGL (old format not very used)
 
 if( aFormat == PLOT_FORMAT::HPGL )
 aFormat = PLOT_FORMAT::PDF;
 
 // Calculate the scale for the format type, scale 1 in HPGL, drawing on
 // an A4 sheet in PS, + text description of symbols
 switch( aFormat )
 {
 case PLOT_FORMAT::GERBER:
 plotter = new GERBER_PLOTTER();
 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
 plotter->SetGerberCoordinatesFormat( 5 ); // format x.5 unit = mm
 break;
 
 default:
 wxASSERT( false );
 KI_FALLTHROUGH;
 
 case PLOT_FORMAT::PDF:
 case PLOT_FORMAT::POST:
 case PLOT_FORMAT::SVG:
 {
 PAGE_INFO pageA4( wxT( "A4" ) );
 VECTOR2I pageSizeIU = pageA4.GetSizeIU( pcbIUScale.IU_PER_MILS );
 
 // Reserve a 10 mm margin around the page.
 int margin = pcbIUScale.mmToIU( 10 );
 
 // Calculate a scaling factor to print the board on the sheet
 double Xscale = double( pageSizeIU.x - ( 2 * margin ) ) / bbbox.GetWidth();
 
 // We should print the list of drill sizes, so reserve room for it
 // 60% height for board 40% height for list
 int ypagesize_for_board = KiROUND( pageSizeIU.y * 0.6 );
 double Yscale = double( ypagesize_for_board - margin ) / bbbox.GetHeight();
 
 scale = std::min( Xscale, Yscale );
 
 // Experience shows the scale should not to large, because texts
 // create problem (can be to big or too small).
 // So the scale is clipped at 3.0;
 scale = std::min( scale, 3.0 );
 
 offset.x = KiROUND( double( bbbox.Centre().x ) - ( pageSizeIU.x / 2.0 ) / scale );
 offset.y = KiROUND( double( bbbox.Centre().y ) - ( ypagesize_for_board / 2.0 ) / scale );
 
 // bottom_limit is used to plot the legend (drill diameters)
 // texts are scaled differently for scale > 1.0 and <= 1.0
 // so the limit is scaled differently.
 bottom_limit = ( pageSizeIU.y - margin ) / std::min( scale, 1.0 );
 
 if( aFormat == PLOT_FORMAT::SVG )
 plotter = new SVG_PLOTTER;
 else if( aFormat == PLOT_FORMAT::PDF )
 plotter = new PDF_PLOTTER;
 else
 plotter = new PS_PLOTTER;
 
 plotter->SetPageSettings( pageA4 );
 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
 break;
 }
 
 case PLOT_FORMAT::DXF:
 {
 DXF_PLOTTER* dxf_plotter = new DXF_PLOTTER;
 
 if( m_unitsMetric )
 dxf_plotter->SetUnits( DXF_UNITS::MILLIMETERS );
 else
 dxf_plotter->SetUnits( DXF_UNITS::INCHES );
 
 plotter = dxf_plotter;
 plotter->SetPageSettings( page_info );
 plotter->SetViewport( offset, pcbIUScale.IU_PER_MILS / 10, scale, false );
 break;
 }
 }
 
 plotter->SetCreator( wxT( "PCBNEW" ) );
 plotter->SetColorMode( false );
 
 KIGFX::PCB_RENDER_SETTINGS renderSettings;
 renderSettings.SetDefaultPenWidth( pcbIUScale.mmToIU( 0.2 ) );
 
 plotter->SetRenderSettings( &renderSettings );
 
 if( !plotter->OpenFile( aFullFileName ) )
 {
 delete plotter;
 return false;
 }
 
 plotter->ClearHeaderLinesList();
 
 // For the Gerber X2 format we need to set the "FileFunction" to Drillmap
 // and set a few other options.
 if( plotter->GetPlotterType() == PLOT_FORMAT::GERBER )
 {
 GERBER_PLOTTER* gbrplotter = static_cast <GERBER_PLOTTER*> ( plotter );
 gbrplotter->DisableApertMacros( false );
 gbrplotter->UseX2format( true ); // Mandatory
 gbrplotter->UseX2NetAttributes( false ); // net attributes have no meaning here
 
 // Attributes are added using X2 format
 AddGerberX2Header( gbrplotter, m_pcb, false );
 
 wxString text;
 
 // Add the TF.FileFunction
 text = "%TF.FileFunction,Drillmap*%";
 gbrplotter->AddLineToHeader( text );
 
 // Add the TF.FilePolarity
 text = wxT( "%TF.FilePolarity,Positive*%" );
 gbrplotter->AddLineToHeader( text );
 }
 
 plotter->StartPlot( wxT( "1" ) );
 
 // Draw items on edge layer.
 // Not all, only items useful for drill map, i.e. board outlines.
 BRDITEMS_PLOTTER itemplotter( plotter, m_pcb, plot_opts );
 
 // Use attributes of a drawing layer (we are not really draw the Edge.Cuts layer)
 itemplotter.SetLayerSet( Dwgs_User );
 
 for( BOARD_ITEM* item : m_pcb->Drawings() )
 {
 if( item->GetLayer() != Edge_Cuts )
 continue;
 
 switch( item->Type() )
 {
 case PCB_SHAPE_T:
 {
 PCB_SHAPE dummy_shape( *static_cast<PCB_SHAPE*>( item ) );
 dummy_shape.SetLayer( Dwgs_User );
 itemplotter.PlotPcbShape( &dummy_shape );
 }
 break;
 
 default:
 break;
 }
 }
 
 int plotX, plotY, TextWidth;
 int intervalle = 0;
 char line[1024];
 wxString msg;
 int textmarginaftersymbol = pcbIUScale.mmToIU( 2 );
 
 // Set Drill Symbols width
 plotter->SetCurrentLineWidth( -1 );
 
 // Plot board outlines and drill map
 plotDrillMarks( plotter );
 
 // Print a list of symbols used.
 int charSize = pcbIUScale.mmToIU( 2 ); // text size in IUs
 
 // real char scale will be 1/scale, because the global plot scale is scale
 // for scale < 1.0 ( plot bigger actual size)
 // Therefore charScale = 1.0 / scale keep the initial charSize
 // (for scale < 1 we use the global scaling factor: the board must be plotted
 // smaller than the actual size)
 double charScale = std::min( 1.0, 1.0 / scale );
 
 TextWidth = KiROUND( ( charSize * charScale ) / 10.0 ); // Set text width (thickness)
 intervalle = KiROUND( charSize * charScale ) + TextWidth;
 
 // Trace information.
 plotX = KiROUND( bbbox.GetX() + textmarginaftersymbol * charScale );
 plotY = bbbox.GetBottom() + intervalle;
 
 // Plot title "Info"
 wxString Text = wxT( "Drill Map:" );
 
 TEXT_ATTRIBUTES attrs;
 attrs.m_StrokeWidth = TextWidth;
 attrs.m_Angle = ANGLE_HORIZONTAL;
 attrs.m_Size = VECTOR2I( KiROUND( charSize * charScale ), KiROUND( charSize * charScale ) );
 attrs.m_Halign = GR_TEXT_H_ALIGN_LEFT;
 attrs.m_Valign = GR_TEXT_V_ALIGN_CENTER;
 attrs.m_Multiline = false;
 
 plotter->PlotText( VECTOR2I( plotX, plotY ), COLOR4D::UNSPECIFIED, Text, attrs, nullptr /* stroke font */ );
 
 // For some formats (PS, PDF SVG) we plot the drill size list on more than one column
 // because the list must be contained inside the printed page
 // (others formats do not have a defined page size)
 int max_line_len = 0; // The max line len in iu of the currently plotted column
 
 for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
 {
 DRILL_TOOL& tool = m_toolListBuffer[ii];
 
 if( tool.m_TotalCount == 0 )
 continue;
 
 plotY += intervalle;
 
 // Ensure there are room to plot the line
 if( bottom_limit && ( plotY+intervalle > bottom_limit ) )
 {
 plotY = bbbox.GetBottom() + intervalle;
 plotX += max_line_len + pcbIUScale.mmToIU( 10 );//column_width;
 max_line_len = 0;
 }
 
 int plot_diam = KiROUND( tool.m_Diameter );
 
 // For markers plotted with the comment, keep marker size <= text height
 plot_diam = std::min( plot_diam, KiROUND( charSize * charScale ) );
 int x = KiROUND( plotX - textmarginaftersymbol * charScale - plot_diam / 2.0 );
 int y = KiROUND( plotY + charSize * charScale );
 
 plotter->SetCurrentLineWidth( getMarkerBestPenSize( plot_diam ) );
 plotter->Marker( VECTOR2I( x, y ), plot_diam, ii );
 plotter->SetCurrentLineWidth( -1 );
 
 // List the diameter of each drill in mm and inches.
 snprintf( line, sizeof(line), "%3.3fmm / %2.4f\" ", diameter_in_mm( tool.m_Diameter ),
 diameter_in_inches( tool.m_Diameter ) );
 
 msg = FROM_UTF8( line );
 
 // Now list how many holes and ovals are associated with each drill.
 if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
 snprintf( line, sizeof(line), "(1 hole)" );
 else if( tool.m_TotalCount == 1 ) // && ( toolm_OvalCount == 1 )
 snprintf( line, sizeof(line), "(1 slot)" );
 else if( tool.m_OvalCount == 0 )
 snprintf( line, sizeof(line), "(%d holes)", tool.m_TotalCount );
 else if( tool.m_OvalCount == 1 )
 snprintf( line, sizeof(line), "(%d holes + 1 slot)", tool.m_TotalCount - 1 );
 else // if ( toolm_OvalCount > 1 )
 snprintf( line, sizeof(line), "(%d holes + %d slots)", tool.m_TotalCount - tool.m_OvalCount,
 tool.m_OvalCount );
 
 msg += FROM_UTF8( line );
 
 if( tool.m_Hole_NotPlated )
 msg += wxT( " (not plated)" );
 
 plotter->PlotText( VECTOR2I( plotX, y ), COLOR4D::UNSPECIFIED, msg, attrs, nullptr /* stroke font */ );
 
 intervalle = KiROUND( ( ( charSize * charScale ) + TextWidth ) * 1.2 );
 
 if( intervalle < ( plot_diam + ( 1 * pcbIUScale.IU_PER_MM / scale ) + TextWidth ) )
 intervalle = plot_diam + ( 1 * pcbIUScale.IU_PER_MM / scale ) + TextWidth;
 
 // Evaluate the text horizontal size, to know the maximal column size
 // This is a rough value, but ok to create a new column to plot next texts
 int text_len = msg.Len() * ( ( charSize * charScale ) + TextWidth );
 max_line_len = std::max( max_line_len, text_len + plot_diam );
 }
 
 plotter->EndPlot();
 delete plotter;
 
 return true;
}

References PAGE_INFO::A4, AddGerberX2Header(), PLOTTER::AddLineToHeader(), ANGLE_HORIZONTAL, BOX2< Vec >::Centre(), PLOTTER::ClearHeaderLinesList(), diameter_in_inches(), diameter_in_mm(), GERBER_PLOTTER::DisableApertMacros(), BOARD::Drawings(), dummy, Dwgs_User, DXF, Edge_Cuts, PLOTTER::EndPlot(), FROM_UTF8(), GERBER, BOARD::GetBoardEdgesBoundingBox(), BOX2< Vec >::GetBottom(), BOX2< Vec >::GetHeight(), getMarkerBestPenSize(), GENDRILL_WRITER_BASE::GetOffset(), PLOTTER::GetPlotterType(), PAGE_INFO::GetSizeIU(), BOARD::GetVisibleLayers(), BOX2< Vec >::GetWidth(), BOX2< Vec >::GetX(), GR_TEXT_H_ALIGN_LEFT, GR_TEXT_V_ALIGN_CENTER, HPGL, INCHES, EDA_IU_SCALE::IU_PER_MILS, EDA_IU_SCALE::IU_PER_MM, KI_FALLTHROUGH, KiROUND(), TEXT_ATTRIBUTES::m_Angle, DRILL_TOOL::m_Diameter, TEXT_ATTRIBUTES::m_Halign, DRILL_TOOL::m_Hole_NotPlated, TEXT_ATTRIBUTES::m_Multiline, DRILL_TOOL::m_OvalCount, GENDRILL_WRITER_BASE::m_pageInfo, GENDRILL_WRITER_BASE::m_pcb, TEXT_ATTRIBUTES::m_Size, TEXT_ATTRIBUTES::m_StrokeWidth, GENDRILL_WRITER_BASE::m_toolListBuffer, DRILL_TOOL::m_TotalCount, GENDRILL_WRITER_BASE::m_unitsMetric, TEXT_ATTRIBUTES::m_Valign, PLOTTER::Marker(), MILLIMETERS, EDA_IU_SCALE::mmToIU(), PLOTTER::OpenFile(), PCB_SHAPE_T, pcbIUScale, PDF, GENDRILL_WRITER_BASE::plotDrillMarks(), BRDITEMS_PLOTTER::PlotPcbShape(), PLOTTER::PlotText(), POST, scale, PLOTTER::SetColorMode(), PLOTTER::SetCreator(), PLOTTER::SetCurrentLineWidth(), KIGFX::RENDER_SETTINGS::SetDefaultPenWidth(), PLOTTER::SetGerberCoordinatesFormat(), BOARD_ITEM::SetLayer(), BRDITEMS_PLOTTER::SetLayerSet(), PLOTTER::SetPageSettings(), PLOTTER::SetRenderSettings(), DXF_PLOTTER::SetUnits(), PLOTTER::SetViewport(), BOARD::SetVisibleLayers(), PLOTTER::StartPlot(), SVG, text, GERBER_PLOTTER::UseX2format(), GERBER_PLOTTER::UseX2NetAttributes(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by GENDRILL_WRITER_BASE::CreateMapFilesSet().

GenDrillReportFile()

bool GENDRILL_WRITER_BASE::GenDrillReportFile ( const wxString &  aFullFileName )

inherited

Create a plain text report file giving a list of drill values and drill count for through holes, oblong holes, and for buried vias, drill values and drill count per layer pair there is only one report for all drill files even when buried or blinds vias exist.

Here is a sample created by this function: Drill report for F:/tmp/interf_u/interf_u.brd Created on 04/10/2012 20:48:38 Selected Drill Unit: Imperial (inches)

Drill report for plated through holes : T1 0,025" 0,64mm (88 holes) T2 0,031" 0,79mm (120 holes) T3 0,032" 0,81mm (151 holes) (with 1 slot) T4 0,040" 1,02mm (43 holes) T5 0,079" 2,00mm (1 hole) (with 1 slot) T6 0,120" 3,05mm (1 hole) (with 1 slot)

Total plated holes count 404

Drill report for buried and blind vias :

Drill report for holes from layer Soudure to layer Interne1 :

Total plated holes count 0

Drill report for holes from layer Interne1 to layer Interne2 : T1 0,025" 0,64mm (3 holes) Total plated holes count 3 Drill report for holes from layer Interne2 to layer Composant : T1 0,025" 0,64mm (1 hole)

Total plated holes count 1

Drill report for unplated through holes : T1 0,120" 3,05mm (1 hole) (with 1 slot)

Total unplated holes count 1

Parameters

aFullFileName

is the name of the file to create.

Returns

true if the file is created.

Definition at line 357 of file gen_drill_report_files.cpp.

{
 FILE_OUTPUTFORMATTER out( aFullFileName );
 
 static const char separator[] =
 " =============================================================\n";
 
 wxASSERT( m_pcb );
 
 unsigned totalHoleCount;
 wxFileName brdFilename( m_pcb->GetFileName() );
 
 std::vector<DRILL_LAYER_PAIR> hole_sets = getUniqueLayerPairs();
 
 out.Print( 0, "Drill report for %s\n", TO_UTF8( brdFilename.GetFullName() ) );
 out.Print( 0, "Created on %s\n\n", TO_UTF8( DateAndTime() ) );
 
 // Output the cu layer stackup, so layer name references make sense.
 out.Print( 0, "Copper Layer Stackup:\n" );
 out.Print( 0, separator );
 
 LSET cu = m_pcb->GetEnabledLayers() & LSET::AllCuMask();
 
 int conventional_layer_num = 1;
 
 for( LSEQ seq = cu.Seq(); seq; ++seq, ++conventional_layer_num )
 {
 out.Print( 0, " L%-2d: %-25s %s\n",
 conventional_layer_num,
 TO_UTF8( m_pcb->GetLayerName( *seq ) ),
 layerName( *seq ).c_str() ); // generic layer name
 }
 
 out.Print( 0, "\n\n" );
 
 /* output hole lists:
 * 1 - through holes
 * 2 - for partial holes only: by layer starting and ending pair
 * 3 - Non Plated through holes
 */
 
 bool buildNPTHlist = false; // First pass: build PTH list only
 
 // in this loop are plated only:
 for( unsigned pair_ndx = 0; pair_ndx < hole_sets.size(); ++pair_ndx )
 {
 DRILL_LAYER_PAIR pair = hole_sets[pair_ndx];
 
 buildHolesList( pair, buildNPTHlist );
 
 if( pair == DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 {
 out.Print( 0, "Drill file '%s' contains\n",
 TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
 
 out.Print( 0, " plated through holes:\n" );
 out.Print( 0, separator );
 totalHoleCount = printToolSummary( out, false );
 out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
 }
 else // blind/buried
 {
 out.Print( 0, "Drill file '%s' contains\n",
 TO_UTF8( getDrillFileName( pair, false, m_merge_PTH_NPTH ) ) );
 
 out.Print( 0, " holes connecting layer pair: '%s and %s' (%s vias):\n",
 TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.first ) ) ),
 TO_UTF8( m_pcb->GetLayerName( ToLAYER_ID( pair.second ) ) ),
 pair.first == F_Cu || pair.second == B_Cu ? "blind" : "buried" );
 
 out.Print( 0, separator );
 totalHoleCount = printToolSummary( out, false );
 out.Print( 0, " Total plated holes count %u\n", totalHoleCount );
 }
 
 out.Print( 0, "\n\n" );
 }
 
 // NPTHoles. Generate the full list (pads+vias) if PTH and NPTH are merged,
 // or only the NPTH list (which never has vias)
 if( !m_merge_PTH_NPTH )
 buildNPTHlist = true;
 
 buildHolesList( DRILL_LAYER_PAIR( F_Cu, B_Cu ), buildNPTHlist );
 
 // nothing wrong with an empty NPTH file in report.
 if( m_merge_PTH_NPTH )
 out.Print( 0, "Not plated through holes are merged with plated holes\n" );
 else
 out.Print( 0, "Drill file '%s' contains\n",
 TO_UTF8( getDrillFileName( DRILL_LAYER_PAIR( F_Cu, B_Cu ),
 true, m_merge_PTH_NPTH ) ) );
 
 out.Print( 0, " unplated through holes:\n" );
 out.Print( 0, separator );
 totalHoleCount = printToolSummary( out, true );
 out.Print( 0, " Total unplated holes count %u\n", totalHoleCount );
 
 return true;
}

References LSET::AllCuMask(), B_Cu, GENDRILL_WRITER_BASE::buildHolesList(), DateAndTime(), F_Cu, GENDRILL_WRITER_BASE::getDrillFileName(), BOARD::GetEnabledLayers(), BOARD::GetFileName(), BOARD::GetLayerName(), GENDRILL_WRITER_BASE::getUniqueLayerPairs(), GENDRILL_WRITER_BASE::layerName(), GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, GENDRILL_WRITER_BASE::m_pcb, OUTPUTFORMATTER::Print(), GENDRILL_WRITER_BASE::printToolSummary(), LSET::Seq(), TO_UTF8, and ToLAYER_ID().

Referenced by DIALOG_GENDRILL::OnGenReportFile().

GetDrillFileExt()

wxString GENDRILL_WRITER_BASE::GetDrillFileExt ( ) const

inlineinherited

Returns the file extension of the drill writer format.

Definition at line 270 of file gendrill_file_writer_base.h.

{ return m_drillFileExtension; }

References GENDRILL_WRITER_BASE::m_drillFileExtension.

getDrillFileName()

const wxString GERBER_WRITER::getDrillFileName ( DRILL_LAYER_PAIR  aPair, bool  aNPTH, bool  aMerge_PTH_NPTH  ) const

overrideprivatevirtual

Parameters

aPair	is the layer pair.
aNPTH	set to true to generate the filename of NPTH holes.
aMerge_PTH_NPTH	set to true to generate the filename of a file which contains both NPH and NPTH holes

Returns

a filename which identify the drill file function. It is the board name with the layer pair names added, and for separate (PTH and NPTH) files, "-NPH" or "-NPTH" added.

Reimplemented from GENDRILL_WRITER_BASE.

Definition at line 299 of file gendrill_gerber_writer.cpp.

{
 // Gerber files extension is always .gbr.
 // Therefore, to mark drill files, add "-drl" to the filename.
 wxFileName fname( GENDRILL_WRITER_BASE::getDrillFileName( aPair, aNPTH, aMerge_PTH_NPTH ) );
 fname.SetName( fname.GetName() + wxT( "-drl" ) );
 
 return fname.GetFullPath();
}

References GENDRILL_WRITER_BASE::getDrillFileName().

Referenced by CreateDrillandMapFilesSet().

getHolesCount()

int GENDRILL_WRITER_BASE::getHolesCount ( ) const

inlineprotectedinherited

Definition at line 300 of file gendrill_file_writer_base.h.

{ return m_holeListBuffer.size(); }

References GENDRILL_WRITER_BASE::m_holeListBuffer.

Referenced by EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateDrillandMapFilesSet(), and GENDRILL_WRITER_BASE::CreateMapFilesSet().

GetOffset()

VECTOR2I GENDRILL_WRITER_BASE::GetOffset ( )

inlineinherited

Return the plot offset (usually the position of the drill/place origin).

Definition at line 183 of file gendrill_file_writer_base.h.

{ return m_offset; }

References GENDRILL_WRITER_BASE::m_offset.

Referenced by GENDRILL_WRITER_BASE::genDrillMapFile().

getUniqueLayerPairs()

std::vector< DRILL_LAYER_PAIR > GENDRILL_WRITER_BASE::getUniqueLayerPairs ( ) const

protectedinherited

Get unique layer pairs by examining the micro and blind_buried vias.

Definition at line 210 of file gendrill_file_writer_base.cpp.

{
 wxASSERT( m_pcb );
 
 PCB_TYPE_COLLECTOR vias;
 
 vias.Collect( m_pcb, { PCB_VIA_T } );
 
 std::set<DRILL_LAYER_PAIR> unique;
 DRILL_LAYER_PAIR layer_pair;
 
 for( int i = 0; i < vias.GetCount(); ++i )
 {
 PCB_VIA* v = static_cast<PCB_VIA*>( vias[i] );
 
 v->LayerPair( &layer_pair.first, &layer_pair.second );
 
 // only make note of blind buried.
 // thru hole is placed unconditionally as first in fetched list.
 if( layer_pair != DRILL_LAYER_PAIR( F_Cu, B_Cu ) )
 unique.insert( layer_pair );
 }
 
 std::vector<DRILL_LAYER_PAIR> ret;
 
 ret.emplace_back( F_Cu, B_Cu ); // always first in returned list
 
 for( const DRILL_LAYER_PAIR& pair : unique )
 ret.push_back( pair );
 
 return ret;
}

References B_Cu, PCB_TYPE_COLLECTOR::Collect(), F_Cu, COLLECTOR::GetCount(), PCB_VIA::LayerPair(), GENDRILL_WRITER_BASE::m_pcb, and PCB_VIA_T.

Referenced by EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateDrillandMapFilesSet(), GENDRILL_WRITER_BASE::CreateMapFilesSet(), and GENDRILL_WRITER_BASE::GenDrillReportFile().

layerName()

const std::string GENDRILL_WRITER_BASE::layerName ( PCB_LAYER_ID  aLayer ) const

protectedinherited

Returns

a string from aLayer to identify the layer. string are "front" "back" or "in<aLayer>"

Definition at line 244 of file gendrill_file_writer_base.cpp.

{
 // Generic names here.
 switch( aLayer )
 {
 case F_Cu:
 return "front";
 case B_Cu:
 return "back";
 default:
 return StrPrintf( "in%d", aLayer );
 }
}

References B_Cu, F_Cu, and StrPrintf().

Referenced by GENDRILL_WRITER_BASE::GenDrillReportFile(), and GENDRILL_WRITER_BASE::layerPairName().

layerPairName()

const std::string GENDRILL_WRITER_BASE::layerPairName ( DRILL_LAYER_PAIR  aPair ) const

protectedinherited

Returns

a string from aPair to identify the layer layer pair. string is "<layer1Name>"-"<layer2Name>" used to generate a filename for drill files and drill maps

Definition at line 259 of file gendrill_file_writer_base.cpp.

{
 std::string ret = layerName( aPair.first );
 ret += '-';
 ret += layerName( aPair.second );
 
 return ret;
}

References GENDRILL_WRITER_BASE::layerName().

Referenced by GENDRILL_WRITER_BASE::getDrillFileName().

plotDrillMarks()

bool GENDRILL_WRITER_BASE::plotDrillMarks ( PLOTTER *  aPlotter )

protectedinherited

Write the drill marks in HPGL, POSTSCRIPT or other supported formats/.

Each hole size has a symbol (circle, cross X, cross + ...) up to PLOTTER::MARKER_COUNT different values. If more than PLOTTER::MARKER_COUNT different values, these other values share the same mark shape.

Parameters

aPlotter

is a PLOTTER instance (HPGL, POSTSCRIPT ... plotter).

Definition at line 459 of file gen_drill_report_files.cpp.

{
 // Plot the drill map:
 VECTOR2I pos;
 
 for( unsigned ii = 0; ii < m_holeListBuffer.size(); ii++ )
 {
 const HOLE_INFO& hole = m_holeListBuffer[ii];
 pos = hole.m_Hole_Pos;
 
 // Gives a good line thickness to have a good marker shape:
 aPlotter->SetCurrentLineWidth( getMarkerBestPenSize( hole.m_Hole_Diameter ) );
 
 // Always plot the drill symbol (for slots identifies the needed cutter!
 aPlotter->Marker( pos, hole.m_Hole_Diameter, hole.m_Tool_Reference - 1 );
 
 if( hole.m_Hole_Shape != 0 )
 aPlotter->FlashPadOval( pos, hole.m_Hole_Size, hole.m_Hole_Orient, SKETCH, nullptr );
 }
 
 aPlotter->SetCurrentLineWidth( -1 );
 
 return true;
}

References PLOTTER::FlashPadOval(), getMarkerBestPenSize(), HOLE_INFO::m_Hole_Diameter, HOLE_INFO::m_Hole_Orient, HOLE_INFO::m_Hole_Pos, HOLE_INFO::m_Hole_Shape, HOLE_INFO::m_Hole_Size, GENDRILL_WRITER_BASE::m_holeListBuffer, HOLE_INFO::m_Tool_Reference, PLOTTER::Marker(), PLOTTER::SetCurrentLineWidth(), and SKETCH.

Referenced by GENDRILL_WRITER_BASE::genDrillMapFile().

printToolSummary()

unsigned GENDRILL_WRITER_BASE::printToolSummary ( OUTPUTFORMATTER &  aOut, bool  aSummaryNPTH  ) const

protectedinherited

Print m_toolListBuffer[] tools to aOut and returns total hole count.

Parameters

aOut	is the current OUTPUTFORMATTER to print summary.
aSummaryNPTH	is true to print summary for NPTH, false for PTH.

Definition at line 485 of file gen_drill_report_files.cpp.

{
 unsigned totalHoleCount = 0;
 
 for( unsigned ii = 0; ii < m_toolListBuffer.size(); ii++ )
 {
 const DRILL_TOOL& tool = m_toolListBuffer[ii];
 
 if( aSummaryNPTH && !tool.m_Hole_NotPlated )
 continue;
 
 if( !aSummaryNPTH && tool.m_Hole_NotPlated )
 continue;
 
 // List the tool number assigned to each drill in mm then in inches.
 int tool_number = ii+1;
 out.Print( 0, " T%d %2.3fmm %2.4f\" ", tool_number,
 diameter_in_mm( tool.m_Diameter ),
 diameter_in_inches( tool.m_Diameter ) );
 
 // Now list how many holes and ovals are associated with each drill.
 if( ( tool.m_TotalCount == 1 ) && ( tool.m_OvalCount == 0 ) )
 out.Print( 0, "(1 hole)\n" );
 else if( tool.m_TotalCount == 1 )
 out.Print( 0, "(1 hole) (with 1 slot)\n" );
 else if( tool.m_OvalCount == 0 )
 out.Print( 0, "(%d holes)\n", tool.m_TotalCount );
 else if( tool.m_OvalCount == 1 )
 out.Print( 0, "(%d holes) (with 1 slot)\n", tool.m_TotalCount );
 else // tool.m_OvalCount > 1
 out.Print( 0, "(%d holes) (with %d slots)\n", tool.m_TotalCount, tool.m_OvalCount );
 
 totalHoleCount += tool.m_TotalCount;
 }
 
 out.Print( 0, "\n" );
 
 return totalHoleCount;
}

References diameter_in_inches(), diameter_in_mm(), DRILL_TOOL::m_Diameter, DRILL_TOOL::m_Hole_NotPlated, DRILL_TOOL::m_OvalCount, GENDRILL_WRITER_BASE::m_toolListBuffer, DRILL_TOOL::m_TotalCount, and OUTPUTFORMATTER::Print().

Referenced by GENDRILL_WRITER_BASE::GenDrillReportFile().

SetFormat()

void GERBER_WRITER::SetFormat

(

int

aRightDigits = 6

)

Initialize internal parameters to match the given format.

Parameters

aRightDigits

is the number of digits for mantissa part of coordinates (5 or 6).

Definition at line 288 of file gendrill_gerber_writer.cpp.

{
 /* Set conversion scale depending on drill file units */
 m_conversionUnits = 1.0 / pcbIUScale.IU_PER_MM; // Gerber units = mm
 
 // Set precision (unit is mm).
 m_precision.m_Lhs = 4;
 m_precision.m_Rhs = aRightDigits == 6 ? 6 : 5;
}

References EDA_IU_SCALE::IU_PER_MM, GENDRILL_WRITER_BASE::m_conversionUnits, DRILL_PRECISION::m_Lhs, GENDRILL_WRITER_BASE::m_precision, DRILL_PRECISION::m_Rhs, and pcbIUScale.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

SetMapFileFormat()

void GENDRILL_WRITER_BASE::SetMapFileFormat ( PLOT_FORMAT  aMapFmt )

inlineinherited

Initialize the format for the drill map file.

Parameters

aMapFmt

a PlotFormat value (one of PLOT_FORMAT_HPGL, PLOT_FORMAT_POST, PLOT_FORMAT_GERBER, PLOT_FORMAT_DXF, PLOT_FORMAT_SVG, PLOT_FORMAT_PDF the most useful are PLOT_FORMAT_PDF and PLOT_FORMAT_POST.

Definition at line 201 of file gendrill_file_writer_base.h.

 {
 m_mapFileFmt = aMapFmt;
 }

References GENDRILL_WRITER_BASE::m_mapFileFmt.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

SetMergeOption()

void GENDRILL_WRITER_BASE::SetMergeOption ( bool  aMerge )

inlineinherited

Set the option to make separate drill files for PTH and NPTH.

Parameters

aMerge

set to true to make only one file containing PTH and NPTH or false to create 2 separate files.

Definition at line 178 of file gendrill_file_writer_base.h.

{ m_merge_PTH_NPTH = aMerge; }

References GENDRILL_WRITER_BASE::m_merge_PTH_NPTH.

Referenced by DIALOG_GENDRILL::OnGenReportFile().

SetOptions()

void GERBER_WRITER::SetOptions ( const VECTOR2I &  aOffset )

inline

Initialize internal parameters to match drill options.

Note

PTH and NPTH are always separate files in Gerber format.

Parameters

aOffset

is the drill coordinates offset.

Definition at line 63 of file gendrill_gerber_writer.h.

 {
 m_offset = aOffset;
 m_merge_PTH_NPTH = false;
 }

References GENDRILL_WRITER_BASE::m_merge_PTH_NPTH, and GENDRILL_WRITER_BASE::m_offset.

Referenced by DIALOG_GENDRILL::GenDrillAndMapFiles(), and PCBNEW_JOBS_HANDLER::JobExportDrill().

SetPageInfo()

void GENDRILL_WRITER_BASE::SetPageInfo ( const PAGE_INFO *  aPageInfo )

inlineinherited

Set the page info used to plot drill maps.

If NULL, a A4 page format will be used.

Parameters

aPageInfo

is a reference to the page info, usually used to plot/display the board.

Definition at line 192 of file gendrill_file_writer_base.h.

{ m_pageInfo = aPageInfo; }

References GENDRILL_WRITER_BASE::m_pageInfo.

Member Data Documentation

m_conversionUnits

double GENDRILL_WRITER_BASE::m_conversionUnits

protectedinherited

Definition at line 385 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::createDrillFile(), EXCELLON_WRITER::EXCELLON_WRITER(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GERBER_WRITER(), EXCELLON_WRITER::SetFormat(), and SetFormat().

m_drillFileExtension

wxString GENDRILL_WRITER_BASE::m_drillFileExtension

protectedinherited

Definition at line 380 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::EXCELLON_WRITER(), GERBER_WRITER(), GENDRILL_WRITER_BASE::GetDrillFileExt(), and GENDRILL_WRITER_BASE::getDrillFileName().

m_holeListBuffer

std::vector<HOLE_INFO> GENDRILL_WRITER_BASE::m_holeListBuffer

protectedinherited

Definition at line 390 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString(), GENDRILL_WRITER_BASE::buildHolesList(), EXCELLON_WRITER::createDrillFile(), createDrillFile(), GENDRILL_WRITER_BASE::getHolesCount(), and GENDRILL_WRITER_BASE::plotDrillMarks().

m_mapFileFmt

PLOT_FORMAT GENDRILL_WRITER_BASE::m_mapFileFmt

protectedinherited

Definition at line 393 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::CreateMapFilesSet(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), and GENDRILL_WRITER_BASE::SetMapFileFormat().

m_merge_PTH_NPTH

bool GENDRILL_WRITER_BASE::m_merge_PTH_NPTH

protectedinherited

Definition at line 389 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::buildHolesList(), EXCELLON_WRITER::CreateDrillandMapFilesSet(), CreateDrillandMapFilesSet(), GENDRILL_WRITER_BASE::CreateMapFilesSet(), EXCELLON_WRITER::EXCELLON_WRITER(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GENDRILL_WRITER_BASE::GenDrillReportFile(), GERBER_WRITER(), GENDRILL_WRITER_BASE::SetMergeOption(), EXCELLON_WRITER::SetOptions(), and SetOptions().

m_offset

VECTOR2I GENDRILL_WRITER_BASE::m_offset

protectedinherited

Definition at line 388 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::createDrillFile(), createDrillFile(), EXCELLON_WRITER::GetOffset(), GENDRILL_WRITER_BASE::GetOffset(), EXCELLON_WRITER::SetOptions(), and SetOptions().

m_pageInfo

const PAGE_INFO* GENDRILL_WRITER_BASE::m_pageInfo

protectedinherited

Definition at line 395 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GENDRILL_WRITER_BASE::genDrillMapFile(), and GENDRILL_WRITER_BASE::SetPageInfo().

m_pcb

BOARD* GENDRILL_WRITER_BASE::m_pcb

protectedinherited

Definition at line 379 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::BuildFileFunctionAttributeString(), GENDRILL_WRITER_BASE::buildHolesList(), createDrillFile(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GENDRILL_WRITER_BASE::genDrillMapFile(), GENDRILL_WRITER_BASE::GenDrillReportFile(), GENDRILL_WRITER_BASE::getDrillFileName(), and GENDRILL_WRITER_BASE::getUniqueLayerPairs().

m_precision

DRILL_PRECISION GENDRILL_WRITER_BASE::m_precision

protectedinherited

Definition at line 383 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::SetFormat(), SetFormat(), EXCELLON_WRITER::writeCoordinates(), and EXCELLON_WRITER::writeEXCELLONHeader().

m_toolListBuffer

std::vector<DRILL_TOOL> GENDRILL_WRITER_BASE::m_toolListBuffer

protectedinherited

Definition at line 391 of file gendrill_file_writer_base.h.

Referenced by GENDRILL_WRITER_BASE::buildHolesList(), EXCELLON_WRITER::createDrillFile(), GENDRILL_WRITER_BASE::genDrillMapFile(), and GENDRILL_WRITER_BASE::printToolSummary().

m_unitsMetric

bool GENDRILL_WRITER_BASE::m_unitsMetric

protectedinherited

Definition at line 381 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::createDrillFile(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GENDRILL_WRITER_BASE::genDrillMapFile(), GERBER_WRITER(), EXCELLON_WRITER::SetFormat(), EXCELLON_WRITER::writeCoordinates(), and EXCELLON_WRITER::writeEXCELLONHeader().

m_zeroFormat

ZEROS_FMT GENDRILL_WRITER_BASE::m_zeroFormat

protectedinherited

Definition at line 382 of file gendrill_file_writer_base.h.

Referenced by EXCELLON_WRITER::EXCELLON_WRITER(), GENDRILL_WRITER_BASE::GENDRILL_WRITER_BASE(), GERBER_WRITER(), EXCELLON_WRITER::SetFormat(), EXCELLON_WRITER::writeCoordinates(), and EXCELLON_WRITER::writeEXCELLONHeader().

---

The documentation for this class was generated from the following files:

• gendrill_gerber_writer.h
• gendrill_gerber_writer.cpp