KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcbnew_jobs_handler.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2022 Mark Roszko <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include <wx/dir.h>
22#include "pcbnew_jobs_handler.h"
23#include <board_commit.h>
24#include <board_design_settings.h>
25#include <drc/drc_item.h>
26#include <drc/drc_report.h>
27#include <drawing_sheet/ds_data_model.h>
28#include <drawing_sheet/ds_proxy_view_item.h>
29#include <jobs/job_fp_export_svg.h>
30#include <jobs/job_fp_upgrade.h>
31#include <jobs/job_export_pcb_ipc2581.h>
32#include <jobs/job_export_pcb_ipcd356.h>
33#include <jobs/job_export_pcb_odb.h>
34#include <jobs/job_export_pcb_gerber.h>
35#include <jobs/job_export_pcb_gerbers.h>
36#include <jobs/job_export_pcb_hpgl.h>
37#include <jobs/job_export_pcb_drill.h>
38#include <jobs/job_export_pcb_dxf.h>
39#include <jobs/job_export_pcb_gencad.h>
40#include <jobs/job_export_pcb_pdf.h>
41#include <jobs/job_export_pcb_pos.h>
42#include <jobs/job_export_pcb_ps.h>
43#include <jobs/job_export_pcb_svg.h>
44#include <jobs/job_export_pcb_3d.h>
45#include <jobs/job_pcb_render.h>
46#include <jobs/job_pcb_drc.h>
47#include <lset.h>
48#include <cli/exit_codes.h>
49#include <exporters/place_file_exporter.h>
50#include <exporters/step/exporter_step.h>
51#include <plotters/plotter_dxf.h>
52#include <plotters/plotter_gerber.h>
53#include <plotters/plotters_pslike.h>
54#include <tool/tool_manager.h>
55#include <tools/drc_tool.h>
56#include <filename_resolver.h>
57#include <gerber_jobfile_writer.h>
58#include "gerber_placefile_writer.h"
59#include <gendrill_Excellon_writer.h>
60#include <gendrill_gerber_writer.h>
61#include <kiface_base.h>
62#include <macros.h>
63#include <pad.h>
64#include <pcb_marker.h>
65#include <project/project_file.h>
66#include <exporters/export_gencad_writer.h>
67#include <exporters/export_d356.h>
68#include <kiface_ids.h>
69#include <netlist_reader/pcb_netlist.h>
70#include <netlist_reader/netlist_reader.h>
71#include <pcbnew_settings.h>
72#include <pcbplot.h>
73#include <pcb_plotter.h>
74#include <pgm_base.h>
75#include <3d_rendering/raytracing/render_3d_raytrace_ram.h>
76#include <3d_rendering/track_ball.h>
77#include <project_pcb.h>
78#include <pcb_io/kicad_sexpr/pcb_io_kicad_sexpr.h>
79#include <reporter.h>
80#include <progress_reporter.h>
81#include <wildcards_and_files_ext.h>
82#include <export_vrml.h>
83#include <wx/wfstream.h>
84#include <wx/zipstrm.h>
85#include <settings/settings_manager.h>
86#include <dialogs/dialog_gendrill.h>
87#include <dialogs/dialog_gen_footprint_position.h>
88#include <dialogs/dialog_export_2581.h>
89#include <dialogs/dialog_export_odbpp.h>
90#include <dialogs/dialog_export_step.h>
91#include <dialogs/dialog_plot.h>
92#include <dialogs/dialog_drc_job_config.h>
93#include <dialogs/dialog_render_job.h>
94#include <dialogs/dialog_gencad_export_options.h>
95#include <paths.h>
96
97#include "pcbnew_scripting_helpers.h"
98#include <locale_io.h>
99#include <confirm.h>
100
101
102#ifdef _WIN32
103#ifdef TRANSPARENT
104#undef TRANSPARENT
105#endif
106#endif
107
108
109PCBNEW_JOBS_HANDLER::PCBNEW_JOBS_HANDLER( KIWAY* aKiway ) :
110 JOB_DISPATCHER( aKiway ),
111 m_cliBoard( nullptr )
112{
113 Register( "3d", std::bind( &PCBNEW_JOBS_HANDLER::JobExportStep, this, std::placeholders::_1 ),
114 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
115 {
116 JOB_EXPORT_PCB_3D* svgJob = dynamic_cast<JOB_EXPORT_PCB_3D*>( job );
117
118 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
119 false ) );
120
121 wxCHECK( svgJob && editFrame, false );
122
123 DIALOG_EXPORT_STEP dlg( editFrame, aParent, "", svgJob );
124 return dlg.ShowModal() == wxID_OK;
125 } );
126 Register( "render",
127 std::bind( &PCBNEW_JOBS_HANDLER::JobExportRender, this, std::placeholders::_1 ),
128 []( JOB* job, wxWindow* aParent ) -> bool
129 {
130 JOB_PCB_RENDER* renderJob = dynamic_cast<JOB_PCB_RENDER*>( job );
131
132 wxCHECK( renderJob, false );
133
134 DIALOG_RENDER_JOB dlg( aParent, renderJob );
135 return dlg.ShowModal() == wxID_OK;
136 } );
137 Register( "svg", std::bind( &PCBNEW_JOBS_HANDLER::JobExportSvg, this, std::placeholders::_1 ),
138 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
139 {
140 JOB_EXPORT_PCB_SVG* svgJob = dynamic_cast<JOB_EXPORT_PCB_SVG*>( job );
141
142 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
143 false ) );
144
145 wxCHECK( svgJob && editFrame, false );
146
147 DIALOG_PLOT dlg( editFrame, aParent, svgJob );
148 return dlg.ShowModal() == wxID_OK;
149 } );
150 Register( "gencad",
151 std::bind( &PCBNEW_JOBS_HANDLER::JobExportGencad, this, std::placeholders::_1 ),
152 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
153 {
154 JOB_EXPORT_PCB_GENCAD* gencadJob = dynamic_cast<JOB_EXPORT_PCB_GENCAD*>( job );
155
156 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
157 false ) );
158
159 wxCHECK( gencadJob && editFrame, false );
160
161 DIALOG_GENCAD_EXPORT_OPTIONS dlg( editFrame, gencadJob );
162 return dlg.ShowModal() == wxID_OK;
163 } );
164 Register( "dxf", std::bind( &PCBNEW_JOBS_HANDLER::JobExportDxf, this, std::placeholders::_1 ),
165 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
166 {
167 JOB_EXPORT_PCB_DXF* dxfJob = dynamic_cast<JOB_EXPORT_PCB_DXF*>( job );
168
169 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
170 false ) );
171
172 wxCHECK( dxfJob && editFrame, false );
173
174 DIALOG_PLOT dlg( editFrame, aParent, dxfJob );
175 return dlg.ShowModal() == wxID_OK;
176 } );
177 Register( "pdf", std::bind( &PCBNEW_JOBS_HANDLER::JobExportPdf, this, std::placeholders::_1 ),
178 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
179 {
180 JOB_EXPORT_PCB_PDF* pdfJob = dynamic_cast<JOB_EXPORT_PCB_PDF*>( job );
181
182 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
183 false ) );
184
185 wxCHECK( pdfJob && editFrame, false );
186
187 DIALOG_PLOT dlg( editFrame, aParent, pdfJob );
188 return dlg.ShowModal() == wxID_OK;
189 } );
190 Register( "ps", std::bind( &PCBNEW_JOBS_HANDLER::JobExportPs, this, std::placeholders::_1 ),
191 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
192 {
193 JOB_EXPORT_PCB_PS* psJob = dynamic_cast<JOB_EXPORT_PCB_PS*>( job );
194
195 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
196 false ) );
197
198 wxCHECK( psJob && editFrame, false );
199
200 DIALOG_PLOT dlg( editFrame, aParent, psJob );
201 return dlg.ShowModal() == wxID_OK;
202 } );
203 Register( "gerber",
204 std::bind( &PCBNEW_JOBS_HANDLER::JobExportGerber, this, std::placeholders::_1 ),
205 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
206 {
207 JOB_EXPORT_PCB_GERBER* gJob = dynamic_cast<JOB_EXPORT_PCB_GERBER*>( job );
208
209 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
210 false ) );
211
212 wxCHECK( gJob && editFrame, false );
213
214 DIALOG_PLOT dlg( editFrame, aParent, gJob );
215 return dlg.ShowModal() == wxID_OK;
216 } );
217 Register( "gerbers",
218 std::bind( &PCBNEW_JOBS_HANDLER::JobExportGerbers, this, std::placeholders::_1 ),
219 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
220 {
221 JOB_EXPORT_PCB_GERBERS* gJob = dynamic_cast<JOB_EXPORT_PCB_GERBERS*>( job );
222
223 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
224 false ) );
225
226 wxCHECK( gJob && editFrame, false );
227
228 DIALOG_PLOT dlg( editFrame, aParent, gJob );
229 return dlg.ShowModal() == wxID_OK;
230 } );
231 Register( "hpgl",
232 [&]( JOB* aJob )
233 {
234 m_reporter->Report( _( "Plotting to HPGL is no longer supported as of KiCad 10.0.\n" ),
235 RPT_SEVERITY_ERROR );
236 return CLI::EXIT_CODES::ERR_ARGS;
237 },
238 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
239 {
240 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
241 false ) );
242
243 wxCHECK( editFrame, false );
244
245 DisplayErrorMessage( editFrame,
246 _( "Plotting to HPGL is no longer supported as of KiCad 10.0." ) );
247 return false;
248 } );
249 Register( "drill",
250 std::bind( &PCBNEW_JOBS_HANDLER::JobExportDrill, this, std::placeholders::_1 ),
251 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
252 {
253 JOB_EXPORT_PCB_DRILL* drillJob = dynamic_cast<JOB_EXPORT_PCB_DRILL*>( job );
254
255 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
256 false ) );
257
258 wxCHECK( drillJob && editFrame, false );
259
260 DIALOG_GENDRILL dlg( editFrame, drillJob, aParent );
261 return dlg.ShowModal() == wxID_OK;
262 } );
263 Register( "pos", std::bind( &PCBNEW_JOBS_HANDLER::JobExportPos, this, std::placeholders::_1 ),
264 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
265 {
266 JOB_EXPORT_PCB_POS* posJob = dynamic_cast<JOB_EXPORT_PCB_POS*>( job );
267
268 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
269 false ) );
270
271 wxCHECK( posJob && editFrame, false );
272
273 DIALOG_GEN_FOOTPRINT_POSITION dlg( posJob, editFrame, aParent );
274 return dlg.ShowModal() == wxID_OK;
275 } );
276 Register( "fpupgrade",
277 std::bind( &PCBNEW_JOBS_HANDLER::JobExportFpUpgrade, this, std::placeholders::_1 ),
278 []( JOB* job, wxWindow* aParent ) -> bool
279 {
280 return true;
281 } );
282 Register( "fpsvg",
283 std::bind( &PCBNEW_JOBS_HANDLER::JobExportFpSvg, this, std::placeholders::_1 ),
284 []( JOB* job, wxWindow* aParent ) -> bool
285 {
286 return true;
287 } );
288 Register( "drc", std::bind( &PCBNEW_JOBS_HANDLER::JobExportDrc, this, std::placeholders::_1 ),
289 []( JOB* job, wxWindow* aParent ) -> bool
290 {
291 JOB_PCB_DRC* drcJob = dynamic_cast<JOB_PCB_DRC*>( job );
292
293 wxCHECK( drcJob, false );
294
295 DIALOG_DRC_JOB_CONFIG dlg( aParent, drcJob );
296 return dlg.ShowModal() == wxID_OK;
297 } );
298 Register( "ipc2581",
299 std::bind( &PCBNEW_JOBS_HANDLER::JobExportIpc2581, this, std::placeholders::_1 ),
300 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
301 {
302 JOB_EXPORT_PCB_IPC2581* ipcJob = dynamic_cast<JOB_EXPORT_PCB_IPC2581*>( job );
303
304 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
305 false ) );
306
307 wxCHECK( ipcJob && editFrame, false );
308
309 DIALOG_EXPORT_2581 dlg( ipcJob, editFrame, aParent );
310 return dlg.ShowModal() == wxID_OK;
311 } );
312 Register( "ipcd356",
313 std::bind( &PCBNEW_JOBS_HANDLER::JobExportIpcD356, this, std::placeholders::_1 ),
314 []( JOB* job, wxWindow* aParent ) -> bool
315 {
316 return true;
317 } );
318 Register( "odb",
319 std::bind( &PCBNEW_JOBS_HANDLER::JobExportOdb, this, std::placeholders::_1 ),
320 [aKiway]( JOB* job, wxWindow* aParent ) -> bool
321 {
322 JOB_EXPORT_PCB_ODB* odbJob = dynamic_cast<JOB_EXPORT_PCB_ODB*>( job );
323
324 PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( aKiway->Player( FRAME_PCB_EDITOR,
325 false ) );
326
327 wxCHECK( odbJob && editFrame, false );
328
329 DIALOG_EXPORT_ODBPP dlg( odbJob, editFrame, aParent );
330 return dlg.ShowModal() == wxID_OK;
331 } );
332}
333
334
335BOARD* PCBNEW_JOBS_HANDLER::getBoard( const wxString& aPath )
336{
337 BOARD* brd = nullptr;
338
339 if( !Pgm().IsGUI() && Pgm().GetSettingsManager().IsProjectOpen() )
340 {
341 wxString pcbPath = aPath;
342
343 if( pcbPath.IsEmpty() )
344 {
345 wxFileName path = Pgm().GetSettingsManager().Prj().GetProjectFullName();
346 path.SetExt( FILEEXT::KiCadPcbFileExtension );
347 path.MakeAbsolute();
348 pcbPath = path.GetFullPath();
349 }
350
351 if( !m_cliBoard )
352 m_cliBoard = LoadBoard( pcbPath, true );
353
354 brd = m_cliBoard;
355 }
356 else if( Pgm().IsGUI() && Pgm().GetSettingsManager().IsProjectOpen() )
357 {
358 PCB_EDIT_FRAME* editFrame = (PCB_EDIT_FRAME*) m_kiway->Player( FRAME_PCB_EDITOR, false );
359
360 if( editFrame )
361 brd = editFrame->GetBoard();
362 }
363 else
364 {
365 brd = LoadBoard( aPath, true );
366 }
367
368 if( !brd )
369 m_reporter->Report( _( "Failed to load board\n" ), RPT_SEVERITY_ERROR );
370
371 return brd;
372}
373
374
375LSEQ PCBNEW_JOBS_HANDLER::convertLayerArg( wxString& aLayerString, BOARD* aBoard ) const
376{
377 std::map<wxString, LSET> layerUserMasks;
378 std::map<wxString, LSET> layerMasks;
379 std::map<wxString, LSET> layerGuiMasks;
380
381 // Build list of layer names and their layer mask:
382 for( PCB_LAYER_ID layer : LSET::AllLayersMask().Seq() )
383 {
384 // Add user layer name
385 if( aBoard )
386 layerUserMasks[ aBoard->GetLayerName( layer ) ] = LSET( { layer } );
387
388 // Add layer name used in pcb files
389 layerMasks[ LSET::Name( layer ) ] = LSET( { layer } );
390 // Add layer name using GUI canonical layer name
391 layerGuiMasks[ LayerName( layer ) ] = LSET( { layer } );
392 }
393
394 // Add list of grouped layer names used in pcb files
395 layerMasks[ wxT( "*" ) ] = LSET::AllLayersMask();
396 layerMasks[ wxT( "*.Cu" ) ] = LSET::AllCuMask();
397 layerMasks[ wxT( "*In.Cu" ) ] = LSET::InternalCuMask();
398 layerMasks[ wxT( "F&B.Cu" ) ] = LSET( { F_Cu, B_Cu } );
399 layerMasks[ wxT( "*.Adhes" ) ] = LSET( { B_Adhes, F_Adhes } );
400 layerMasks[ wxT( "*.Paste" ) ] = LSET( { B_Paste, F_Paste } );
401 layerMasks[ wxT( "*.Mask" ) ] = LSET( { B_Mask, F_Mask } );
402 layerMasks[ wxT( "*.SilkS" ) ] = LSET( { B_SilkS, F_SilkS } );
403 layerMasks[ wxT( "*.Fab" ) ] = LSET( { B_Fab, F_Fab } );
404 layerMasks[ wxT( "*.CrtYd" ) ] = LSET( { B_CrtYd, F_CrtYd } );
405
406 // Add list of grouped layer names using GUI canonical layer names
407 layerGuiMasks[ wxT( "*.Adhesive" ) ] = LSET( { B_Adhes, F_Adhes } );
408 layerGuiMasks[ wxT( "*.Silkscreen" ) ] = LSET( { B_SilkS, F_SilkS } );
409 layerGuiMasks[ wxT( "*.Courtyard" ) ] = LSET( { B_CrtYd, F_CrtYd } );
410
411 LSEQ layerMask;
412
413 auto pushLayers =
414 [&]( const LSET& layerSet )
415 {
416 for( PCB_LAYER_ID layer : layerSet.Seq() )
417 layerMask.push_back( layer );
418 };
419
420 if( !aLayerString.IsEmpty() )
421 {
422 wxStringTokenizer layerTokens( aLayerString, "," );
423
424 while( layerTokens.HasMoreTokens() )
425 {
426 std::string token = TO_UTF8( layerTokens.GetNextToken() );
427
428 if( layerUserMasks.contains( token ) )
429 pushLayers( layerUserMasks.at( token ) );
430 else if( layerMasks.count( token ) )
431 pushLayers( layerMasks.at( token ) );
432 else if( layerGuiMasks.count( token ) )
433 pushLayers( layerGuiMasks.at( token ) );
434 else
435 m_reporter->Report( wxString::Format( _( "Invalid layer name \"%s\"\n" ), token ) );
436 }
437 }
438
439 return layerMask;
440}
441
442
443int PCBNEW_JOBS_HANDLER::JobExportStep( JOB* aJob )
444{
445 JOB_EXPORT_PCB_3D* aStepJob = dynamic_cast<JOB_EXPORT_PCB_3D*>( aJob );
446
447 if( aStepJob == nullptr )
448 return CLI::EXIT_CODES::ERR_UNKNOWN;
449
450 BOARD* brd = getBoard( aStepJob->m_filename );
451
452 if( !brd )
453 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
454
455 aJob->SetTitleBlock( brd->GetTitleBlock() );
456 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
457 brd->SynchronizeProperties();
458
459 if( aStepJob->GetConfiguredOutputPath().IsEmpty() )
460 {
461 wxFileName fn = brd->GetFileName();
462 fn.SetName( fn.GetName() );
463
464 switch( aStepJob->m_format )
465 {
466 case JOB_EXPORT_PCB_3D::FORMAT::VRML: fn.SetExt( FILEEXT::VrmlFileExtension ); break;
467 case JOB_EXPORT_PCB_3D::FORMAT::STEP: fn.SetExt( FILEEXT::StepFileExtension ); break;
468 case JOB_EXPORT_PCB_3D::FORMAT::BREP: fn.SetExt( FILEEXT::BrepFileExtension ); break;
469 case JOB_EXPORT_PCB_3D::FORMAT::XAO: fn.SetExt( FILEEXT::XaoFileExtension ); break;
470 case JOB_EXPORT_PCB_3D::FORMAT::GLB: fn.SetExt( FILEEXT::GltfBinaryFileExtension ); break;
471 case JOB_EXPORT_PCB_3D::FORMAT::PLY: fn.SetExt( FILEEXT::PlyFileExtension ); break;
472 case JOB_EXPORT_PCB_3D::FORMAT::STL: fn.SetExt( FILEEXT::StlFileExtension ); break;
473 default:
474 m_reporter->Report( _( "Unknown export format" ), RPT_SEVERITY_ERROR );
475 return CLI::EXIT_CODES::ERR_UNKNOWN; // shouldnt have gotten here
476 }
477
478 aStepJob->SetWorkingOutputPath( fn.GetFullName() );
479 }
480
481 wxString outPath = aStepJob->GetFullOutputPath( brd->GetProject() );
482
483 if( !PATHS::EnsurePathExists( outPath, true ) )
484 {
485 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
486 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
487 }
488
489 if( aStepJob->m_format == JOB_EXPORT_PCB_3D::FORMAT::VRML )
490 {
491
492 double scale = 0.0;
493 switch ( aStepJob->m_vrmlUnits )
494 {
495 case JOB_EXPORT_PCB_3D::VRML_UNITS::MM: scale = 1.0; break;
496 case JOB_EXPORT_PCB_3D::VRML_UNITS::METERS: scale = 0.001; break;
497 case JOB_EXPORT_PCB_3D::VRML_UNITS::TENTHS: scale = 10.0 / 25.4; break;
498 case JOB_EXPORT_PCB_3D::VRML_UNITS::INCH: scale = 1.0 / 25.4; break;
499 }
500
501 EXPORTER_VRML vrmlExporter( brd );
502 wxString messages;
503
504 double originX = pcbIUScale.IUTomm( aStepJob->m_3dparams.m_Origin.x );
505 double originY = pcbIUScale.IUTomm( aStepJob->m_3dparams.m_Origin.y );
506
507 if( !aStepJob->m_hasUserOrigin )
508 {
509 BOX2I bbox = brd->ComputeBoundingBox( true );
510 originX = pcbIUScale.IUTomm( bbox.GetCenter().x );
511 originY = pcbIUScale.IUTomm( bbox.GetCenter().y );
512 }
513
514 bool success = vrmlExporter.ExportVRML_File( brd->GetProject(),
515 &messages,
516 outPath,
517 scale,
518 aStepJob->m_3dparams.m_IncludeUnspecified,
519 aStepJob->m_3dparams.m_IncludeDNP,
520 !aStepJob->m_vrmlModelDir.IsEmpty(),
521 aStepJob->m_vrmlRelativePaths,
522 aStepJob->m_vrmlModelDir,
523 originX,
524 originY );
525
526 if ( success )
527 {
528 m_reporter->Report( wxString::Format( _( "Successfully exported VRML to %s" ),
529 outPath ),
530 RPT_SEVERITY_INFO );
531 }
532 else
533 {
534 m_reporter->Report( _( "Error exporting VRML" ), RPT_SEVERITY_ERROR );
535 return CLI::EXIT_CODES::ERR_UNKNOWN;
536 }
537 }
538 else
539 {
540 EXPORTER_STEP_PARAMS params = aStepJob->m_3dparams;
541
542 switch( aStepJob->m_format )
543 {
544 case JOB_EXPORT_PCB_3D::FORMAT::STEP: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::STEP; break;
545 case JOB_EXPORT_PCB_3D::FORMAT::STEPZ: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::STEPZ; break;
546 case JOB_EXPORT_PCB_3D::FORMAT::BREP: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::BREP; break;
547 case JOB_EXPORT_PCB_3D::FORMAT::XAO: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::XAO; break;
548 case JOB_EXPORT_PCB_3D::FORMAT::GLB: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::GLB; break;
549 case JOB_EXPORT_PCB_3D::FORMAT::PLY: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::PLY; break;
550 case JOB_EXPORT_PCB_3D::FORMAT::STL: params.m_Format = EXPORTER_STEP_PARAMS::FORMAT::STL; break;
551 default:
552 m_reporter->Report( _( "Unknown export format" ), RPT_SEVERITY_ERROR );
553 return CLI::EXIT_CODES::ERR_UNKNOWN; // shouldnt have gotten here
554 }
555
556 EXPORTER_STEP stepExporter( brd, params, m_reporter );
557 stepExporter.m_outputFile = aStepJob->GetFullOutputPath( brd->GetProject() );
558
559 if( !stepExporter.Export() )
560 return CLI::EXIT_CODES::ERR_UNKNOWN;
561 }
562
563 return CLI::EXIT_CODES::OK;
564}
565
566
567int PCBNEW_JOBS_HANDLER::JobExportRender( JOB* aJob )
568{
569 JOB_PCB_RENDER* aRenderJob = dynamic_cast<JOB_PCB_RENDER*>( aJob );
570
571 if( aRenderJob == nullptr )
572 return CLI::EXIT_CODES::ERR_UNKNOWN;
573
574 // Reject width and height being invalid
575 // Final bit of sanity because this can blow things up
576 if( aRenderJob->m_width <= 0 || aRenderJob->m_height <= 0 )
577 {
578 m_reporter->Report( _( "Invalid image dimensions" ), RPT_SEVERITY_ERROR );
579 return CLI::EXIT_CODES::ERR_ARGS;
580 }
581
582 BOARD* brd = getBoard( aRenderJob->m_filename );
583
584 if( !brd )
585 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
586
587 aJob->SetTitleBlock( brd->GetTitleBlock() );
588 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
589 brd->SynchronizeProperties();
590
591 if( aRenderJob->GetConfiguredOutputPath().IsEmpty() )
592 {
593 wxFileName fn = brd->GetFileName();
594
595 switch( aRenderJob->m_format )
596 {
597 case JOB_PCB_RENDER::FORMAT::JPEG: fn.SetExt( FILEEXT::JpegFileExtension ); break;
598 case JOB_PCB_RENDER::FORMAT::PNG: fn.SetExt( FILEEXT::PngFileExtension ); break;
599 default:
600 m_reporter->Report( _( "Unknown export format" ), RPT_SEVERITY_ERROR );
601 return CLI::EXIT_CODES::ERR_UNKNOWN; // shouldnt have gotten here
602 }
603
604 // set the name to board name + "side", its lazy but its hard to generate anything truely unique
605 // incase someone is doing this in a jobset with multiple jobs, they should be setting the output themselves
606 // or we do a hash based on all the options
607 fn.SetName( wxString::Format( "%s-%d", fn.GetName(), static_cast<int>( aRenderJob->m_side ) ) );
608
609 aRenderJob->SetWorkingOutputPath( fn.GetFullName() );
610 }
611
612 wxString outPath = aRenderJob->GetFullOutputPath( brd->GetProject() );
613
614 if( !PATHS::EnsurePathExists( outPath, true ) )
615 {
616 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
617 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
618 }
619
620 BOARD_ADAPTER boardAdapter;
621
622 boardAdapter.SetBoard( brd );
623 boardAdapter.m_IsBoardView = false;
624
625 if( aRenderJob->m_appearancePreset.empty() )
626 boardAdapter.m_IsPreviewer = true; // Force display 3D models, regardless of 3D viewer options
627
628 EDA_3D_VIEWER_SETTINGS cfg;
629
630 if( EDA_3D_VIEWER_SETTINGS* userCfg = GetAppSettings<EDA_3D_VIEWER_SETTINGS>( "3d_viewer" ) )
631 {
632 cfg.m_Render = userCfg->m_Render;
633 cfg.m_Camera = userCfg->m_Camera;
634 cfg.m_LayerPresets = userCfg->m_LayerPresets;
635 }
636
637 if( aRenderJob->m_quality == JOB_PCB_RENDER::QUALITY::BASIC )
638 {
639 // Silkscreen is pixelated without antialiasing
640 cfg.m_Render.raytrace_anti_aliasing = true;
641
642 cfg.m_Render.raytrace_backfloor = aRenderJob->m_floor;
643 cfg.m_Render.raytrace_post_processing = aRenderJob->m_floor;
644
645 cfg.m_Render.raytrace_procedural_textures = false;
646 cfg.m_Render.raytrace_reflections = false;
647 cfg.m_Render.raytrace_shadows = aRenderJob->m_floor;
648
649 // Better colors
650 cfg.m_Render.differentiate_plated_copper = true;
651
652 // Tracks below soldermask are not visible without refractions
653 cfg.m_Render.raytrace_refractions = true;
654 cfg.m_Render.raytrace_recursivelevel_refractions = 1;
655 }
656 else if( aRenderJob->m_quality == JOB_PCB_RENDER::QUALITY::HIGH )
657 {
658 cfg.m_Render.raytrace_anti_aliasing = true;
659 cfg.m_Render.raytrace_backfloor = true;
660 cfg.m_Render.raytrace_post_processing = true;
661 cfg.m_Render.raytrace_procedural_textures = true;
662 cfg.m_Render.raytrace_reflections = true;
663 cfg.m_Render.raytrace_shadows = true;
664 cfg.m_Render.raytrace_refractions = true;
665 cfg.m_Render.differentiate_plated_copper = true;
666 }
667 else if( aRenderJob->m_quality == JOB_PCB_RENDER::QUALITY::JOB_SETTINGS )
668 {
669 cfg.m_Render.raytrace_anti_aliasing = aRenderJob->m_antiAlias;
670 cfg.m_Render.raytrace_backfloor = aRenderJob->m_floor;
671 cfg.m_Render.raytrace_post_processing = aRenderJob->m_postProcess;
672 cfg.m_Render.raytrace_procedural_textures = aRenderJob->m_proceduralTextures;
673 }
674
675 cfg.m_Render.raytrace_lightColorTop = COLOR4D( aRenderJob->m_lightTopIntensity.x,
676 aRenderJob->m_lightTopIntensity.y,
677 aRenderJob->m_lightTopIntensity.z, 1.0 );
678
679 cfg.m_Render.raytrace_lightColorBottom = COLOR4D( aRenderJob->m_lightBottomIntensity.x,
680 aRenderJob->m_lightBottomIntensity.y,
681 aRenderJob->m_lightBottomIntensity.z, 1.0 );
682
683 cfg.m_Render.raytrace_lightColorCamera = COLOR4D( aRenderJob->m_lightCameraIntensity.x,
684 aRenderJob->m_lightCameraIntensity.y,
685 aRenderJob->m_lightCameraIntensity.z, 1.0 );
686
687 COLOR4D lightColor( aRenderJob->m_lightSideIntensity.x,
688 aRenderJob->m_lightSideIntensity.y,
689 aRenderJob->m_lightSideIntensity.z, 1.0 );
690
691 cfg.m_Render.raytrace_lightColor = {
692 lightColor, lightColor, lightColor, lightColor,
693 lightColor, lightColor, lightColor, lightColor,
694 };
695
696 int sideElevation = aRenderJob->m_lightSideElevation;
697
698 cfg.m_Render.raytrace_lightElevation = {
699 sideElevation, sideElevation, sideElevation, sideElevation,
700 -sideElevation, -sideElevation, -sideElevation, -sideElevation,
701 };
702
703 cfg.m_Render.raytrace_lightAzimuth = {
704 45, 135, 225, 315, 45, 135, 225, 315,
705 };
706
707 cfg.m_CurrentPreset = aRenderJob->m_appearancePreset;
708 boardAdapter.m_Cfg = &cfg;
709
710 if( aRenderJob->m_bgStyle == JOB_PCB_RENDER::BG_STYLE::TRANSPARENT
711 || ( aRenderJob->m_bgStyle == JOB_PCB_RENDER::BG_STYLE::DEFAULT
712 && aRenderJob->m_format == JOB_PCB_RENDER::FORMAT::PNG ) )
713 {
714 boardAdapter.m_ColorOverrides[LAYER_3D_BACKGROUND_TOP] = COLOR4D( 1.0, 1.0, 1.0, 0.0 );
715 boardAdapter.m_ColorOverrides[LAYER_3D_BACKGROUND_BOTTOM] = COLOR4D( 1.0, 1.0, 1.0, 0.0 );
716 }
717
718 boardAdapter.Set3dCacheManager( PROJECT_PCB::Get3DCacheManager( brd->GetProject() ) );
719
720 static std::map<JOB_PCB_RENDER::SIDE, VIEW3D_TYPE> s_viewCmdMap = {
721 { JOB_PCB_RENDER::SIDE::TOP, VIEW3D_TYPE::VIEW3D_TOP },
722 { JOB_PCB_RENDER::SIDE::BOTTOM, VIEW3D_TYPE::VIEW3D_BOTTOM },
723 { JOB_PCB_RENDER::SIDE::LEFT, VIEW3D_TYPE::VIEW3D_LEFT },
724 { JOB_PCB_RENDER::SIDE::RIGHT, VIEW3D_TYPE::VIEW3D_RIGHT },
725 { JOB_PCB_RENDER::SIDE::FRONT, VIEW3D_TYPE::VIEW3D_FRONT },
726 { JOB_PCB_RENDER::SIDE::BACK, VIEW3D_TYPE::VIEW3D_BACK },
727 };
728
729 PROJECTION_TYPE projection = aRenderJob->m_perspective ? PROJECTION_TYPE::PERSPECTIVE
730 : PROJECTION_TYPE::ORTHO;
731
732 wxSize windowSize( aRenderJob->m_width, aRenderJob->m_height );
733 TRACK_BALL camera( 2 * RANGE_SCALE_3D );
734
735 camera.SetProjection( projection );
736 camera.SetCurWindowSize( windowSize );
737
738 RENDER_3D_RAYTRACE_RAM raytrace( boardAdapter, camera );
739 raytrace.SetCurWindowSize( windowSize );
740
741 for( bool first = true; raytrace.Redraw( false, m_reporter, m_reporter ); first = false )
742 {
743 if( first )
744 {
745 const float cmTo3D = boardAdapter.BiuTo3dUnits() * pcbIUScale.mmToIU( 10.0 );
746
747 // First redraw resets lookat point to the board center, so set up the camera here
748 camera.ViewCommand_T1( s_viewCmdMap[aRenderJob->m_side] );
749
750 camera.SetLookAtPos_T1( camera.GetLookAtPos_T1() + SFVEC3F( aRenderJob->m_pivot.x,
751 aRenderJob->m_pivot.y,
752 aRenderJob->m_pivot.z ) * cmTo3D );
753
754 camera.Pan_T1( SFVEC3F( aRenderJob->m_pan.x, aRenderJob->m_pan.y, aRenderJob->m_pan.z ) );
755
756 camera.Zoom_T1( aRenderJob->m_zoom );
757
758 camera.RotateX_T1( DEG2RAD( aRenderJob->m_rotation.x ) );
759 camera.RotateY_T1( DEG2RAD( aRenderJob->m_rotation.y ) );
760 camera.RotateZ_T1( DEG2RAD( aRenderJob->m_rotation.z ) );
761
762 camera.Interpolate( 1.0f );
763 camera.SetT0_and_T1_current_T();
764 camera.ParametersChanged();
765 }
766 }
767
768 uint8_t* rgbaBuffer = raytrace.GetBuffer();
769 wxSize realSize = raytrace.GetRealBufferSize();
770 bool success = !!rgbaBuffer;
771
772 if( rgbaBuffer )
773 {
774 const unsigned int wxh = realSize.x * realSize.y;
775
776 unsigned char* rgbBuffer = (unsigned char*) malloc( wxh * 3 );
777 unsigned char* alphaBuffer = (unsigned char*) malloc( wxh );
778
779 unsigned char* rgbaPtr = rgbaBuffer;
780 unsigned char* rgbPtr = rgbBuffer;
781 unsigned char* alphaPtr = alphaBuffer;
782
783 for( int y = 0; y < realSize.y; y++ )
784 {
785 for( int x = 0; x < realSize.x; x++ )
786 {
787 rgbPtr[0] = rgbaPtr[0];
788 rgbPtr[1] = rgbaPtr[1];
789 rgbPtr[2] = rgbaPtr[2];
790 alphaPtr[0] = rgbaPtr[3];
791
792 rgbaPtr += 4;
793 rgbPtr += 3;
794 alphaPtr += 1;
795 }
796 }
797
798 wxImage image( realSize );
799 image.SetData( rgbBuffer );
800 image.SetAlpha( alphaBuffer );
801 image = image.Mirror( false );
802
803 image.SetOption( wxIMAGE_OPTION_QUALITY, 90 );
804 image.SaveFile( outPath, aRenderJob->m_format == JOB_PCB_RENDER::FORMAT::PNG ? wxBITMAP_TYPE_PNG
805 : wxBITMAP_TYPE_JPEG );
806 }
807
808 if( success )
809 {
810 m_reporter->Report( _( "Successfully created 3D render image" ) + wxS( "\n" ), RPT_SEVERITY_INFO );
811 return CLI::EXIT_CODES::OK;
812 }
813 else
814 {
815 m_reporter->Report( _( "Error creating 3D render image" ) + wxS( "\n" ), RPT_SEVERITY_ERROR );
816 return CLI::EXIT_CODES::ERR_UNKNOWN;
817 }
818}
819
820
821int PCBNEW_JOBS_HANDLER::JobExportSvg( JOB* aJob )
822{
823 JOB_EXPORT_PCB_SVG* aSvgJob = dynamic_cast<JOB_EXPORT_PCB_SVG*>( aJob );
824
825 if( aSvgJob == nullptr )
826 return CLI::EXIT_CODES::ERR_UNKNOWN;
827
828 BOARD* brd = getBoard( aSvgJob->m_filename );
829
830 if( !brd )
831 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
832
833 aJob->SetTitleBlock( brd->GetTitleBlock() );
834
835 if( aSvgJob->m_genMode == JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE )
836 {
837 if( aSvgJob->GetConfiguredOutputPath().IsEmpty() )
838 {
839 wxFileName fn = brd->GetFileName();
840 fn.SetName( fn.GetName() );
841 fn.SetExt( GetDefaultPlotExtension( PLOT_FORMAT::SVG ) );
842
843 aSvgJob->SetWorkingOutputPath( fn.GetFullName() );
844 }
845 }
846
847 wxString outPath = aSvgJob->GetFullOutputPath( brd->GetProject() );
848
849 if( !PATHS::EnsurePathExists( outPath, aSvgJob->m_genMode == JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE ) )
850 {
851 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
852 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
853 }
854
855 loadOverrideDrawingSheet( brd, aSvgJob->m_drawingSheet );
856 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
857 brd->SynchronizeProperties();
858
859 if( aSvgJob->m_argLayers )
860 aSvgJob->m_plotLayerSequence = convertLayerArg( aSvgJob->m_argLayers.value(), brd );
861
862 if( aSvgJob->m_argCommonLayers )
863 aSvgJob->m_plotOnAllLayersSequence = convertLayerArg( aSvgJob->m_argCommonLayers.value(), brd );
864
865 if( aSvgJob->m_plotLayerSequence.size() < 1 )
866 {
867 m_reporter->Report( _( "At least one layer must be specified\n" ), RPT_SEVERITY_ERROR );
868 return CLI::EXIT_CODES::ERR_ARGS;
869 }
870
871 PCB_PLOT_PARAMS plotOpts;
872 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, aSvgJob, *m_reporter );
873
874 PCB_PLOTTER plotter( brd, m_reporter, plotOpts );
875
876 std::optional<wxString> layerName;
877 std::optional<wxString> sheetName;
878 std::optional<wxString> sheetPath;
879
880 if( aSvgJob->m_genMode == JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE )
881 {
882 if( aJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
883 layerName = aSvgJob->GetVarOverrides().at( wxT( "LAYER" ) );
884
885 if( aJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
886 sheetName = aSvgJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
887
888 if( aJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
889 sheetPath = aSvgJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
890 }
891
892 if( !plotter.Plot( outPath, aSvgJob->m_plotLayerSequence, aSvgJob->m_plotOnAllLayersSequence,
893 false, aSvgJob->m_genMode == JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE,
894 layerName, sheetName, sheetPath ) )
895 {
896 return CLI::EXIT_CODES::ERR_UNKNOWN;
897 }
898
899 return CLI::EXIT_CODES::OK;
900}
901
902
903int PCBNEW_JOBS_HANDLER::JobExportDxf( JOB* aJob )
904{
905 JOB_EXPORT_PCB_DXF* aDxfJob = dynamic_cast<JOB_EXPORT_PCB_DXF*>( aJob );
906
907 if( aDxfJob == nullptr )
908 return CLI::EXIT_CODES::ERR_UNKNOWN;
909
910 BOARD* brd = getBoard( aDxfJob->m_filename );
911
912 if( !brd )
913 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
914
915 aJob->SetTitleBlock( brd->GetTitleBlock() );
916 loadOverrideDrawingSheet( brd, aDxfJob->m_drawingSheet );
917 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
918 brd->SynchronizeProperties();
919
920 if( aDxfJob->m_argLayers )
921 aDxfJob->m_plotLayerSequence = convertLayerArg( aDxfJob->m_argLayers.value(), brd );
922
923 if( aDxfJob->m_argCommonLayers )
924 aDxfJob->m_plotOnAllLayersSequence = convertLayerArg( aDxfJob->m_argCommonLayers.value(), brd );
925
926 if( aDxfJob->m_plotLayerSequence.size() < 1 )
927 {
928 m_reporter->Report( _( "At least one layer must be specified\n" ), RPT_SEVERITY_ERROR );
929 return CLI::EXIT_CODES::ERR_ARGS;
930 }
931
932 if( aDxfJob->m_genMode == JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE )
933 {
934 if( aDxfJob->GetConfiguredOutputPath().IsEmpty() )
935 {
936 wxFileName fn = brd->GetFileName();
937 fn.SetName( fn.GetName() );
938 fn.SetExt( GetDefaultPlotExtension( PLOT_FORMAT::DXF ) );
939
940 aDxfJob->SetWorkingOutputPath( fn.GetFullName() );
941 }
942 }
943
944 wxString outPath = aDxfJob->GetFullOutputPath( brd->GetProject() );
945
946 if( !PATHS::EnsurePathExists( outPath, aDxfJob->m_genMode == JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE ) )
947 {
948 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
949 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
950 }
951
952 PCB_PLOT_PARAMS plotOpts;
953 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, aDxfJob, *m_reporter);
954
955 PCB_PLOTTER plotter( brd, m_reporter, plotOpts );
956
957 std::optional<wxString> layerName;
958 std::optional<wxString> sheetName;
959 std::optional<wxString> sheetPath;
960
961 if( aDxfJob->m_genMode == JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE )
962 {
963 if( aJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
964 layerName = aDxfJob->GetVarOverrides().at( wxT( "LAYER" ) );
965
966 if( aJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
967 sheetName = aDxfJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
968
969 if( aJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
970 sheetPath = aDxfJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
971 }
972
973 if( !plotter.Plot( outPath, aDxfJob->m_plotLayerSequence, aDxfJob->m_plotOnAllLayersSequence,
974 false, aDxfJob->m_genMode == JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE,
975 layerName, sheetName, sheetPath ) )
976 {
977 return CLI::EXIT_CODES::ERR_UNKNOWN;
978 }
979
980 return CLI::EXIT_CODES::OK;
981}
982
983
984int PCBNEW_JOBS_HANDLER::JobExportPdf( JOB* aJob )
985{
986 bool plotAllLayersOneFile = false;
987 JOB_EXPORT_PCB_PDF* pdfJob = dynamic_cast<JOB_EXPORT_PCB_PDF*>( aJob );
988
989 if( pdfJob == nullptr )
990 return CLI::EXIT_CODES::ERR_UNKNOWN;
991
992 BOARD* brd = getBoard( pdfJob->m_filename );
993
994 if( !brd )
995 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
996
997 pdfJob->SetTitleBlock( brd->GetTitleBlock() );
998 loadOverrideDrawingSheet( brd, pdfJob->m_drawingSheet );
999 brd->GetProject()->ApplyTextVars( pdfJob->GetVarOverrides() );
1000 brd->SynchronizeProperties();
1001
1002 if( pdfJob->m_argLayers )
1003 pdfJob->m_plotLayerSequence = convertLayerArg( pdfJob->m_argLayers.value(), brd );
1004
1005 if( pdfJob->m_argCommonLayers )
1006 pdfJob->m_plotOnAllLayersSequence = convertLayerArg( pdfJob->m_argCommonLayers.value(), brd );
1007
1008 if( pdfJob->m_pdfGenMode == JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_ONE_FILE )
1009 plotAllLayersOneFile = true;
1010
1011 if( pdfJob->m_plotLayerSequence.size() < 1 )
1012 {
1013 m_reporter->Report( _( "At least one layer must be specified\n" ), RPT_SEVERITY_ERROR );
1014 return CLI::EXIT_CODES::ERR_ARGS;
1015 }
1016
1017 if( plotAllLayersOneFile && pdfJob->GetConfiguredOutputPath().IsEmpty() )
1018 {
1019 wxFileName fn = brd->GetFileName();
1020 fn.SetName( fn.GetName() );
1021 fn.SetExt( GetDefaultPlotExtension( PLOT_FORMAT::PDF ) );
1022
1023 pdfJob->SetWorkingOutputPath( fn.GetFullName() );
1024 }
1025
1026 PCB_PLOT_PARAMS plotOpts;
1027 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, pdfJob, *m_reporter );
1028
1029 // ensure this is set for this one gen mode
1030 if( plotAllLayersOneFile )
1031 plotOpts.m_PDFSingle = true;
1032
1033 PCB_PLOTTER pcbPlotter( brd, m_reporter, plotOpts );
1034
1035 wxString outPath = pdfJob->GetFullOutputPath( brd->GetProject() );
1036
1037 if( !PATHS::EnsurePathExists( outPath, plotAllLayersOneFile ) )
1038 {
1039 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1040 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1041 }
1042
1043 std::optional<wxString> layerName;
1044 std::optional<wxString> sheetName;
1045 std::optional<wxString> sheetPath;
1046
1047 if( plotAllLayersOneFile )
1048 {
1049 if( pdfJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
1050 layerName = pdfJob->GetVarOverrides().at( wxT( "LAYER" ) );
1051
1052 if( pdfJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
1053 sheetName = pdfJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
1054
1055 if( pdfJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
1056 sheetPath = pdfJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
1057 }
1058
1059
1060 LOCALE_IO dummy;
1061
1062 if( !pcbPlotter.Plot( outPath, pdfJob->m_plotLayerSequence,
1063 pdfJob->m_plotOnAllLayersSequence, false, plotAllLayersOneFile,
1064 layerName, sheetName, sheetPath ) )
1065 {
1066 return CLI::EXIT_CODES::ERR_UNKNOWN;
1067 }
1068
1069 return CLI::EXIT_CODES::OK;
1070}
1071
1072
1073int PCBNEW_JOBS_HANDLER::JobExportPs( JOB* aJob )
1074{
1075 JOB_EXPORT_PCB_PS* psJob = dynamic_cast<JOB_EXPORT_PCB_PS*>( aJob );
1076
1077 if( psJob == nullptr )
1078 return CLI::EXIT_CODES::ERR_UNKNOWN;
1079
1080 BOARD* brd = getBoard( psJob->m_filename );
1081
1082 if( !brd )
1083 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1084
1085 psJob->SetTitleBlock( brd->GetTitleBlock() );
1086 loadOverrideDrawingSheet( brd, psJob->m_drawingSheet );
1087 brd->GetProject()->ApplyTextVars( psJob->GetVarOverrides() );
1088 brd->SynchronizeProperties();
1089
1090 if( psJob->m_argLayers )
1091 psJob->m_plotLayerSequence = convertLayerArg( psJob->m_argLayers.value(), brd );
1092
1093 if( psJob->m_argCommonLayers )
1094 psJob->m_plotOnAllLayersSequence = convertLayerArg( psJob->m_argCommonLayers.value(), brd );
1095
1096 if( psJob->m_plotLayerSequence.size() < 1 )
1097 {
1098 m_reporter->Report( _( "At least one layer must be specified\n" ), RPT_SEVERITY_ERROR );
1099 return CLI::EXIT_CODES::ERR_ARGS;
1100 }
1101
1102 bool isSingle = psJob->m_genMode == JOB_EXPORT_PCB_PS::GEN_MODE::SINGLE;
1103
1104 if( isSingle )
1105 {
1106 if( psJob->GetConfiguredOutputPath().IsEmpty() )
1107 {
1108 wxFileName fn = brd->GetFileName();
1109 fn.SetName( fn.GetName() );
1110 fn.SetExt( GetDefaultPlotExtension( PLOT_FORMAT::POST ) );
1111
1112 psJob->SetWorkingOutputPath( fn.GetFullName() );
1113 }
1114 }
1115
1116 wxString outPath = psJob->GetFullOutputPath( brd->GetProject() );
1117
1118 if( !PATHS::EnsurePathExists( outPath, isSingle ) )
1119 {
1120 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1121 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1122 }
1123
1124 PCB_PLOT_PARAMS plotOpts;
1125 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, psJob, *m_reporter );
1126
1127 PCB_PLOTTER pcbPlotter( brd, m_reporter, plotOpts );
1128
1129 std::optional<wxString> layerName;
1130 std::optional<wxString> sheetName;
1131 std::optional<wxString> sheetPath;
1132
1133 if( isSingle )
1134 {
1135 if( aJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
1136 layerName = psJob->GetVarOverrides().at( wxT( "LAYER" ) );
1137
1138 if( aJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
1139 sheetName = psJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
1140
1141 if( aJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
1142 sheetPath = psJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
1143 }
1144
1145 LOCALE_IO dummy;
1146
1147 if( !pcbPlotter.Plot( outPath, psJob->m_plotLayerSequence, psJob->m_plotOnAllLayersSequence, false, isSingle,
1148 layerName, sheetName, sheetPath ) )
1149 {
1150 return CLI::EXIT_CODES::ERR_UNKNOWN;
1151 }
1152
1153 return CLI::EXIT_CODES::OK;
1154}
1155
1156
1157int PCBNEW_JOBS_HANDLER::JobExportGerbers( JOB* aJob )
1158{
1159 int exitCode = CLI::EXIT_CODES::OK;
1160 JOB_EXPORT_PCB_GERBERS* aGerberJob = dynamic_cast<JOB_EXPORT_PCB_GERBERS*>( aJob );
1161
1162 if( aGerberJob == nullptr )
1163 return CLI::EXIT_CODES::ERR_UNKNOWN;
1164
1165 BOARD* brd = getBoard( aGerberJob->m_filename );
1166
1167 if( !brd )
1168 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1169
1170 wxString outPath = aGerberJob->GetFullOutputPath( brd->GetProject() );
1171
1172 if( !PATHS::EnsurePathExists( outPath, false ) )
1173 {
1174 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1175 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1176 }
1177
1178 aJob->SetTitleBlock( brd->GetTitleBlock() );
1179 loadOverrideDrawingSheet( brd, aGerberJob->m_drawingSheet );
1180 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
1181 brd->SynchronizeProperties();
1182
1183 bool hasLayerListSpecified = false; // will be true if the user layer list is not empty
1184
1185 if( aGerberJob->m_argLayers )
1186 {
1187 if( !aGerberJob->m_argLayers.value().empty() )
1188 {
1189 aGerberJob->m_plotLayerSequence = convertLayerArg( aGerberJob->m_argLayers.value(), brd );
1190 hasLayerListSpecified = true;
1191 }
1192 else
1193 {
1194 aGerberJob->m_plotLayerSequence = LSET::AllLayersMask().SeqStackupForPlotting();
1195 }
1196 }
1197
1198 if( aGerberJob->m_argCommonLayers )
1199 aGerberJob->m_plotOnAllLayersSequence = convertLayerArg( aGerberJob->m_argCommonLayers.value(), brd );
1200
1201 PCB_PLOT_PARAMS boardPlotOptions = brd->GetPlotOptions();
1202 GERBER_JOBFILE_WRITER jobfile_writer( brd );
1203
1204 wxString fileExt;
1205
1206 if( aGerberJob->m_useBoardPlotParams )
1207 {
1208 // The board plot options are saved with all copper layers enabled, even those that don't
1209 // exist in the current stackup. This is done so the layers are automatically enabled in the plot
1210 // dialog when the user enables them. We need to filter out these not-enabled layers here so
1211 // we don't plot 32 layers when we only have 4, etc.
1212 LSET plotLayers = ( boardPlotOptions.GetLayerSelection() & LSET::AllNonCuMask() )
1213 | ( brd->GetEnabledLayers() & LSET::AllCuMask() );
1214 aGerberJob->m_plotLayerSequence = plotLayers.SeqStackupForPlotting();
1215 aGerberJob->m_plotOnAllLayersSequence = boardPlotOptions.GetPlotOnAllLayersSequence();
1216 }
1217 else
1218 {
1219 // default to the board enabled layers, but only if the user has not specifed a layer list
1220 // ( m_plotLayerSequence can be empty with a broken user layer list)
1221 if( aGerberJob->m_plotLayerSequence.empty() && !hasLayerListSpecified )
1222 aGerberJob->m_plotLayerSequence = brd->GetEnabledLayers().SeqStackupForPlotting();
1223 }
1224
1225 // Ensure layers to plot are restricted to enabled layers of the board to plot
1226 LSET layersToPlot = LSET( { aGerberJob->m_plotLayerSequence } ) & brd->GetEnabledLayers();
1227
1228 for( PCB_LAYER_ID layer : layersToPlot.UIOrder() )
1229 {
1230 LSEQ plotSequence;
1231
1232 // Base layer always gets plotted first.
1233 plotSequence.push_back( layer );
1234
1235 // Now all the "include on all" layers
1236 for( PCB_LAYER_ID layer_all : aGerberJob->m_plotOnAllLayersSequence )
1237 {
1238 // Don't plot the same layer more than once;
1239 if( find( plotSequence.begin(), plotSequence.end(), layer_all ) != plotSequence.end() )
1240 continue;
1241
1242 plotSequence.push_back( layer_all );
1243 }
1244
1245 // Pick the basename from the board file
1246 wxFileName fn( brd->GetFileName() );
1247 wxString layerName = brd->GetLayerName( layer );
1248 wxString sheetName;
1249 wxString sheetPath;
1250 PCB_PLOT_PARAMS plotOpts;
1251
1252 if( aGerberJob->m_useBoardPlotParams )
1253 plotOpts = boardPlotOptions;
1254 else
1255 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, aGerberJob, *m_reporter );
1256
1257 if( plotOpts.GetUseGerberProtelExtensions() )
1258 fileExt = GetGerberProtelExtension( layer );
1259 else
1260 fileExt = FILEEXT::GerberFileExtension;
1261
1262 BuildPlotFileName( &fn, outPath, layerName, fileExt );
1263 wxString fullname = fn.GetFullName();
1264
1265 if( m_progressReporter )
1266 {
1267 m_progressReporter->AdvancePhase( wxString::Format( _( "Exporting %s" ), fullname ) );
1268 m_progressReporter->KeepRefreshing();
1269 }
1270
1271 jobfile_writer.AddGbrFile( layer, fullname );
1272
1273 if( aJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
1274 layerName = aJob->GetVarOverrides().at( wxT( "LAYER" ) );
1275
1276 if( aJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
1277 sheetName = aJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
1278
1279 if( aJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
1280 sheetPath = aJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
1281
1282 // We are feeding it one layer at the start here to silence a logic check
1283 GERBER_PLOTTER* plotter;
1284 {
1285 LOCALE_IO dummy;
1286 plotter = (GERBER_PLOTTER*) StartPlotBoard( brd, &plotOpts, layer, layerName,
1287 fn.GetFullPath(), sheetName, sheetPath );
1288 }
1289
1290 if( plotter )
1291 {
1292 m_reporter->Report( wxString::Format( _( "Plotted to '%s'.\n" ), fn.GetFullPath() ),
1293 RPT_SEVERITY_ACTION );
1294 LOCALE_IO dummy;
1295 PlotBoardLayers( brd, plotter, plotSequence, plotOpts );
1296 plotter->EndPlot();
1297 }
1298 else
1299 {
1300 m_reporter->Report( wxString::Format( _( "Failed to plot to '%s'.\n" ), fn.GetFullPath() ),
1301 RPT_SEVERITY_ERROR );
1302 exitCode = CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1303 }
1304
1305 delete plotter;
1306 }
1307
1308 if( aGerberJob->m_createJobsFile )
1309 {
1310 wxFileName fn( brd->GetFileName() );
1311
1312 // Build gerber job file from basename
1313 BuildPlotFileName( &fn, outPath, wxT( "job" ), FILEEXT::GerberJobFileExtension );
1314 jobfile_writer.CreateJobFile( fn.GetFullPath() );
1315 }
1316
1317 return exitCode;
1318}
1319
1320
1321int PCBNEW_JOBS_HANDLER::JobExportGencad( JOB* aJob )
1322{
1323 JOB_EXPORT_PCB_GENCAD* aGencadJob = dynamic_cast<JOB_EXPORT_PCB_GENCAD*>( aJob );
1324
1325 if( aGencadJob == nullptr )
1326 return CLI::EXIT_CODES::ERR_UNKNOWN;
1327
1328 BOARD* brd = LoadBoard( aGencadJob->m_filename, true ); // Ensure m_board is of type BOARD*
1329
1330 if( brd == nullptr )
1331 return CLI::EXIT_CODES::ERR_UNKNOWN;
1332
1333 GENCAD_EXPORTER exporter( brd );
1334
1335 VECTOR2I GencadOffset;
1336 VECTOR2I auxOrigin = brd->GetDesignSettings().GetAuxOrigin();
1337 GencadOffset.x = aGencadJob->m_useDrillOrigin ? auxOrigin.x : 0;
1338 GencadOffset.y = aGencadJob->m_useDrillOrigin ? auxOrigin.y : 0;
1339
1340 exporter.FlipBottomPads( aGencadJob->m_flipBottomPads );
1341 exporter.UsePinNamesUnique( aGencadJob->m_useUniquePins );
1342 exporter.UseIndividualShapes( aGencadJob->m_useIndividualShapes );
1343 exporter.SetPlotOffet( GencadOffset );
1344 exporter.StoreOriginCoordsInFile( aGencadJob->m_storeOriginCoords );
1345
1346 if( aGencadJob->GetConfiguredOutputPath().IsEmpty() )
1347 {
1348 wxFileName fn = brd->GetFileName();
1349 fn.SetName( fn.GetName() );
1350 fn.SetExt( FILEEXT::GencadFileExtension );
1351
1352 aGencadJob->SetWorkingOutputPath( fn.GetFullName() );
1353 }
1354
1355 wxString outPath = aGencadJob->GetFullOutputPath( brd->GetProject() );
1356
1357 if( !PATHS::EnsurePathExists( outPath, true ) )
1358 {
1359 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1360 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1361 }
1362
1363 if( !exporter.WriteFile( outPath ) )
1364 {
1365 m_reporter->Report( wxString::Format( _( "Failed to create file '%s'.\n" ), outPath ),
1366 RPT_SEVERITY_ERROR );
1367
1368 return CLI::EXIT_CODES::ERR_UNKNOWN;
1369 }
1370
1371 m_reporter->Report( _( "Successfully created genCAD file\n" ), RPT_SEVERITY_INFO );
1372
1373 return CLI::EXIT_CODES::OK;
1374}
1375
1376
1377int PCBNEW_JOBS_HANDLER::JobExportGerber( JOB* aJob )
1378{
1379 int exitCode = CLI::EXIT_CODES::OK;
1380 JOB_EXPORT_PCB_GERBER* aGerberJob = dynamic_cast<JOB_EXPORT_PCB_GERBER*>( aJob );
1381
1382 if( aGerberJob == nullptr )
1383 return CLI::EXIT_CODES::ERR_UNKNOWN;
1384
1385 BOARD* brd = getBoard( aGerberJob->m_filename );
1386
1387 if( !brd )
1388 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1389
1390 aJob->SetTitleBlock( brd->GetTitleBlock() );
1391 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
1392 brd->SynchronizeProperties();
1393
1394 if( aGerberJob->m_argLayers )
1395 aGerberJob->m_plotLayerSequence = convertLayerArg( aGerberJob->m_argLayers.value(), brd );
1396
1397 if( aGerberJob->m_argCommonLayers )
1398 aGerberJob->m_plotOnAllLayersSequence = convertLayerArg( aGerberJob->m_argCommonLayers.value(), brd );
1399
1400 if( aGerberJob->m_plotLayerSequence.size() < 1 )
1401 {
1402 m_reporter->Report( _( "At least one layer must be specified\n" ), RPT_SEVERITY_ERROR );
1403 return CLI::EXIT_CODES::ERR_ARGS;
1404 }
1405
1406 if( aGerberJob->GetConfiguredOutputPath().IsEmpty() )
1407 {
1408 wxFileName fn = brd->GetFileName();
1409 fn.SetName( fn.GetName() );
1410 fn.SetExt( GetDefaultPlotExtension( PLOT_FORMAT::GERBER ) );
1411
1412 aGerberJob->SetWorkingOutputPath( fn.GetFullName() );
1413 }
1414
1415 PCB_PLOT_PARAMS plotOpts;
1416 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, aGerberJob, *m_reporter );
1417 plotOpts.SetLayerSelection( aGerberJob->m_plotLayerSequence );
1418 plotOpts.SetPlotOnAllLayersSequence( aGerberJob->m_plotOnAllLayersSequence );
1419
1420 PCB_LAYER_ID layer = UNDEFINED_LAYER;
1421 wxString layerName;
1422 wxString sheetName;
1423 wxString sheetPath;
1424 wxString outPath = aGerberJob->GetFullOutputPath( brd->GetProject() );
1425
1426 // The first layer will be treated as the layer name for the gerber header,
1427 // the other layers will be treated equivalent to the "Plot on All Layers" option
1428 // in the GUI
1429 if( aGerberJob->m_plotLayerSequence.size() >= 1 )
1430 {
1431 layer = aGerberJob->m_plotLayerSequence.front();
1432 layerName = brd->GetLayerName( layer );
1433 }
1434
1435 if( aJob->GetVarOverrides().contains( wxT( "LAYER" ) ) )
1436 layerName = aJob->GetVarOverrides().at( wxT( "LAYER" ) );
1437
1438 if( aJob->GetVarOverrides().contains( wxT( "SHEETNAME" ) ) )
1439 sheetName = aJob->GetVarOverrides().at( wxT( "SHEETNAME" ) );
1440
1441 if( aJob->GetVarOverrides().contains( wxT( "SHEETPATH" ) ) )
1442 sheetPath = aJob->GetVarOverrides().at( wxT( "SHEETPATH" ) );
1443
1444 // We are feeding it one layer at the start here to silence a logic check
1445 PLOTTER* plotter = StartPlotBoard( brd, &plotOpts, layer, layerName, outPath, sheetName,
1446 sheetPath );
1447
1448 if( plotter )
1449 {
1450 PlotBoardLayers( brd, plotter, aGerberJob->m_plotLayerSequence, plotOpts );
1451 plotter->EndPlot();
1452 }
1453 else
1454 {
1455 m_reporter->Report( wxString::Format( _( "Failed to plot to '%s'.\n" ), outPath ),
1456 RPT_SEVERITY_ERROR );
1457 exitCode = CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1458 }
1459
1460 delete plotter;
1461
1462 return exitCode;
1463}
1464
1465static DRILL_PRECISION precisionListForInches( 2, 4 );
1466static DRILL_PRECISION precisionListForMetric( 3, 3 );
1467
1468
1469int PCBNEW_JOBS_HANDLER::JobExportDrill( JOB* aJob )
1470{
1471 JOB_EXPORT_PCB_DRILL* aDrillJob = dynamic_cast<JOB_EXPORT_PCB_DRILL*>( aJob );
1472
1473 if( aDrillJob == nullptr )
1474 return CLI::EXIT_CODES::ERR_UNKNOWN;
1475
1476 BOARD* brd = getBoard( aDrillJob->m_filename );
1477
1478 if( !brd )
1479 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1480
1481 aJob->SetTitleBlock( brd->GetTitleBlock() );
1482
1483 wxString outPath = aDrillJob->GetFullOutputPath( brd->GetProject() );
1484
1485 if( !PATHS::EnsurePathExists( outPath ) )
1486 {
1487 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1488 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1489 }
1490
1491 std::unique_ptr<GENDRILL_WRITER_BASE> drillWriter;
1492
1493 if( aDrillJob->m_format == JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON )
1494 drillWriter = std::make_unique<EXCELLON_WRITER>( brd );
1495 else
1496 drillWriter = std::make_unique<GERBER_WRITER>( brd );
1497
1498 VECTOR2I offset;
1499
1500 if( aDrillJob->m_drillOrigin == JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS )
1501 offset = VECTOR2I( 0, 0 );
1502 else
1503 offset = brd->GetDesignSettings().GetAuxOrigin();
1504
1505 PLOT_FORMAT mapFormat = PLOT_FORMAT::PDF;
1506
1507 switch( aDrillJob->m_mapFormat )
1508 {
1509 case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::POSTSCRIPT: mapFormat = PLOT_FORMAT::POST; break;
1510 case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::GERBER_X2: mapFormat = PLOT_FORMAT::GERBER; break;
1511 case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::DXF: mapFormat = PLOT_FORMAT::DXF; break;
1512 case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::SVG: mapFormat = PLOT_FORMAT::SVG; break;
1513 default:
1514 case JOB_EXPORT_PCB_DRILL::MAP_FORMAT::PDF: mapFormat = PLOT_FORMAT::PDF; break;
1515 }
1516
1517 if( aDrillJob->m_format == JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON )
1518 {
1519 EXCELLON_WRITER::ZEROS_FMT zeroFmt;
1520 switch( aDrillJob->m_zeroFormat )
1521 {
1522 case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::KEEP_ZEROS:
1523 zeroFmt = EXCELLON_WRITER::KEEP_ZEROS;
1524 break;
1525 case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_LEADING:
1526 zeroFmt = EXCELLON_WRITER::SUPPRESS_LEADING;
1527 break;
1528 case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_TRAILING:
1529 zeroFmt = EXCELLON_WRITER::SUPPRESS_TRAILING;
1530 break;
1531 case JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL:
1532 default:
1533 zeroFmt = EXCELLON_WRITER::DECIMAL_FORMAT;
1534 break;
1535 }
1536
1537 DRILL_PRECISION precision;
1538
1539 if( aDrillJob->m_drillUnits == JOB_EXPORT_PCB_DRILL::DRILL_UNITS::INCH )
1540 precision = precisionListForInches;
1541 else
1542 precision = precisionListForMetric;
1543
1544 EXCELLON_WRITER* excellonWriter = dynamic_cast<EXCELLON_WRITER*>( drillWriter.get() );
1545
1546 if( excellonWriter == nullptr )
1547 return CLI::EXIT_CODES::ERR_UNKNOWN;
1548
1549 excellonWriter->SetFormat( aDrillJob->m_drillUnits == JOB_EXPORT_PCB_DRILL::DRILL_UNITS::MM,
1550 zeroFmt, precision.m_Lhs, precision.m_Rhs );
1551 excellonWriter->SetOptions( aDrillJob->m_excellonMirrorY,
1552 aDrillJob->m_excellonMinimalHeader,
1553 offset, aDrillJob->m_excellonCombinePTHNPTH );
1554 excellonWriter->SetRouteModeForOvalHoles( aDrillJob->m_excellonOvalDrillRoute );
1555 excellonWriter->SetMapFileFormat( mapFormat );
1556
1557 if( !excellonWriter->CreateDrillandMapFilesSet( outPath, true, aDrillJob->m_generateMap,
1558 m_reporter ) )
1559 {
1560 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1561 }
1562 }
1563 else if( aDrillJob->m_format == JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::GERBER )
1564 {
1565 GERBER_WRITER* gerberWriter = dynamic_cast<GERBER_WRITER*>( drillWriter.get() );
1566
1567 if( gerberWriter == nullptr )
1568 return CLI::EXIT_CODES::ERR_UNKNOWN;
1569
1570 // Set gerber precision: only 5 or 6 digits for mantissa are allowed
1571 // (SetFormat() accept 5 or 6, and any other value set the precision to 5)
1572 // the integer part precision is always 4, and units always mm
1573 gerberWriter->SetFormat( aDrillJob->m_gerberPrecision );
1574 gerberWriter->SetOptions( offset );
1575 gerberWriter->SetMapFileFormat( mapFormat );
1576
1577 if( !gerberWriter->CreateDrillandMapFilesSet( outPath, true, aDrillJob->m_generateMap,
1578 aDrillJob->m_generateTenting, m_reporter ) )
1579 {
1580 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1581 }
1582 }
1583
1584 return CLI::EXIT_CODES::OK;
1585}
1586
1587
1588int PCBNEW_JOBS_HANDLER::JobExportPos( JOB* aJob )
1589{
1590 JOB_EXPORT_PCB_POS* aPosJob = dynamic_cast<JOB_EXPORT_PCB_POS*>( aJob );
1591
1592 if( aPosJob == nullptr )
1593 return CLI::EXIT_CODES::ERR_UNKNOWN;
1594
1595 BOARD* brd = getBoard( aPosJob->m_filename );
1596
1597 if( !brd )
1598 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1599
1600 aJob->SetTitleBlock( brd->GetTitleBlock() );
1601
1602 if( aPosJob->GetConfiguredOutputPath().IsEmpty() )
1603 {
1604 wxFileName fn = brd->GetFileName();
1605 fn.SetName( fn.GetName() );
1606
1607 if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::ASCII )
1608 fn.SetExt( FILEEXT::FootprintPlaceFileExtension );
1609 else if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV )
1610 fn.SetExt( FILEEXT::CsvFileExtension );
1611 else if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::GERBER )
1612 fn.SetExt( FILEEXT::GerberFileExtension );
1613
1614 aPosJob->SetWorkingOutputPath( fn.GetFullName() );
1615 }
1616
1617 wxString outPath = aPosJob->GetFullOutputPath( brd->GetProject() );
1618
1619 if( !PATHS::EnsurePathExists( outPath, true ) )
1620 {
1621 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1622 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1623 }
1624
1625 if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::ASCII
1626 || aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV )
1627 {
1628 wxFileName fn( outPath );
1629 wxString baseName = fn.GetName();
1630
1631 auto exportPlaceFile =
1632 [&]( bool frontSide, bool backSide, const wxString& curr_outPath ) -> bool
1633 {
1634 FILE* file = wxFopen( curr_outPath, wxS( "wt" ) );
1635 wxCHECK( file, false );
1636
1637 PLACE_FILE_EXPORTER exporter( brd,
1638 aPosJob->m_units == JOB_EXPORT_PCB_POS::UNITS::MM,
1639 aPosJob->m_smdOnly,
1640 aPosJob->m_excludeFootprintsWithTh,
1641 aPosJob->m_excludeDNP,
1642 frontSide,
1643 backSide,
1644 aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV,
1645 aPosJob->m_useDrillPlaceFileOrigin,
1646 aPosJob->m_negateBottomX );
1647
1648 std::string data = exporter.GenPositionData();
1649 fputs( data.c_str(), file );
1650 fclose( file );
1651
1652 return true;
1653 };
1654
1655 if( aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH && !aPosJob->m_singleFile )
1656 {
1657 fn.SetName( PLACE_FILE_EXPORTER::DecorateFilename( baseName, true, false ) );
1658
1659 if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV && !aPosJob->m_nakedFilename )
1660 fn.SetName( fn.GetName() + wxT( "-" ) + FILEEXT::FootprintPlaceFileExtension );
1661
1662 if( exportPlaceFile( true, false, fn.GetFullPath() ) )
1663 {
1664 m_reporter->Report( wxString::Format( _( "Wrote front position data to '%s'.\n" ),
1665 fn.GetFullPath() ),
1666 RPT_SEVERITY_ACTION );
1667
1668 aPosJob->AddOutput( fn.GetFullPath() );
1669 }
1670 else
1671 {
1672 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1673 }
1674
1675 fn.SetName( PLACE_FILE_EXPORTER::DecorateFilename( baseName, false, true ) );
1676
1677 if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV && !aPosJob->m_nakedFilename )
1678 fn.SetName( fn.GetName() + wxT( "-" ) + FILEEXT::FootprintPlaceFileExtension );
1679
1680 if( exportPlaceFile( false, true, fn.GetFullPath() ) )
1681 {
1682 m_reporter->Report( wxString::Format( _( "Wrote back position data to '%s'.\n" ),
1683 fn.GetFullPath() ),
1684 RPT_SEVERITY_ACTION );
1685
1686 aPosJob->AddOutput( fn.GetFullPath() );
1687 }
1688 else
1689 {
1690 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1691 }
1692 }
1693 else
1694 {
1695 bool front = aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::FRONT
1696 || aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH;
1697
1698 bool back = aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BACK
1699 || aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH;
1700
1701 if( !aPosJob->m_nakedFilename )
1702 {
1703 fn.SetName( PLACE_FILE_EXPORTER::DecorateFilename( fn.GetName(), front, back ) );
1704
1705 if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::CSV )
1706 fn.SetName( fn.GetName() + wxT( "-" ) + FILEEXT::FootprintPlaceFileExtension );
1707 }
1708
1709 if( exportPlaceFile( front, back, fn.GetFullPath() ) )
1710 {
1711 m_reporter->Report( wxString::Format( _( "Wrote position data to '%s'.\n" ),
1712 fn.GetFullPath() ),
1713 RPT_SEVERITY_ACTION );
1714
1715 aPosJob->AddOutput( fn.GetFullPath() );
1716 }
1717 else
1718 {
1719 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1720 }
1721 }
1722 }
1723 else if( aPosJob->m_format == JOB_EXPORT_PCB_POS::FORMAT::GERBER )
1724 {
1725 PLACEFILE_GERBER_WRITER exporter( brd );
1726 PCB_LAYER_ID gbrLayer = F_Cu;
1727 wxString outPath_base = outPath;
1728
1729 if( aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::FRONT
1730 || aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH )
1731 {
1732 if( aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH || !aPosJob->m_nakedFilename )
1733 outPath = exporter.GetPlaceFileName( outPath, gbrLayer );
1734
1735 if( exporter.CreatePlaceFile( outPath, gbrLayer, aPosJob->m_gerberBoardEdge, aPosJob->m_excludeDNP ) >= 0 )
1736 {
1737 m_reporter->Report( wxString::Format( _( "Wrote front position data to '%s'.\n" ), outPath ),
1738 RPT_SEVERITY_ACTION );
1739
1740 aPosJob->AddOutput( outPath );
1741 }
1742 else
1743 {
1744 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1745 }
1746 }
1747
1748 if( aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BACK
1749 || aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH )
1750 {
1751 gbrLayer = B_Cu;
1752
1753 outPath = outPath_base;
1754
1755 if( aPosJob->m_side == JOB_EXPORT_PCB_POS::SIDE::BOTH || !aPosJob->m_nakedFilename )
1756 outPath = exporter.GetPlaceFileName( outPath, gbrLayer );
1757
1758 if( exporter.CreatePlaceFile( outPath, gbrLayer, aPosJob->m_gerberBoardEdge, aPosJob->m_excludeDNP ) >= 0 )
1759 {
1760 m_reporter->Report( wxString::Format( _( "Wrote back position data to '%s'.\n" ), outPath ),
1761 RPT_SEVERITY_ACTION );
1762
1763 aPosJob->AddOutput( outPath );
1764 }
1765 else
1766 {
1767 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1768 }
1769 }
1770 }
1771
1772 return CLI::EXIT_CODES::OK;
1773}
1774
1775
1776int PCBNEW_JOBS_HANDLER::JobExportFpUpgrade( JOB* aJob )
1777{
1778 JOB_FP_UPGRADE* upgradeJob = dynamic_cast<JOB_FP_UPGRADE*>( aJob );
1779
1780 if( upgradeJob == nullptr )
1781 return CLI::EXIT_CODES::ERR_UNKNOWN;
1782
1783 PCB_IO_MGR::PCB_FILE_T fileType = PCB_IO_MGR::GuessPluginTypeFromLibPath( upgradeJob->m_libraryPath );
1784
1785 if( !upgradeJob->m_outputLibraryPath.IsEmpty() )
1786 {
1787 if( wxFile::Exists( upgradeJob->m_outputLibraryPath )
1788 || wxDir::Exists( upgradeJob->m_outputLibraryPath) )
1789 {
1790 m_reporter->Report( _( "Output path must not conflict with existing path\n" ),
1791 RPT_SEVERITY_ERROR );
1792 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1793 }
1794 }
1795 else if( fileType != PCB_IO_MGR::KICAD_SEXP )
1796 {
1797 m_reporter->Report( _( "Output path must be specified to convert legacy and non-KiCad libraries\n" ),
1798 RPT_SEVERITY_ERROR );
1799
1800 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1801 }
1802
1803 if( fileType == PCB_IO_MGR::KICAD_SEXP )
1804 {
1805 if( !wxDir::Exists( upgradeJob->m_libraryPath ) )
1806 {
1807 m_reporter->Report( _( "Footprint library path does not exist or is not accessible\n" ),
1808 RPT_SEVERITY_ERROR );
1809 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
1810 }
1811
1812 PCB_IO_KICAD_SEXPR pcb_io( CTL_FOR_LIBRARY );
1813 FP_CACHE fpLib( &pcb_io, upgradeJob->m_libraryPath );
1814
1815 try
1816 {
1817 fpLib.Load();
1818 }
1819 catch( ... )
1820 {
1821 m_reporter->Report( _( "Unable to load library\n" ), RPT_SEVERITY_ERROR );
1822 return CLI::EXIT_CODES::ERR_UNKNOWN;
1823 }
1824
1825 if( m_progressReporter )
1826 m_progressReporter->KeepRefreshing();
1827
1828 bool shouldSave = upgradeJob->m_force;
1829
1830 for( const auto& footprint : fpLib.GetFootprints() )
1831 {
1832 if( footprint.second->GetFootprint()->GetFileFormatVersionAtLoad() < SEXPR_BOARD_FILE_VERSION )
1833 shouldSave = true;
1834 }
1835
1836 if( shouldSave )
1837 {
1838 try
1839 {
1840 if( !upgradeJob->m_outputLibraryPath.IsEmpty() )
1841 fpLib.SetPath( upgradeJob->m_outputLibraryPath );
1842
1843 fpLib.Save();
1844 }
1845 catch( ... )
1846 {
1847 m_reporter->Report( _( "Unable to save library\n" ), RPT_SEVERITY_ERROR );
1848 return CLI::EXIT_CODES::ERR_UNKNOWN;
1849 }
1850 }
1851 else
1852 {
1853 m_reporter->Report( _( "Footprint library was not updated\n" ), RPT_SEVERITY_ERROR );
1854 }
1855 }
1856 else
1857 {
1858 if( !PCB_IO_MGR::ConvertLibrary( nullptr, upgradeJob->m_libraryPath,
1859 upgradeJob->m_outputLibraryPath, nullptr /* REPORTER */ ) )
1860 {
1861 m_reporter->Report( ( "Unable to convert library\n" ), RPT_SEVERITY_ERROR );
1862 return CLI::EXIT_CODES::ERR_UNKNOWN;
1863 }
1864 }
1865
1866 return CLI::EXIT_CODES::OK;
1867}
1868
1869
1870int PCBNEW_JOBS_HANDLER::JobExportFpSvg( JOB* aJob )
1871{
1872 JOB_FP_EXPORT_SVG* svgJob = dynamic_cast<JOB_FP_EXPORT_SVG*>( aJob );
1873
1874 if( svgJob == nullptr )
1875 return CLI::EXIT_CODES::ERR_UNKNOWN;
1876
1877 PCB_IO_KICAD_SEXPR pcb_io( CTL_FOR_LIBRARY );
1878 FP_CACHE fpLib( &pcb_io, svgJob->m_libraryPath );
1879
1880 if( svgJob->m_argLayers )
1881 {
1882 if( !svgJob->m_argLayers.value().empty() )
1883 svgJob->m_plotLayerSequence = convertLayerArg( svgJob->m_argLayers.value(), nullptr );
1884 else
1885 svgJob->m_plotLayerSequence = LSET::AllLayersMask().SeqStackupForPlotting();
1886 }
1887
1888 try
1889 {
1890 fpLib.Load();
1891 }
1892 catch( ... )
1893 {
1894 m_reporter->Report( _( "Unable to load library\n" ), RPT_SEVERITY_ERROR );
1895 return CLI::EXIT_CODES::ERR_UNKNOWN;
1896 }
1897
1898 wxString outPath = svgJob->GetFullOutputPath( nullptr );
1899
1900 if( !PATHS::EnsurePathExists( outPath, true ) )
1901 {
1902 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
1903 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
1904 }
1905
1906 int exitCode = CLI::EXIT_CODES::OK;
1907 bool singleFpPlotted = false;
1908
1909 for( const auto& [fpName, fpCacheEntry] : fpLib.GetFootprints() )
1910 {
1911 if( m_progressReporter )
1912 {
1913 m_progressReporter->AdvancePhase( wxString::Format( _( "Exporting %s" ), fpName ) );
1914 m_progressReporter->KeepRefreshing();
1915 }
1916
1917 if( !svgJob->m_footprint.IsEmpty() )
1918 {
1919 // skip until we find the right footprint
1920 if( fpName != svgJob->m_footprint )
1921 continue;
1922 else
1923 singleFpPlotted = true;
1924 }
1925
1926 exitCode = doFpExportSvg( svgJob, fpCacheEntry->GetFootprint().get() );
1927
1928 if( exitCode != CLI::EXIT_CODES::OK )
1929 break;
1930 }
1931
1932 if( !svgJob->m_footprint.IsEmpty() && !singleFpPlotted )
1933 {
1934 m_reporter->Report( _( "The given footprint could not be found to export." ) + wxS( "\n" ),
1935 RPT_SEVERITY_ERROR );
1936 }
1937
1938 return CLI::EXIT_CODES::OK;
1939}
1940
1941
1942int PCBNEW_JOBS_HANDLER::doFpExportSvg( JOB_FP_EXPORT_SVG* aSvgJob, const FOOTPRINT* aFootprint )
1943{
1944 // the hack for now is we create fake boards containing the footprint and plot the board
1945 // until we refactor better plot api later
1946 std::unique_ptr<BOARD> brd;
1947 brd.reset( CreateEmptyBoard() );
1948 brd->GetProject()->ApplyTextVars( aSvgJob->GetVarOverrides() );
1949 brd->SynchronizeProperties();
1950
1951 FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( aFootprint->Clone() );
1952
1953 if( fp == nullptr )
1954 return CLI::EXIT_CODES::ERR_UNKNOWN;
1955
1956 fp->SetLink( niluuid );
1957 fp->SetFlags( IS_NEW );
1958 fp->SetParent( brd.get() );
1959
1960 for( PAD* pad : fp->Pads() )
1961 {
1962 pad->SetLocalRatsnestVisible( false );
1963 pad->SetNetCode( 0 );
1964 }
1965
1966 fp->SetOrientation( ANGLE_0 );
1967 fp->SetPosition( VECTOR2I( 0, 0 ) );
1968
1969 brd->Add( fp, ADD_MODE::INSERT, true );
1970
1971 wxFileName outputFile;
1972 outputFile.SetPath( aSvgJob->GetFullOutputPath(nullptr) );
1973 outputFile.SetName( aFootprint->GetFPID().GetLibItemName().wx_str() );
1974 outputFile.SetExt( FILEEXT::SVGFileExtension );
1975
1976 m_reporter->Report( wxString::Format( _( "Plotting footprint '%s' to '%s'\n" ),
1977 aFootprint->GetFPID().GetLibItemName().wx_str(),
1978 outputFile.GetFullPath() ),
1979 RPT_SEVERITY_ACTION );
1980
1981 PCB_PLOT_PARAMS plotOpts;
1982 PCB_PLOTTER::PlotJobToPlotOpts( plotOpts, aSvgJob, *m_reporter );
1983
1984 // always fixed for the svg plot
1985 plotOpts.SetPlotFrameRef( false );
1986 plotOpts.SetSvgFitPageToBoard( true );
1987 plotOpts.SetMirror( false );
1988 plotOpts.SetSkipPlotNPTH_Pads( false );
1989
1990 if( plotOpts.GetSketchPadsOnFabLayers() )
1991 {
1992 plotOpts.SetPlotPadNumbers( true );
1993 }
1994
1995 PCB_PLOTTER plotter( brd.get(), m_reporter, plotOpts );
1996
1997 if( !plotter.Plot( outputFile.GetFullPath(),
1998 aSvgJob->m_plotLayerSequence,
1999 aSvgJob->m_plotOnAllLayersSequence,
2000 false,
2001 true,
2002 wxEmptyString, wxEmptyString,
2003 wxEmptyString ) )
2004 {
2005 m_reporter->Report( _( "Error creating svg file" ) + wxS( "\n" ), RPT_SEVERITY_ERROR );
2006 return CLI::EXIT_CODES::ERR_UNKNOWN;
2007 }
2008
2009 return CLI::EXIT_CODES::OK;
2010}
2011
2012
2013int PCBNEW_JOBS_HANDLER::JobExportDrc( JOB* aJob )
2014{
2015 JOB_PCB_DRC* drcJob = dynamic_cast<JOB_PCB_DRC*>( aJob );
2016
2017 if( drcJob == nullptr )
2018 return CLI::EXIT_CODES::ERR_UNKNOWN;
2019
2020 BOARD* brd = getBoard( drcJob->m_filename );
2021
2022 if( !brd )
2023 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
2024
2025 aJob->SetTitleBlock( brd->GetTitleBlock() );
2026 brd->GetProject()->ApplyTextVars( aJob->GetVarOverrides() );
2027 brd->SynchronizeProperties();
2028
2029 if( drcJob->GetConfiguredOutputPath().IsEmpty() )
2030 {
2031 wxFileName fn = brd->GetFileName();
2032 fn.SetName( fn.GetName() + wxS( "-drc" ) );
2033
2034 if( drcJob->m_format == JOB_PCB_DRC::OUTPUT_FORMAT::JSON )
2035 fn.SetExt( FILEEXT::JsonFileExtension );
2036 else
2037 fn.SetExt( FILEEXT::ReportFileExtension );
2038
2039 drcJob->SetWorkingOutputPath( fn.GetFullName() );
2040 }
2041
2042 wxString outPath = drcJob->GetFullOutputPath( brd->GetProject() );
2043
2044 if( !PATHS::EnsurePathExists( outPath, true ) )
2045 {
2046 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
2047 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
2048 }
2049
2050 EDA_UNITS units;
2051
2052 switch( drcJob->m_units )
2053 {
2054 case JOB_PCB_DRC::UNITS::INCH: units = EDA_UNITS::INCH; break;
2055 case JOB_PCB_DRC::UNITS::MILS: units = EDA_UNITS::MILS; break;
2056 case JOB_PCB_DRC::UNITS::MM: units = EDA_UNITS::MM; break;
2057 default: units = EDA_UNITS::MM; break;
2058 }
2059
2060 std::shared_ptr<DRC_ENGINE> drcEngine = brd->GetDesignSettings().m_DRCEngine;
2061 std::unique_ptr<NETLIST> netlist = std::make_unique<NETLIST>();
2062
2063 drcEngine->SetDrawingSheet( getDrawingSheetProxyView( brd ) );
2064
2065 // BOARD_COMMIT uses TOOL_MANAGER to grab the board internally so we must give it one
2066 TOOL_MANAGER* toolManager = new TOOL_MANAGER;
2067 toolManager->SetEnvironment( brd, nullptr, nullptr, Kiface().KifaceSettings(), nullptr );
2068
2069 BOARD_COMMIT commit( toolManager );
2070 bool checkParity = drcJob->m_parity;
2071 std::string netlist_str;
2072
2073 if( checkParity )
2074 {
2075 wxString annotateMsg = _( "Schematic parity tests require a fully annotated schematic." );
2076 netlist_str = annotateMsg;
2077
2078 // The KIFACE_NETLIST_SCHEMATIC function has some broken-ness that the schematic
2079 // frame's version does not, but it is the only one that works in CLI, so we use it
2080 // if we don't have the sch frame open.
2081 // TODO: clean this up, see https://gitlab.com/kicad/code/kicad/-/issues/19929
2082 if( m_kiway->Player( FRAME_SCH, false ) )
2083 {
2084 m_kiway->ExpressMail( FRAME_SCH, MAIL_SCH_GET_NETLIST, netlist_str );
2085 }
2086 else
2087 {
2088 wxFileName schematicPath( drcJob->m_filename );
2089 schematicPath.SetExt( FILEEXT::KiCadSchematicFileExtension );
2090
2091 if( !schematicPath.Exists() )
2092 schematicPath.SetExt( FILEEXT::LegacySchematicFileExtension );
2093
2094 if( !schematicPath.Exists() )
2095 {
2096 m_reporter->Report( _( "Failed to fetch schematic netlist for parity tests.\n" ),
2097 RPT_SEVERITY_ERROR );
2098 checkParity = false;
2099 }
2100 else
2101 {
2102 typedef bool ( *NETLIST_FN_PTR )( const wxString&, std::string& );
2103 KIFACE* eeschema = m_kiway->KiFACE( KIWAY::FACE_SCH );
2104 NETLIST_FN_PTR netlister =
2105 (NETLIST_FN_PTR) eeschema->IfaceOrAddress( KIFACE_NETLIST_SCHEMATIC );
2106 ( *netlister )( schematicPath.GetFullPath(), netlist_str );
2107 }
2108 }
2109
2110 if( netlist_str == annotateMsg )
2111 {
2112 m_reporter->Report( wxString( netlist_str ) + wxT( "\n" ), RPT_SEVERITY_ERROR );
2113 checkParity = false;
2114 }
2115 }
2116
2117 if( checkParity )
2118 {
2119 try
2120 {
2121 STRING_LINE_READER* lineReader = new STRING_LINE_READER( netlist_str,
2122 _( "Eeschema netlist" ) );
2123 KICAD_NETLIST_READER netlistReader( lineReader, netlist.get() );
2124
2125 netlistReader.LoadNetlist();
2126 }
2127 catch( const IO_ERROR& )
2128 {
2129 m_reporter->Report( _( "Failed to fetch schematic netlist for parity tests.\n" ),
2130 RPT_SEVERITY_ERROR );
2131 checkParity = false;
2132 }
2133
2134 drcEngine->SetSchematicNetlist( netlist.get() );
2135 }
2136
2137 drcEngine->SetProgressReporter( m_progressReporter );
2138 drcEngine->SetViolationHandler(
2139 [&]( const std::shared_ptr<DRC_ITEM>& aItem, VECTOR2I aPos, int aLayer,
2140 DRC_CUSTOM_MARKER_HANDLER* aCustomHandler )
2141 {
2142 PCB_MARKER* marker = new PCB_MARKER( aItem, aPos, aLayer );
2143 commit.Add( marker );
2144 } );
2145
2146 brd->RecordDRCExclusions();
2147 brd->DeleteMARKERs( true, true );
2148 drcEngine->RunTests( units, drcJob->m_reportAllTrackErrors, checkParity );
2149 drcEngine->ClearViolationHandler();
2150
2151 commit.Push( _( "DRC" ), SKIP_UNDO | SKIP_SET_DIRTY );
2152
2153 // Update the exclusion status on any excluded markers that still exist.
2154 brd->ResolveDRCExclusions( false );
2155
2156 std::shared_ptr<DRC_ITEMS_PROVIDER> markersProvider = std::make_shared<DRC_ITEMS_PROVIDER>(
2157 brd, MARKER_BASE::MARKER_DRC, MARKER_BASE::MARKER_DRAWING_SHEET );
2158
2159 std::shared_ptr<DRC_ITEMS_PROVIDER> ratsnestProvider =
2160 std::make_shared<DRC_ITEMS_PROVIDER>( brd, MARKER_BASE::MARKER_RATSNEST );
2161
2162 std::shared_ptr<DRC_ITEMS_PROVIDER> fpWarningsProvider =
2163 std::make_shared<DRC_ITEMS_PROVIDER>( brd, MARKER_BASE::MARKER_PARITY );
2164
2165 markersProvider->SetSeverities( drcJob->m_severity );
2166 ratsnestProvider->SetSeverities( drcJob->m_severity );
2167 fpWarningsProvider->SetSeverities( drcJob->m_severity );
2168
2169 m_reporter->Report( wxString::Format( _( "Found %d violations\n" ),
2170 markersProvider->GetCount() ),
2171 RPT_SEVERITY_INFO );
2172 m_reporter->Report( wxString::Format( _( "Found %d unconnected items\n" ),
2173 ratsnestProvider->GetCount() ),
2174 RPT_SEVERITY_INFO );
2175
2176 if( checkParity )
2177 {
2178 m_reporter->Report( wxString::Format( _( "Found %d schematic parity issues\n" ),
2179 fpWarningsProvider->GetCount() ),
2180 RPT_SEVERITY_INFO );
2181 }
2182
2183 DRC_REPORT reportWriter( brd, units, markersProvider, ratsnestProvider, fpWarningsProvider );
2184
2185 bool wroteReport = false;
2186
2187 if( drcJob->m_format == JOB_PCB_DRC::OUTPUT_FORMAT::JSON )
2188 wroteReport = reportWriter.WriteJsonReport( outPath );
2189 else
2190 wroteReport = reportWriter.WriteTextReport( outPath );
2191
2192 if( !wroteReport )
2193 {
2194 m_reporter->Report( wxString::Format( _( "Unable to save DRC report to %s\n" ), outPath ),
2195 RPT_SEVERITY_ERROR );
2196 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
2197 }
2198
2199 m_reporter->Report( wxString::Format( _( "Saved DRC Report to %s\n" ), outPath ),
2200 RPT_SEVERITY_ACTION );
2201
2202 if( drcJob->m_exitCodeViolations )
2203 {
2204 if( markersProvider->GetCount() > 0 || ratsnestProvider->GetCount() > 0
2205 || fpWarningsProvider->GetCount() > 0 )
2206 {
2207 return CLI::EXIT_CODES::ERR_RC_VIOLATIONS;
2208 }
2209 }
2210
2211 return CLI::EXIT_CODES::SUCCESS;
2212}
2213
2214
2215int PCBNEW_JOBS_HANDLER::JobExportIpc2581( JOB* aJob )
2216{
2217 JOB_EXPORT_PCB_IPC2581* job = dynamic_cast<JOB_EXPORT_PCB_IPC2581*>( aJob );
2218
2219 if( job == nullptr )
2220 return CLI::EXIT_CODES::ERR_UNKNOWN;
2221
2222 BOARD* brd = getBoard( job->m_filename );
2223
2224 if( !brd )
2225 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
2226
2227 aJob->SetTitleBlock( brd->GetTitleBlock() );
2228
2229 if( job->GetConfiguredOutputPath().IsEmpty() )
2230 {
2231 wxFileName fn = brd->GetFileName();
2232 fn.SetName( fn.GetName() );
2233 fn.SetExt( FILEEXT::Ipc2581FileExtension );
2234
2235 job->SetWorkingOutputPath( fn.GetName() );
2236 }
2237
2238 wxString outPath = job->GetFullOutputPath( brd->GetProject() );
2239
2240 if( !PATHS::EnsurePathExists( outPath, true ) )
2241 {
2242 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
2243 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
2244 }
2245
2246 std::map<std::string, UTF8> props;
2247 props["units"] = job->m_units == JOB_EXPORT_PCB_IPC2581::IPC2581_UNITS::MM ? "mm" : "inch";
2248 props["sigfig"] = wxString::Format( "%d", job->m_precision );
2249 props["version"] = job->m_version == JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::C ? "C" : "B";
2250 props["OEMRef"] = job->m_colInternalId;
2251 props["mpn"] = job->m_colMfgPn;
2252 props["mfg"] = job->m_colMfg;
2253 props["dist"] = job->m_colDist;
2254 props["distpn"] = job->m_colDistPn;
2255
2256 wxString tempFile = wxFileName::CreateTempFileName( wxS( "pcbnew_ipc" ) );
2257 try
2258 {
2259 IO_RELEASER<PCB_IO> pi( PCB_IO_MGR::PluginFind( PCB_IO_MGR::IPC2581 ) );
2260 pi->SetProgressReporter( m_progressReporter );
2261 pi->SaveBoard( tempFile, brd, &props );
2262 }
2263 catch( const IO_ERROR& ioe )
2264 {
2265 m_reporter->Report( wxString::Format( _( "Error generating IPC-2581 file '%s'.\n%s" ),
2266 job->m_filename,
2267 ioe.What() ),
2268 RPT_SEVERITY_ERROR );
2269
2270 wxRemoveFile( tempFile );
2271
2272 return CLI::EXIT_CODES::ERR_UNKNOWN;
2273 }
2274
2275 if( job->m_compress )
2276 {
2277 wxFileName tempfn = outPath;
2278 tempfn.SetExt( FILEEXT::Ipc2581FileExtension );
2279 wxFileName zipfn = tempFile;
2280 zipfn.SetExt( "zip" );
2281
2282 {
2283 wxFFileOutputStream fnout( zipfn.GetFullPath() );
2284 wxZipOutputStream zip( fnout );
2285 wxFFileInputStream fnin( tempFile );
2286
2287 zip.PutNextEntry( tempfn.GetFullName() );
2288 fnin.Read( zip );
2289 }
2290
2291 wxRemoveFile( tempFile );
2292 tempFile = zipfn.GetFullPath();
2293 }
2294
2295 // If save succeeded, replace the original with what we just wrote
2296 if( !wxRenameFile( tempFile, outPath ) )
2297 {
2298 m_reporter->Report( wxString::Format( _( "Error generating IPC-2581 file '%s'.\n"
2299 "Failed to rename temporary file '%s." ),
2300 outPath,
2301 tempFile ),
2302 RPT_SEVERITY_ERROR );
2303 }
2304
2305 return CLI::EXIT_CODES::SUCCESS;
2306}
2307
2308
2309int PCBNEW_JOBS_HANDLER::JobExportIpcD356( JOB* aJob )
2310{
2311 JOB_EXPORT_PCB_IPCD356* job = dynamic_cast<JOB_EXPORT_PCB_IPCD356*>( aJob );
2312
2313 if( job == nullptr )
2314 return CLI::EXIT_CODES::ERR_UNKNOWN;
2315
2316 BOARD* brd = getBoard( job->m_filename );
2317
2318 if( !brd )
2319 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
2320
2321 aJob->SetTitleBlock( brd->GetTitleBlock() );
2322
2323 if( job->GetConfiguredOutputPath().IsEmpty() )
2324 {
2325 wxFileName fn = brd->GetFileName();
2326 fn.SetName( fn.GetName() );
2327 fn.SetExt( FILEEXT::IpcD356FileExtension );
2328
2329 job->SetWorkingOutputPath( fn.GetFullName() );
2330 }
2331
2332 wxString outPath = job->GetFullOutputPath( brd->GetProject() );
2333
2334 if( !PATHS::EnsurePathExists( outPath, true ) )
2335 {
2336 m_reporter->Report( _( "Failed to create output directory\n" ), RPT_SEVERITY_ERROR );
2337 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
2338 }
2339
2340 IPC356D_WRITER exporter( brd );
2341
2342 bool success = exporter.Write( outPath );
2343
2344 if( success )
2345 {
2346 m_reporter->Report( _( "Successfully created IPC-D-356 file\n" ), RPT_SEVERITY_INFO );
2347 return CLI::EXIT_CODES::SUCCESS;
2348 }
2349 else
2350 {
2351 m_reporter->Report( _( "Failed to create IPC-D-356 file\n" ), RPT_SEVERITY_ERROR );
2352 return CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT;
2353 }
2354}
2355
2356
2357int PCBNEW_JOBS_HANDLER::JobExportOdb( JOB* aJob )
2358{
2359 JOB_EXPORT_PCB_ODB* job = dynamic_cast<JOB_EXPORT_PCB_ODB*>( aJob );
2360
2361 if( job == nullptr )
2362 return CLI::EXIT_CODES::ERR_UNKNOWN;
2363
2364 BOARD* brd = getBoard( job->m_filename );
2365
2366 if( !brd )
2367 return CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE;
2368
2369 aJob->SetTitleBlock( brd->GetTitleBlock() );
2370
2371 wxString path = job->GetConfiguredOutputPath();
2372
2373 if( job->GetConfiguredOutputPath().IsEmpty() )
2374 {
2375 if( job->m_compressionMode == JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::NONE )
2376 {
2377 // just basic folder name
2378 job->SetWorkingOutputPath( "odb" );
2379 }
2380 else
2381 {
2382 wxFileName fn( brd->GetFileName() );
2383 fn.SetName( fn.GetName() + wxS( "-odb" ) );
2384
2385 switch( job->m_compressionMode )
2386 {
2387 case JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::ZIP:
2388 fn.SetExt( FILEEXT::ArchiveFileExtension );
2389 break;
2390 case JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::TGZ:
2391 fn.SetExt( "tgz" );
2392 break;
2393 default:
2394 break;
2395 };
2396
2397 job->SetWorkingOutputPath( fn.GetFullName() );
2398 }
2399 }
2400
2401 DIALOG_EXPORT_ODBPP::GenerateODBPPFiles( *job, brd, nullptr, m_progressReporter, m_reporter );
2402
2403 return CLI::EXIT_CODES::SUCCESS;
2404}
2405
2406
2407DS_PROXY_VIEW_ITEM* PCBNEW_JOBS_HANDLER::getDrawingSheetProxyView( BOARD* aBrd )
2408{
2409 DS_PROXY_VIEW_ITEM* drawingSheet = new DS_PROXY_VIEW_ITEM( pcbIUScale,
2410 &aBrd->GetPageSettings(),
2411 aBrd->GetProject(),
2412 &aBrd->GetTitleBlock(),
2413 &aBrd->GetProperties() );
2414
2415 drawingSheet->SetSheetName( std::string() );
2416 drawingSheet->SetSheetPath( std::string() );
2417 drawingSheet->SetIsFirstPage( true );
2418
2419 drawingSheet->SetFileName( TO_UTF8( aBrd->GetFileName() ) );
2420
2421 return drawingSheet;
2422}
2423
2424
2425void PCBNEW_JOBS_HANDLER::loadOverrideDrawingSheet( BOARD* aBrd, const wxString& aSheetPath )
2426{
2427 // dont bother attempting to load a empty path, if there was one
2428 if( aSheetPath.IsEmpty() )
2429 return;
2430
2431 auto loadSheet =
2432 [&]( const wxString& path ) -> bool
2433 {
2434 BASE_SCREEN::m_DrawingSheetFileName = path;
2435 FILENAME_RESOLVER resolver;
2436 resolver.SetProject( aBrd->GetProject() );
2437 resolver.SetProgramBase( &Pgm() );
2438
2439 wxString filename = resolver.ResolvePath( BASE_SCREEN::m_DrawingSheetFileName,
2440 aBrd->GetProject()->GetProjectPath(),
2441 { aBrd->GetEmbeddedFiles() } );
2442 wxString msg;
2443
2444 if( !DS_DATA_MODEL::GetTheInstance().LoadDrawingSheet( filename, &msg ) )
2445 {
2446 m_reporter->Report( wxString::Format( _( "Error loading drawing sheet '%s'." ),
2447 path )
2448 + wxS( "\n" ) + msg + wxS( "\n" ),
2449 RPT_SEVERITY_ERROR );
2450 return false;
2451 }
2452
2453 return true;
2454 };
2455
2456 if( loadSheet( aSheetPath ) )
2457 return;
2458
2459 // failed loading custom path, revert back to default
2460 loadSheet( aBrd->GetProject()->GetProjectFile().m_BoardDrawingSheetFile );
2461}
pcbIUScale
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:112
Kiface
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
Definition: bitmap2cmp_main.cpp:73
BITMAPS::pad
@ pad
BITMAPS::netlist
@ netlist
BITMAPS::image
@ image
BITMAPS::zip
@ zip
BITMAPS::eeschema
@ eeschema
BITMAPS::path
@ path
BITMAPS::find
@ find
RANGE_SCALE_3D
#define RANGE_SCALE_3D
This defines the range that all coord will have to be rendered.
Definition: board_adapter.h:66
board_commit.h
board_design_settings.h
PROJECTION_TYPE
PROJECTION_TYPE
Definition: camera.h:40
BASE_SCREEN::m_DrawingSheetFileName
static wxString m_DrawingSheetFileName
the name of the drawing sheet file, or empty to use the default drawing sheet
Definition: base_screen.h:85
BOARD_ADAPTER
Helper class to handle information needed to display 3D board.
Definition: board_adapter.h:73
BOARD_ADAPTER::BiuTo3dUnits
double BiuTo3dUnits() const noexcept
Board integer units To 3D units.
Definition: board_adapter.h:137
BOARD_ADAPTER::m_IsBoardView
bool m_IsBoardView
Definition: board_adapter.h:429
BOARD_ADAPTER::m_IsPreviewer
bool m_IsPreviewer
true if we're in a 3D preview panel, false for the standard 3D viewer
Definition: board_adapter.h:431
BOARD_ADAPTER::SetBoard
void SetBoard(BOARD *aBoard) noexcept
Set current board to be rendered.
Definition: board_adapter.h:105
BOARD_ADAPTER::m_Cfg
EDA_3D_VIEWER_SETTINGS * m_Cfg
Definition: board_adapter.h:427
BOARD_ADAPTER::m_ColorOverrides
std::map< int, COLOR4D > m_ColorOverrides
allows to override color scheme colors
Definition: board_adapter.h:449
BOARD_ADAPTER::Set3dCacheManager
void Set3dCacheManager(S3D_CACHE *aCacheMgr) noexcept
Update the cache manager pointer.
Definition: board_adapter.h:84
BOARD_COMMIT
Definition: board_commit.h:49
BOARD_COMMIT::Push
virtual void Push(const wxString &aMessage=wxEmptyString, int aCommitFlags=0) override
Execute the changes.
Definition: board_commit.cpp:177
BOARD_DESIGN_SETTINGS::m_DRCEngine
std::shared_ptr< DRC_ENGINE > m_DRCEngine
Definition: board_design_settings.h:727
BOARD_DESIGN_SETTINGS::GetAuxOrigin
const VECTOR2I & GetAuxOrigin() const
Definition: board_design_settings.h:675
BOARD
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:317
BOARD::GetEmbeddedFiles
EMBEDDED_FILES * GetEmbeddedFiles() override
Definition: board.cpp:2628
BOARD::GetPageSettings
const PAGE_INFO & GetPageSettings() const
Definition: board.h:740
BOARD::RecordDRCExclusions
void RecordDRCExclusions()
Scan existing markers and record data from any that are Excluded.
Definition: board.cpp:328
BOARD::GetTitleBlock
TITLE_BLOCK & GetTitleBlock()
Definition: board.h:746
BOARD::ComputeBoundingBox
BOX2I ComputeBoundingBox(bool aBoardEdgesOnly=false) const
Calculate the bounding box containing all board items (or board edge segments).
Definition: board.cpp:1822
BOARD::GetProperties
const std::map< wxString, wxString > & GetProperties() const
Definition: board.h:393
BOARD::GetFileName
const wxString & GetFileName() const
Definition: board.h:354
BOARD::ResolveDRCExclusions
std::vector< PCB_MARKER * > ResolveDRCExclusions(bool aCreateMarkers)
Rebuild DRC markers from the serialized data in BOARD_DESIGN_SETTINGS.
Definition: board.cpp:385
BOARD::GetPlotOptions
const PCB_PLOT_PARAMS & GetPlotOptions() const
Definition: board.h:743
BOARD::GetLayerName
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition: board.cpp:679
BOARD::GetProject
PROJECT * GetProject() const
Definition: board.h:536
BOARD::GetDesignSettings
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.cpp:1011
BOARD::GetEnabledLayers
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:894
BOARD::SynchronizeProperties
void SynchronizeProperties()
Copy the current project's text variables into the boards property cache.
Definition: board.cpp:2192
BOARD::DeleteMARKERs
void DeleteMARKERs()
Delete all MARKERS from the board.
Definition: board.cpp:1501
BOX2::GetCenter
constexpr const Vec GetCenter() const
Definition: box2.h:230
CAMERA::SetProjection
void SetProjection(PROJECTION_TYPE aProjection)
Definition: camera.h:206
CAMERA::RotateY_T1
void RotateY_T1(float aAngleInRadians)
Definition: camera.cpp:686
CAMERA::Zoom_T1
bool Zoom_T1(float aFactor)
Definition: camera.cpp:629
CAMERA::SetCurWindowSize
bool SetCurWindowSize(const wxSize &aSize)
Update the windows size of the camera.
Definition: camera.cpp:571
CAMERA::ViewCommand_T1
bool ViewCommand_T1(VIEW3D_TYPE aRequestedView)
Definition: camera.cpp:110
CAMERA::RotateX_T1
void RotateX_T1(float aAngleInRadians)
Definition: camera.cpp:680
CAMERA::SetLookAtPos_T1
void SetLookAtPos_T1(const SFVEC3F &aLookAtPos)
Definition: camera.h:162
CAMERA::GetLookAtPos_T1
const SFVEC3F & GetLookAtPos_T1() const
Definition: camera.h:167
CAMERA::RotateZ_T1
void RotateZ_T1(float aAngleInRadians)
Definition: camera.cpp:692
CAMERA::ParametersChanged
bool ParametersChanged()
Definition: camera.cpp:730
COMMIT::Add
COMMIT & Add(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Add a new item to the model.
Definition: commit.h:79
DIALOG_DRC_JOB_CONFIG
Definition: dialog_drc_job_config.h:25
DIALOG_EXPORT_2581
Definition: dialog_export_2581.h:28
DIALOG_EXPORT_ODBPP
Definition: dialog_export_odbpp.h:31
DIALOG_EXPORT_ODBPP::GenerateODBPPFiles
static void GenerateODBPPFiles(const JOB_EXPORT_PCB_ODB &aJob, BOARD *aBoard, PCB_EDIT_FRAME *aParentFrame=nullptr, PROGRESS_REPORTER *aProgressReporter=nullptr, REPORTER *aErrorReporter=nullptr)
Definition: dialog_export_odbpp.cpp:289
DIALOG_EXPORT_STEP
Definition: dialog_export_step.h:33
DIALOG_GENCAD_EXPORT_OPTIONS
Definition: dialog_gencad_export_options.h:56
DIALOG_GENDRILL
Definition: dialog_gendrill.h:34
DIALOG_GEN_FOOTPRINT_POSITION
The dialog to create footprint position files and choose options (one or 2 files, units and force all...
Definition: dialog_gen_footprint_position.h:37
DIALOG_PLOT
A dialog to set the plot options and create plot files in various formats.
Definition: dialog_plot.h:41
DIALOG_RENDER_JOB
Definition: dialog_render_job.h:27
DIALOG_SHIM::ShowModal
int ShowModal() override
Definition: dialog_shim.cpp:454
DRC_REPORT
Definition: drc_report.h:31
DRC_REPORT::WriteJsonReport
bool WriteJsonReport(const wxString &aFullFileName)
Definition: drc_report.cpp:114
DRC_REPORT::WriteTextReport
bool WriteTextReport(const wxString &aFullFileName)
Definition: drc_report.cpp:47
DRILL_PRECISION
Helper to handle drill precision format in excellon files.
Definition: gendrill_file_writer_base.h:153
DRILL_PRECISION::m_Lhs
int m_Lhs
Definition: gendrill_file_writer_base.h:169
DRILL_PRECISION::m_Rhs
int m_Rhs
Definition: gendrill_file_writer_base.h:170
DS_DATA_MODEL::LoadDrawingSheet
bool LoadDrawingSheet(const wxString &aFullFileName, wxString *aMsg, bool aAppend=false)
Populate the list with a custom layout or the default layout if no custom layout is available.
Definition: drawing_sheet_parser.cpp:971
DS_DATA_MODEL::GetTheInstance
static DS_DATA_MODEL & GetTheInstance()
Return the instance of DS_DATA_MODEL used in the application.
Definition: ds_data_model.cpp:76
DS_PROXY_VIEW_ITEM
Definition: ds_proxy_view_item.h:48
DS_PROXY_VIEW_ITEM::SetSheetPath
void SetSheetPath(const std::string &aSheetPath)
Set the sheet path displayed in the title block.
Definition: ds_proxy_view_item.h:67
DS_PROXY_VIEW_ITEM::SetSheetName
void SetSheetName(const std::string &aSheetName)
Set the sheet name displayed in the title block.
Definition: ds_proxy_view_item.h:62
DS_PROXY_VIEW_ITEM::SetIsFirstPage
void SetIsFirstPage(bool aIsFirstPage)
Change if this is first page.
Definition: ds_proxy_view_item.h:85
DS_PROXY_VIEW_ITEM::SetFileName
void SetFileName(const std::string &aFileName)
Set the file name displayed in the title block.
Definition: ds_proxy_view_item.h:57
EDA_3D_VIEWER_SETTINGS
Definition: eda_3d_viewer_settings.h:76
EDA_3D_VIEWER_SETTINGS::m_CurrentPreset
wxString m_CurrentPreset
Definition: eda_3d_viewer_settings.h:194
EDA_3D_VIEWER_SETTINGS::m_Camera
CAMERA_SETTINGS m_Camera
Definition: eda_3d_viewer_settings.h:190
EDA_3D_VIEWER_SETTINGS::m_LayerPresets
std::vector< LAYER_PRESET_3D > m_LayerPresets
Definition: eda_3d_viewer_settings.h:193
EDA_3D_VIEWER_SETTINGS::m_Render
RENDER_SETTINGS m_Render
Definition: eda_3d_viewer_settings.h:189
EDA_ITEM::SetFlags
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:141
EDA_ITEM::SetParent
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:112
EXCELLON_WRITER
Create Excellon drill, drill map, and drill report files.
Definition: gendrill_Excellon_writer.h:45
EXCELLON_WRITER::SetFormat
void SetFormat(bool aMetric, ZEROS_FMT aZerosFmt=DECIMAL_FORMAT, int aLeftDigits=0, int aRightDigits=0)
Initialize internal parameters to match the given format.
Definition: gendrill_Excellon_writer.cpp:358
EXCELLON_WRITER::CreateDrillandMapFilesSet
bool CreateDrillandMapFilesSet(const wxString &aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER *aReporter=nullptr)
Create the full set of Excellon drill file for the board.
Definition: gendrill_Excellon_writer.cpp:76
EXCELLON_WRITER::SetOptions
void SetOptions(bool aMirror, bool aMinimalHeader, const VECTOR2I &aOffset, bool aMerge_PTH_NPTH)
Initialize internal parameters to match drill options.
Definition: gendrill_Excellon_writer.h:89
EXCELLON_WRITER::SetRouteModeForOvalHoles
void SetRouteModeForOvalHoles(bool aUseRouteModeForOvalHoles)
Definition: gendrill_Excellon_writer.h:61
EXPORTER_STEP_PARAMS
Definition: job_export_pcb_3d.h:33
EXPORTER_STEP_PARAMS::m_IncludeUnspecified
bool m_IncludeUnspecified
Definition: job_export_pcb_3d.h:84
EXPORTER_STEP_PARAMS::m_IncludeDNP
bool m_IncludeDNP
Definition: job_export_pcb_3d.h:85
EXPORTER_STEP_PARAMS::m_Origin
VECTOR2D m_Origin
Definition: job_export_pcb_3d.h:77
EXPORTER_STEP_PARAMS::m_Format
FORMAT m_Format
Definition: job_export_pcb_3d.h:101
EXPORTER_STEP_PARAMS::FORMAT::BREP
@ BREP
EXPORTER_STEP_PARAMS::FORMAT::STL
@ STL
EXPORTER_STEP_PARAMS::FORMAT::PLY
@ PLY
EXPORTER_STEP_PARAMS::FORMAT::STEP
@ STEP
EXPORTER_STEP_PARAMS::FORMAT::XAO
@ XAO
EXPORTER_STEP_PARAMS::FORMAT::STEPZ
@ STEPZ
EXPORTER_STEP_PARAMS::FORMAT::GLB
@ GLB
EXPORTER_STEP
Definition: exporter_step.h:47
EXPORTER_STEP::Export
bool Export()
Definition: exporter_step.cpp:812
EXPORTER_STEP::m_outputFile
wxString m_outputFile
Definition: exporter_step.h:54
EXPORTER_VRML
Wrapper to expose an API for writing VRML files, without exposing all the many structures used in the...
Definition: export_vrml.h:33
EXPORTER_VRML::ExportVRML_File
bool ExportVRML_File(PROJECT *aProject, wxString *aMessages, const wxString &aFullFileName, double aMMtoWRMLunit, bool aIncludeUnspecified, bool aIncludeDNP, bool aExport3DFiles, bool aUseRelativePaths, const wxString &a3D_Subdir, double aXRef, double aYRef)
Exports the board and its footprint shapes 3D (vrml files only) as a vrml file.
Definition: exporter_vrml.cpp:61
FILENAME_RESOLVER
Provide an extensible class to resolve 3D model paths.
Definition: filename_resolver.h:58
FILENAME_RESOLVER::ResolvePath
wxString ResolvePath(const wxString &aFileName, const wxString &aWorkingPath, std::vector< const EMBEDDED_FILES * > aEmbeddedFilesStack)
Determine the full path of the given file name.
Definition: filename_resolver.cpp:246
FILENAME_RESOLVER::SetProgramBase
void SetProgramBase(PGM_BASE *aBase)
Set a pointer to the application's PGM_BASE instance used to extract the local env vars.
Definition: filename_resolver.cpp:146
FILENAME_RESOLVER::SetProject
bool SetProject(const PROJECT *aProject, bool *flgChanged=nullptr)
Set the current KiCad project directory as the first entry in the model path list.
Definition: filename_resolver.cpp:81
FOOTPRINT::SetPosition
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2465
FOOTPRINT::SetLink
void SetLink(const KIID &aLink)
Definition: footprint.h:842
FOOTPRINT::SetOrientation
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition: footprint.cpp:2547
FOOTPRINT::Clone
EDA_ITEM * Clone() const override
Invoke a function on all children.
Definition: footprint.cpp:2202
FOOTPRINT::Pads
std::deque< PAD * > & Pads()
Definition: footprint.h:209
FOOTPRINT::GetFPID
const LIB_ID & GetFPID() const
Definition: footprint.h:251
FP_CACHE
Definition: pcb_io_kicad_sexpr.h:230
FP_CACHE::SetPath
void SetPath(const wxString &aPath)
Definition: pcb_io_kicad_sexpr.cpp:261
FP_CACHE::Load
void Load()
Definition: pcb_io_kicad_sexpr.cpp:173
FP_CACHE::Save
void Save(FOOTPRINT *aFootprintFilter=nullptr)
Save the footprint cache or a single footprint from it to disk.
Definition: pcb_io_kicad_sexpr.cpp:91
FP_CACHE::GetFootprints
boost::ptr_map< wxString, FP_CACHE_ENTRY > & GetFootprints()
Definition: pcb_io_kicad_sexpr.h:252
GENCAD_EXPORTER
Export board to GenCAD file format.
Definition: export_gencad_writer.h:30
GENCAD_EXPORTER::UseIndividualShapes
void UseIndividualShapes(bool aUnique)
Make pad shapes unique.
Definition: export_gencad_writer.h:60
GENCAD_EXPORTER::UsePinNamesUnique
void UsePinNamesUnique(bool aUnique)
Make pin names unique.
Definition: export_gencad_writer.h:57
GENCAD_EXPORTER::StoreOriginCoordsInFile
void StoreOriginCoordsInFile(bool aStore)
Store origin coordinate in GenCAD file.
Definition: export_gencad_writer.h:63
GENCAD_EXPORTER::FlipBottomPads
void FlipBottomPads(bool aFlip)
Flip pad shapes on the bottom side.
Definition: export_gencad_writer.h:54
GENCAD_EXPORTER::SetPlotOffet
void SetPlotOffet(VECTOR2I aOffset)
Set the coordinates offset when exporting items.
Definition: export_gencad_writer.h:51
GENCAD_EXPORTER::WriteFile
bool WriteFile(const wxString &aFullFileName)
Export a GenCAD file.
Definition: export_gencad_writer.cpp:156
GENDRILL_WRITER_BASE::SetMapFileFormat
void SetMapFileFormat(PLOT_FORMAT aMapFmt)
Initialize the format for the drill map file.
Definition: gendrill_file_writer_base.h:230
GENDRILL_WRITER_BASE::ZEROS_FMT
ZEROS_FMT
Definition: gendrill_file_writer_base.h:184
GENDRILL_WRITER_BASE::SUPPRESS_TRAILING
@ SUPPRESS_TRAILING
Definition: gendrill_file_writer_base.h:187
GENDRILL_WRITER_BASE::DECIMAL_FORMAT
@ DECIMAL_FORMAT
Definition: gendrill_file_writer_base.h:185
GENDRILL_WRITER_BASE::KEEP_ZEROS
@ KEEP_ZEROS
Definition: gendrill_file_writer_base.h:188
GENDRILL_WRITER_BASE::SUPPRESS_LEADING
@ SUPPRESS_LEADING
Definition: gendrill_file_writer_base.h:186
GERBER_JOBFILE_WRITER
GERBER_JOBFILE_WRITER is a class used to create Gerber job file a Gerber job file stores info to make...
Definition: gerber_jobfile_writer.h:72
GERBER_JOBFILE_WRITER::CreateJobFile
bool CreateJobFile(const wxString &aFullFilename)
Creates a Gerber job file.
Definition: gerber_jobfile_writer.cpp:121
GERBER_JOBFILE_WRITER::AddGbrFile
void AddGbrFile(PCB_LAYER_ID aLayer, wxString &aFilename)
add a gerber file name and type in job file list
Definition: gerber_jobfile_writer.h:85
GERBER_PLOTTER
Definition: plotter_gerber.h:30
GERBER_PLOTTER::EndPlot
virtual bool EndPlot() override
Definition: GERBER_plotter.cpp:319
GERBER_WRITER
Used to create Gerber drill files.
Definition: gendrill_gerber_writer.h:41
GERBER_WRITER::CreateDrillandMapFilesSet
bool CreateDrillandMapFilesSet(const wxString &aPlotDirectory, bool aGenDrill, bool aGenMap, bool aGenTenting, REPORTER *aReporter=nullptr)
Create the full set of Excellon drill file for the board filenames are computed from the board name,...
Definition: gendrill_gerber_writer.cpp:60
GERBER_WRITER::SetOptions
void SetOptions(const VECTOR2I &aOffset)
Initialize internal parameters to match drill options.
Definition: gendrill_gerber_writer.h:63
GERBER_WRITER::SetFormat
void SetFormat(int aRightDigits=6)
Initialize internal parameters to match the given format.
Definition: gendrill_gerber_writer.cpp:475
IO_ERROR
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
IO_ERROR::What
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
IPC356D_WRITER
Wrapper to expose an API for writing IPC-D356 files.
Definition: export_d356.h:54
IPC356D_WRITER::Write
bool Write(const wxString &aFilename)
Generates and writes the netlist to a given path.
Definition: export_d356.cpp:354
JOB_DISPATCHER
Definition: job_dispatcher.h:37
JOB_DISPATCHER::Register
void Register(const std::string &aJobTypeName, std::function< int(JOB *job)> aHandler, std::function< bool(JOB *job, wxWindow *aParent)> aConfigHandler)
Definition: job_dispatcher.cpp:36
JOB_DISPATCHER::m_progressReporter
PROGRESS_REPORTER * m_progressReporter
Definition: job_dispatcher.h:50
JOB_DISPATCHER::m_kiway
KIWAY * m_kiway
Definition: job_dispatcher.h:48
JOB_DISPATCHER::m_reporter
REPORTER * m_reporter
Definition: job_dispatcher.h:49
JOB_EXPORT_PCB_3D
Definition: job_export_pcb_3d.h:110
JOB_EXPORT_PCB_3D::FORMAT::BREP
@ BREP
JOB_EXPORT_PCB_3D::FORMAT::STL
@ STL
JOB_EXPORT_PCB_3D::FORMAT::PLY
@ PLY
JOB_EXPORT_PCB_3D::FORMAT::STEP
@ STEP
JOB_EXPORT_PCB_3D::FORMAT::XAO
@ XAO
JOB_EXPORT_PCB_3D::FORMAT::STEPZ
@ STEPZ
JOB_EXPORT_PCB_3D::FORMAT::VRML
@ VRML
JOB_EXPORT_PCB_3D::FORMAT::GLB
@ GLB
JOB_EXPORT_PCB_3D::m_hasUserOrigin
bool m_hasUserOrigin
Definition: job_export_pcb_3d.h:140
JOB_EXPORT_PCB_3D::m_vrmlUnits
VRML_UNITS m_vrmlUnits
Definition: job_export_pcb_3d.h:148
JOB_EXPORT_PCB_3D::VRML_UNITS::INCH
@ INCH
JOB_EXPORT_PCB_3D::VRML_UNITS::METERS
@ METERS
JOB_EXPORT_PCB_3D::VRML_UNITS::MM
@ MM
JOB_EXPORT_PCB_3D::VRML_UNITS::TENTHS
@ TENTHS
JOB_EXPORT_PCB_3D::m_format
JOB_EXPORT_PCB_3D::FORMAT m_format
Definition: job_export_pcb_3d.h:143
JOB_EXPORT_PCB_3D::m_filename
wxString m_filename
Definition: job_export_pcb_3d.h:141
JOB_EXPORT_PCB_3D::m_vrmlRelativePaths
bool m_vrmlRelativePaths
Definition: job_export_pcb_3d.h:150
JOB_EXPORT_PCB_3D::m_vrmlModelDir
wxString m_vrmlModelDir
Definition: job_export_pcb_3d.h:149
JOB_EXPORT_PCB_3D::m_3dparams
EXPORTER_STEP_PARAMS m_3dparams
Despite the name; also used for other formats.
Definition: job_export_pcb_3d.h:146
JOB_EXPORT_PCB_DRILL
Definition: job_export_pcb_drill.h:29
JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::EXCELLON
@ EXCELLON
JOB_EXPORT_PCB_DRILL::DRILL_FORMAT::GERBER
@ GERBER
JOB_EXPORT_PCB_DRILL::DRILL_UNITS::INCH
@ INCH
JOB_EXPORT_PCB_DRILL::DRILL_UNITS::MM
@ MM
JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::DECIMAL
@ DECIMAL
JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::KEEP_ZEROS
@ KEEP_ZEROS
JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_LEADING
@ SUPPRESS_LEADING
JOB_EXPORT_PCB_DRILL::ZEROS_FORMAT::SUPPRESS_TRAILING
@ SUPPRESS_TRAILING
JOB_EXPORT_PCB_DRILL::DRILL_ORIGIN::ABS
@ ABS
JOB_EXPORT_PCB_DRILL::m_zeroFormat
ZEROS_FORMAT m_zeroFormat
Definition: job_export_pcb_drill.h:82
JOB_EXPORT_PCB_DRILL::m_drillUnits
DRILL_UNITS m_drillUnits
Definition: job_export_pcb_drill.h:81
JOB_EXPORT_PCB_DRILL::m_format
DRILL_FORMAT m_format
Definition: job_export_pcb_drill.h:79
JOB_EXPORT_PCB_DRILL::m_excellonMirrorY
bool m_excellonMirrorY
Definition: job_export_pcb_drill.h:74
JOB_EXPORT_PCB_DRILL::m_excellonOvalDrillRoute
bool m_excellonOvalDrillRoute
Definition: job_export_pcb_drill.h:77
JOB_EXPORT_PCB_DRILL::m_filename
wxString m_filename
Definition: job_export_pcb_drill.h:72
JOB_EXPORT_PCB_DRILL::m_drillOrigin
DRILL_ORIGIN m_drillOrigin
Definition: job_export_pcb_drill.h:80
JOB_EXPORT_PCB_DRILL::m_generateMap
bool m_generateMap
Definition: job_export_pcb_drill.h:86
JOB_EXPORT_PCB_DRILL::m_excellonCombinePTHNPTH
bool m_excellonCombinePTHNPTH
Definition: job_export_pcb_drill.h:76
JOB_EXPORT_PCB_DRILL::m_excellonMinimalHeader
bool m_excellonMinimalHeader
Definition: job_export_pcb_drill.h:75
JOB_EXPORT_PCB_DRILL::m_mapFormat
MAP_FORMAT m_mapFormat
Definition: job_export_pcb_drill.h:84
JOB_EXPORT_PCB_DRILL::MAP_FORMAT::DXF
@ DXF
JOB_EXPORT_PCB_DRILL::MAP_FORMAT::PDF
@ PDF
JOB_EXPORT_PCB_DRILL::MAP_FORMAT::SVG
@ SVG
JOB_EXPORT_PCB_DRILL::MAP_FORMAT::GERBER_X2
@ GERBER_X2
JOB_EXPORT_PCB_DRILL::MAP_FORMAT::POSTSCRIPT
@ POSTSCRIPT
JOB_EXPORT_PCB_DRILL::m_generateTenting
bool m_generateTenting
Definition: job_export_pcb_drill.h:88
JOB_EXPORT_PCB_DRILL::m_gerberPrecision
int m_gerberPrecision
Definition: job_export_pcb_drill.h:85
JOB_EXPORT_PCB_DXF
Definition: job_export_pcb_dxf.h:31
JOB_EXPORT_PCB_DXF::GEN_MODE::SINGLE
@ SINGLE
JOB_EXPORT_PCB_DXF::m_genMode
GEN_MODE m_genMode
Definition: job_export_pcb_dxf.h:54
JOB_EXPORT_PCB_GENCAD
Definition: job_export_pcb_gencad.h:30
JOB_EXPORT_PCB_GENCAD::m_filename
wxString m_filename
Definition: job_export_pcb_gencad.h:36
JOB_EXPORT_PCB_GENCAD::m_useUniquePins
bool m_useUniquePins
Definition: job_export_pcb_gencad.h:42
JOB_EXPORT_PCB_GENCAD::m_flipBottomPads
bool m_flipBottomPads
Definition: job_export_pcb_gencad.h:38
JOB_EXPORT_PCB_GENCAD::m_useDrillOrigin
bool m_useDrillOrigin
Definition: job_export_pcb_gencad.h:41
JOB_EXPORT_PCB_GENCAD::m_storeOriginCoords
bool m_storeOriginCoords
Definition: job_export_pcb_gencad.h:40
JOB_EXPORT_PCB_GENCAD::m_useIndividualShapes
bool m_useIndividualShapes
Definition: job_export_pcb_gencad.h:39
JOB_EXPORT_PCB_GERBERS
Definition: job_export_pcb_gerbers.h:31
JOB_EXPORT_PCB_GERBERS::m_createJobsFile
bool m_createJobsFile
Definition: job_export_pcb_gerbers.h:39
JOB_EXPORT_PCB_GERBERS::m_useBoardPlotParams
bool m_useBoardPlotParams
Definition: job_export_pcb_gerbers.h:37
JOB_EXPORT_PCB_GERBER
Definition: job_export_pcb_gerber.h:30
JOB_EXPORT_PCB_IPC2581
Definition: job_export_pcb_ipc2581.h:28
JOB_EXPORT_PCB_IPC2581::m_colMfgPn
wxString m_colMfgPn
Definition: job_export_pcb_ipc2581.h:59
JOB_EXPORT_PCB_IPC2581::m_colDist
wxString m_colDist
Definition: job_export_pcb_ipc2581.h:62
JOB_EXPORT_PCB_IPC2581::m_colInternalId
wxString m_colInternalId
Definition: job_export_pcb_ipc2581.h:58
JOB_EXPORT_PCB_IPC2581::m_colMfg
wxString m_colMfg
Definition: job_export_pcb_ipc2581.h:60
JOB_EXPORT_PCB_IPC2581::m_precision
int m_precision
Definition: job_export_pcb_ipc2581.h:54
JOB_EXPORT_PCB_IPC2581::m_colDistPn
wxString m_colDistPn
Definition: job_export_pcb_ipc2581.h:61
JOB_EXPORT_PCB_IPC2581::m_version
IPC2581_VERSION m_version
Definition: job_export_pcb_ipc2581.h:53
JOB_EXPORT_PCB_IPC2581::m_filename
wxString m_filename
Definition: job_export_pcb_ipc2581.h:49
JOB_EXPORT_PCB_IPC2581::m_units
IPC2581_UNITS m_units
Definition: job_export_pcb_ipc2581.h:52
JOB_EXPORT_PCB_IPC2581::IPC2581_VERSION::C
@ C
JOB_EXPORT_PCB_IPC2581::m_compress
bool m_compress
Definition: job_export_pcb_ipc2581.h:56
JOB_EXPORT_PCB_IPC2581::IPC2581_UNITS::MM
@ MM
JOB_EXPORT_PCB_IPCD356
Definition: job_export_pcb_ipcd356.h:28
JOB_EXPORT_PCB_IPCD356::m_filename
wxString m_filename
Definition: job_export_pcb_ipcd356.h:36
JOB_EXPORT_PCB_ODB
Definition: job_export_pcb_odb.h:27
JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::ZIP
@ ZIP
JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::NONE
@ NONE
JOB_EXPORT_PCB_ODB::ODB_COMPRESSION::TGZ
@ TGZ
JOB_EXPORT_PCB_ODB::m_filename
wxString m_filename
Definition: job_export_pcb_odb.h:49
JOB_EXPORT_PCB_ODB::m_compressionMode
ODB_COMPRESSION m_compressionMode
Definition: job_export_pcb_odb.h:55
JOB_EXPORT_PCB_PDF
Definition: job_export_pcb_pdf.h:32
JOB_EXPORT_PCB_PDF::GEN_MODE::ALL_LAYERS_ONE_FILE
@ ALL_LAYERS_ONE_FILE
DEPRECATED MODE.
JOB_EXPORT_PCB_PDF::m_pdfGenMode
GEN_MODE m_pdfGenMode
The background color specified in a hex string.
Definition: job_export_pcb_pdf.h:58
JOB_EXPORT_PCB_PLOT::m_plotOnAllLayersSequence
LSEQ m_plotOnAllLayersSequence
Used by SVG & PDF.
Definition: job_export_pcb_plot.h:75
JOB_EXPORT_PCB_PLOT::m_argLayers
std::optional< wxString > m_argLayers
Definition: job_export_pcb_plot.h:45
JOB_EXPORT_PCB_PLOT::m_filename
wxString m_filename
Definition: job_export_pcb_plot.h:50
JOB_EXPORT_PCB_PLOT::m_drawingSheet
wxString m_drawingSheet
Definition: job_export_pcb_plot.h:52
JOB_EXPORT_PCB_PLOT::m_argCommonLayers
std::optional< wxString > m_argCommonLayers
Definition: job_export_pcb_plot.h:46
JOB_EXPORT_PCB_PLOT::m_plotLayerSequence
LSEQ m_plotLayerSequence
Layers to include on all individual layer prints.
Definition: job_export_pcb_plot.h:73
JOB_EXPORT_PCB_POS
Definition: job_export_pcb_pos.h:29
JOB_EXPORT_PCB_POS::m_singleFile
bool m_singleFile
Definition: job_export_pcb_pos.h:65
JOB_EXPORT_PCB_POS::m_negateBottomX
bool m_negateBottomX
Definition: job_export_pcb_pos.h:64
JOB_EXPORT_PCB_POS::m_useDrillPlaceFileOrigin
bool m_useDrillPlaceFileOrigin
Definition: job_export_pcb_pos.h:60
JOB_EXPORT_PCB_POS::m_format
FORMAT m_format
Definition: job_export_pcb_pos.h:69
JOB_EXPORT_PCB_POS::m_nakedFilename
bool m_nakedFilename
Definition: job_export_pcb_pos.h:66
JOB_EXPORT_PCB_POS::FORMAT::GERBER
@ GERBER
JOB_EXPORT_PCB_POS::FORMAT::CSV
@ CSV
JOB_EXPORT_PCB_POS::FORMAT::ASCII
@ ASCII
JOB_EXPORT_PCB_POS::m_gerberBoardEdge
bool m_gerberBoardEdge
Definition: job_export_pcb_pos.h:70
JOB_EXPORT_PCB_POS::m_smdOnly
bool m_smdOnly
Definition: job_export_pcb_pos.h:61
JOB_EXPORT_PCB_POS::UNITS::MM
@ MM
JOB_EXPORT_PCB_POS::m_excludeDNP
bool m_excludeDNP
Definition: job_export_pcb_pos.h:63
JOB_EXPORT_PCB_POS::m_units
UNITS m_units
Definition: job_export_pcb_pos.h:68
JOB_EXPORT_PCB_POS::m_excludeFootprintsWithTh
bool m_excludeFootprintsWithTh
Definition: job_export_pcb_pos.h:62
JOB_EXPORT_PCB_POS::m_filename
wxString m_filename
Definition: job_export_pcb_pos.h:58
JOB_EXPORT_PCB_POS::m_side
SIDE m_side
Definition: job_export_pcb_pos.h:67
JOB_EXPORT_PCB_POS::SIDE::BACK
@ BACK
JOB_EXPORT_PCB_POS::SIDE::BOTH
@ BOTH
JOB_EXPORT_PCB_POS::SIDE::FRONT
@ FRONT
JOB_EXPORT_PCB_PS
Definition: job_export_pcb_ps.h:32
JOB_EXPORT_PCB_PS::m_genMode
GEN_MODE m_genMode
Definition: job_export_pcb_ps.h:44
JOB_EXPORT_PCB_PS::GEN_MODE::SINGLE
@ SINGLE
JOB_EXPORT_PCB_SVG
Definition: job_export_pcb_svg.h:32
JOB_EXPORT_PCB_SVG::m_genMode
GEN_MODE m_genMode
Definition: job_export_pcb_svg.h:47
JOB_EXPORT_PCB_SVG::GEN_MODE::SINGLE
@ SINGLE
JOB_FP_EXPORT_SVG
Definition: job_fp_export_svg.h:31
JOB_FP_EXPORT_SVG::m_footprint
wxString m_footprint
Definition: job_fp_export_svg.h:36
JOB_FP_EXPORT_SVG::m_libraryPath
wxString m_libraryPath
Definition: job_fp_export_svg.h:35
JOB_FP_UPGRADE
Definition: job_fp_upgrade.h:28
JOB_FP_UPGRADE::m_libraryPath
wxString m_libraryPath
Definition: job_fp_upgrade.h:32
JOB_FP_UPGRADE::m_force
bool m_force
Definition: job_fp_upgrade.h:35
JOB_FP_UPGRADE::m_outputLibraryPath
wxString m_outputLibraryPath
Definition: job_fp_upgrade.h:33
JOB_PCB_DRC
Definition: job_pcb_drc.h:26
JOB_PCB_DRC::m_parity
bool m_parity
Definition: job_pcb_drc.h:33
JOB_PCB_DRC::m_reportAllTrackErrors
bool m_reportAllTrackErrors
Definition: job_pcb_drc.h:32
JOB_PCB_RENDER
Definition: job_pcb_render.h:40
JOB_PCB_RENDER::m_pan
VECTOR3D m_pan
Definition: job_pcb_render.h:93
JOB_PCB_RENDER::m_lightBottomIntensity
VECTOR3D m_lightBottomIntensity
Definition: job_pcb_render.h:100
JOB_PCB_RENDER::m_lightTopIntensity
VECTOR3D m_lightTopIntensity
Definition: job_pcb_render.h:99
JOB_PCB_RENDER::SIDE::BACK
@ BACK
JOB_PCB_RENDER::SIDE::BOTTOM
@ BOTTOM
JOB_PCB_RENDER::SIDE::RIGHT
@ RIGHT
JOB_PCB_RENDER::SIDE::TOP
@ TOP
JOB_PCB_RENDER::SIDE::LEFT
@ LEFT
JOB_PCB_RENDER::SIDE::FRONT
@ FRONT
JOB_PCB_RENDER::m_width
int m_width
Definition: job_pcb_render.h:86
JOB_PCB_RENDER::m_side
SIDE m_side
Definition: job_pcb_render.h:89
JOB_PCB_RENDER::m_bgStyle
BG_STYLE m_bgStyle
Definition: job_pcb_render.h:85
JOB_PCB_RENDER::m_perspective
bool m_perspective
Definition: job_pcb_render.h:91
JOB_PCB_RENDER::m_lightSideElevation
int m_lightSideElevation
Definition: job_pcb_render.h:103
JOB_PCB_RENDER::m_lightCameraIntensity
VECTOR3D m_lightCameraIntensity
Definition: job_pcb_render.h:101
JOB_PCB_RENDER::BG_STYLE::DEFAULT
@ DEFAULT
JOB_PCB_RENDER::BG_STYLE::TRANSPARENT
@ TRANSPARENT
JOB_PCB_RENDER::m_floor
bool m_floor
Definition: job_pcb_render.h:96
JOB_PCB_RENDER::m_rotation
VECTOR3D m_rotation
Definition: job_pcb_render.h:92
JOB_PCB_RENDER::m_zoom
double m_zoom
Definition: job_pcb_render.h:90
JOB_PCB_RENDER::m_proceduralTextures
bool m_proceduralTextures
Definition: job_pcb_render.h:95
JOB_PCB_RENDER::m_quality
QUALITY m_quality
Definition: job_pcb_render.h:84
JOB_PCB_RENDER::QUALITY::HIGH
@ HIGH
JOB_PCB_RENDER::QUALITY::BASIC
@ BASIC
JOB_PCB_RENDER::QUALITY::JOB_SETTINGS
@ JOB_SETTINGS
JOB_PCB_RENDER::m_format
FORMAT m_format
Definition: job_pcb_render.h:83
JOB_PCB_RENDER::m_filename
wxString m_filename
Definition: job_pcb_render.h:55
JOB_PCB_RENDER::m_height
int m_height
Definition: job_pcb_render.h:87
JOB_PCB_RENDER::m_pivot
VECTOR3D m_pivot
Definition: job_pcb_render.h:94
JOB_PCB_RENDER::m_lightSideIntensity
VECTOR3D m_lightSideIntensity
Definition: job_pcb_render.h:102
JOB_PCB_RENDER::m_antiAlias
bool m_antiAlias
Definition: job_pcb_render.h:97
JOB_PCB_RENDER::m_appearancePreset
std::string m_appearancePreset
Definition: job_pcb_render.h:88
JOB_PCB_RENDER::FORMAT::PNG
@ PNG
JOB_PCB_RENDER::FORMAT::JPEG
@ JPEG
JOB_PCB_RENDER::m_postProcess
bool m_postProcess
Definition: job_pcb_render.h:98
JOB_RC::m_exitCodeViolations
bool m_exitCodeViolations
Definition: job_rc.h:52
JOB_RC::UNITS::INCH
@ INCH
JOB_RC::UNITS::MILS
@ MILS
JOB_RC::UNITS::MM
@ MM
JOB_RC::m_severity
int m_severity
Definition: job_rc.h:49
JOB_RC::m_units
UNITS m_units
Definition: job_rc.h:48
JOB_RC::m_format
OUTPUT_FORMAT m_format
Definition: job_rc.h:50
JOB_RC::m_filename
wxString m_filename
Definition: job_rc.h:47
JOB_RC::OUTPUT_FORMAT::JSON
@ JSON
JOB
An simple container class that lets us dispatch output jobs to kifaces.
Definition: job.h:183
JOB::AddOutput
void AddOutput(wxString aOutputPath)
Definition: job.h:210
JOB::GetFullOutputPath
wxString GetFullOutputPath(PROJECT *aProject) const
Returns the full output path for the job, taking into account the configured output path,...
Definition: job.cpp:100
JOB::GetConfiguredOutputPath
wxString GetConfiguredOutputPath() const
Returns the configured output path for the job.
Definition: job.h:227
JOB::SetTitleBlock
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition: job.h:198
JOB::SetWorkingOutputPath
void SetWorkingOutputPath(const wxString &aPath)
Sets a transient output path for the job, it takes priority over the configured output path when GetF...
Definition: job.h:233
JOB::GetVarOverrides
const std::map< wxString, wxString > & GetVarOverrides() const
Definition: job.h:191
KICAD_NETLIST_READER
Read the new s-expression based KiCad netlist format.
Definition: netlist_reader.h:261
KICAD_NETLIST_READER::LoadNetlist
virtual void LoadNetlist() override
Load the contents of the netlist file into aNetlist.
Definition: kicad_netlist_reader.cpp:36
KIGFX::COLOR4D
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
KIWAY
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:286
KIWAY::Player
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:395
KIWAY::KiFACE
virtual KIFACE * KiFACE(FACE_T aFaceId, bool doLoad=true)
Return the KIFACE* given a FACE_T.
Definition: kiway.cpp:198
KIWAY::FACE_SCH
@ FACE_SCH
eeschema DSO
Definition: kiway.h:293
KIWAY::ExpressMail
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:499
LIB_ID::GetLibItemName
const UTF8 & GetLibItemName() const
Definition: lib_id.h:102
LOCALE_IO
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:41
LSEQ
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: lseq.h:47
LSET
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:37
LSET::UIOrder
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
Definition: lset.cpp:733
LSET::SeqStackupForPlotting
LSEQ SeqStackupForPlotting() const
Return the sequence that is typical for a bottom-to-top stack-up.
Definition: lset.cpp:387
LSET::AllNonCuMask
static LSET AllNonCuMask()
Return a mask holding all layer minus CU layers.
Definition: lset.cpp:610
LSET::AllLayersMask
static const LSET & AllLayersMask()
Definition: lset.cpp:624
LSET::AllCuMask
static LSET AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition: lset.cpp:591
LSET::InternalCuMask
static const LSET & InternalCuMask()
Return a complete set of internal copper layers which is all Cu layers except F_Cu and B_Cu.
Definition: lset.cpp:560
LSET::Name
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition: lset.cpp:188
MARKER_BASE::MARKER_RATSNEST
@ MARKER_RATSNEST
Definition: marker_base.h:57
MARKER_BASE::MARKER_DRC
@ MARKER_DRC
Definition: marker_base.h:55
MARKER_BASE::MARKER_PARITY
@ MARKER_PARITY
Definition: marker_base.h:58
MARKER_BASE::MARKER_DRAWING_SHEET
@ MARKER_DRAWING_SHEET
Definition: marker_base.h:56
PAD
Definition: pad.h:54
PATHS::EnsurePathExists
static bool EnsurePathExists(const wxString &aPath, bool aPathToFile=false)
Attempts to create a given path if it does not exist.
Definition: paths.cpp:484
PCBNEW_JOBS_HANDLER::JobExportStep
int JobExportStep(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:443
PCBNEW_JOBS_HANDLER::JobExportPs
int JobExportPs(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1073
PCBNEW_JOBS_HANDLER::JobExportPos
int JobExportPos(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1588
PCBNEW_JOBS_HANDLER::JobExportFpSvg
int JobExportFpSvg(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1870
PCBNEW_JOBS_HANDLER::JobExportOdb
int JobExportOdb(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:2357
PCBNEW_JOBS_HANDLER::JobExportDrc
int JobExportDrc(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:2013
PCBNEW_JOBS_HANDLER::JobExportFpUpgrade
int JobExportFpUpgrade(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1776
PCBNEW_JOBS_HANDLER::JobExportGerber
int JobExportGerber(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1377
PCBNEW_JOBS_HANDLER::getDrawingSheetProxyView
DS_PROXY_VIEW_ITEM * getDrawingSheetProxyView(BOARD *aBrd)
Definition: pcbnew_jobs_handler.cpp:2407
PCBNEW_JOBS_HANDLER::JobExportDxf
int JobExportDxf(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:903
PCBNEW_JOBS_HANDLER::JobExportPdf
int JobExportPdf(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:984
PCBNEW_JOBS_HANDLER::JobExportDrill
int JobExportDrill(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1469
PCBNEW_JOBS_HANDLER::JobExportSvg
int JobExportSvg(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:821
PCBNEW_JOBS_HANDLER::loadOverrideDrawingSheet
void loadOverrideDrawingSheet(BOARD *brd, const wxString &aSheetPath)
Definition: pcbnew_jobs_handler.cpp:2425
PCBNEW_JOBS_HANDLER::PCBNEW_JOBS_HANDLER
PCBNEW_JOBS_HANDLER(KIWAY *aKiway)
Definition: pcbnew_jobs_handler.cpp:109
PCBNEW_JOBS_HANDLER::JobExportGerbers
int JobExportGerbers(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1157
PCBNEW_JOBS_HANDLER::JobExportGencad
int JobExportGencad(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:1321
PCBNEW_JOBS_HANDLER::getBoard
BOARD * getBoard(const wxString &aPath=wxEmptyString)
Definition: pcbnew_jobs_handler.cpp:335
PCBNEW_JOBS_HANDLER::JobExportIpc2581
int JobExportIpc2581(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:2215
PCBNEW_JOBS_HANDLER::convertLayerArg
LSEQ convertLayerArg(wxString &aLayerString, BOARD *aBoard) const
Definition: pcbnew_jobs_handler.cpp:375
PCBNEW_JOBS_HANDLER::JobExportRender
int JobExportRender(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:567
PCBNEW_JOBS_HANDLER::JobExportIpcD356
int JobExportIpcD356(JOB *aJob)
Definition: pcbnew_jobs_handler.cpp:2309
PCBNEW_JOBS_HANDLER::m_cliBoard
BOARD * m_cliBoard
Definition: pcbnew_jobs_handler.h:70
PCBNEW_JOBS_HANDLER::doFpExportSvg
int doFpExportSvg(JOB_FP_EXPORT_SVG *aSvgJob, const FOOTPRINT *aFootprint)
Definition: pcbnew_jobs_handler.cpp:1942
PCB_BASE_FRAME::GetBoard
BOARD * GetBoard() const
Definition: pcb_base_frame.h:205
PCB_EDIT_FRAME
The main frame for Pcbnew.
Definition: pcb_edit_frame.h:81
PCB_IO_KICAD_SEXPR
A #PLUGIN derivation for saving and loading Pcbnew s-expression formatted files.
Definition: pcb_io_kicad_sexpr.h:304
PCB_IO_MGR::PluginFind
static PCB_IO * PluginFind(PCB_FILE_T aFileType)
Return a #PLUGIN which the caller can use to import, export, save, or load design documents.
Definition: pcb_io_mgr.cpp:69
PCB_IO_MGR::PCB_FILE_T
PCB_FILE_T
The set of file types that the PCB_IO_MGR knows about, and for which there has been a plugin written,...
Definition: pcb_io_mgr.h:56
PCB_IO_MGR::IPC2581
@ IPC2581
Definition: pcb_io_mgr.h:71
PCB_IO_MGR::KICAD_SEXP
@ KICAD_SEXP
S-expression Pcbnew file format.
Definition: pcb_io_mgr.h:58
PCB_IO_MGR::ConvertLibrary
static bool ConvertLibrary(std::map< std::string, UTF8 > *aOldFileProps, const wxString &aOldFilePath, const wxString &aNewFilePath, REPORTER *aReporter)
Convert a schematic symbol library to the latest KiCad format.
Definition: pcb_io_mgr.cpp:191
PCB_IO_MGR::GuessPluginTypeFromLibPath
static PCB_FILE_T GuessPluginTypeFromLibPath(const wxString &aLibPath, int aCtl=0)
Return a plugin type given a footprint library's libPath.
Definition: pcb_io_mgr.cpp:136
PCB_MARKER
Definition: pcb_marker.h:43
PCB_PLOTTER
Definition: pcb_plotter.h:34
PCB_PLOTTER::Plot
bool Plot(const wxString &aOutputPath, const LSEQ &aLayersToPlot, const LSEQ &aCommonLayers, bool aUseGerberFileExtensions, bool aOutputPathIsSingle=false, std::optional< wxString > aLayerName=std::nullopt, std::optional< wxString > aSheetName=std::nullopt, std::optional< wxString > aSheetPath=std::nullopt)
Definition: pcb_plotter.cpp:64
PCB_PLOTTER::PlotJobToPlotOpts
static void PlotJobToPlotOpts(PCB_PLOT_PARAMS &aOpts, JOB_EXPORT_PCB_PLOT *aJob, REPORTER &aReporter)
Translate a JOB to PCB_PLOT_PARAMS.
Definition: pcb_plotter.cpp:372
PCB_PLOT_PARAMS
Parameters and options when plotting/printing a board.
Definition: pcb_plot_params.h:38
PCB_PLOT_PARAMS::GetPlotOnAllLayersSequence
LSEQ GetPlotOnAllLayersSequence() const
Definition: pcb_plot_params.h:170
PCB_PLOT_PARAMS::SetSkipPlotNPTH_Pads
void SetSkipPlotNPTH_Pads(bool aSkip)
Definition: pcb_plot_params.h:42
PCB_PLOT_PARAMS::SetLayerSelection
void SetLayerSelection(const LSET &aSelection)
Definition: pcb_plot_params.h:166
PCB_PLOT_PARAMS::SetPlotOnAllLayersSequence
void SetPlotOnAllLayersSequence(LSEQ aSeq)
Definition: pcb_plot_params.h:169
PCB_PLOT_PARAMS::SetPlotFrameRef
void SetPlotFrameRef(bool aFlag)
Definition: pcb_plot_params.h:127
PCB_PLOT_PARAMS::SetPlotPadNumbers
void SetPlotPadNumbers(bool aFlag)
Definition: pcb_plot_params.h:75
PCB_PLOT_PARAMS::GetLayerSelection
LSET GetLayerSelection() const
Definition: pcb_plot_params.h:167
PCB_PLOT_PARAMS::SetMirror
void SetMirror(bool aFlag)
Definition: pcb_plot_params.h:100
PCB_PLOT_PARAMS::GetSketchPadsOnFabLayers
bool GetSketchPadsOnFabLayers() const
Definition: pcb_plot_params.h:104
PCB_PLOT_PARAMS::m_PDFSingle
bool m_PDFSingle
Generate a single PDF file for all layers.
Definition: pcb_plot_params.h:194
PCB_PLOT_PARAMS::SetSvgFitPageToBoard
void SetSvgFitPageToBoard(int aSvgFitPageToBoard)
Definition: pcb_plot_params.h:157
PCB_PLOT_PARAMS::GetUseGerberProtelExtensions
bool GetUseGerberProtelExtensions() const
Definition: pcb_plot_params.h:149
PGM_BASE::GetSettingsManager
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:125
PLACEFILE_GERBER_WRITER
Used to create Gerber drill files.
Definition: gerber_placefile_writer.h:40
PLACEFILE_GERBER_WRITER::GetPlaceFileName
const wxString GetPlaceFileName(const wxString &aFullBaseFilename, PCB_LAYER_ID aLayer) const
Definition: gerber_placefile_writer.cpp:364
PLACEFILE_GERBER_WRITER::CreatePlaceFile
int CreatePlaceFile(const wxString &aFullFilename, PCB_LAYER_ID aLayer, bool aIncludeBrdEdges, bool aExcludeDNP)
Create an pnp gerber file.
Definition: gerber_placefile_writer.cpp:51
PLACE_FILE_EXPORTER
The ASCII format of the kicad place file is:
Definition: place_file_exporter.h:52
PLACE_FILE_EXPORTER::DecorateFilename
static wxString DecorateFilename(const wxString &aBaseName, bool aFront, bool aBack)
Definition: place_file_exporter.cpp:447
PLACE_FILE_EXPORTER::GenPositionData
std::string GenPositionData()
build a string filled with the position data
Definition: place_file_exporter.cpp:107
PLOTTER
Base plotter engine class.
Definition: plotter.h:121
PLOTTER::EndPlot
virtual bool EndPlot()=0
PROGRESS_REPORTER::KeepRefreshing
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
PROGRESS_REPORTER::AdvancePhase
virtual void AdvancePhase()=0
Use the next available virtual zone of the dialog progress bar.
PROJECT_FILE::m_BoardDrawingSheetFile
wxString m_BoardDrawingSheetFile
PcbNew params.
Definition: project_file.h:176
PROJECT_PCB::Get3DCacheManager
static S3D_CACHE * Get3DCacheManager(PROJECT *aProject, bool updateProjDir=false)
Return a pointer to an instance of the 3D cache manager.
Definition: project_pcb.cpp:77
PROJECT::GetProjectFullName
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition: project.cpp:142
PROJECT::GetProjectPath
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:148
PROJECT::ApplyTextVars
virtual void ApplyTextVars(const std::map< wxString, wxString > &aVarsMap)
Applies the given var map, it will create or update existing vars.
Definition: project.cpp:103
PROJECT::GetProjectFile
virtual PROJECT_FILE & GetProjectFile() const
Definition: project.h:204
RENDER_3D_RAYTRACE_RAM
Definition: render_3d_raytrace_ram.h:33
RENDER_3D_RAYTRACE_RAM::Redraw
bool Redraw(bool aIsMoving, REPORTER *aStatusReporter, REPORTER *aWarningReporter) override
Redraw the view.
Definition: render_3d_raytrace_ram.cpp:74
RENDER_3D_RAYTRACE_RAM::GetRealBufferSize
wxSize GetRealBufferSize()
Definition: render_3d_raytrace_ram.cpp:50
RENDER_3D_RAYTRACE_RAM::SetCurWindowSize
void SetCurWindowSize(const wxSize &aSize) override
Before each render, the canvas will tell the render what is the size of its windows,...
Definition: render_3d_raytrace_ram.cpp:63
RENDER_3D_RAYTRACE_RAM::GetBuffer
uint8_t * GetBuffer()
Definition: render_3d_raytrace_ram.cpp:44
REPORTER::Report
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Report a string with a given severity.
Definition: reporter.h:102
SETTINGS_MANAGER::Prj
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
Definition: settings_manager.cpp:1057
STRING_LINE_READER
Is a LINE_READER that reads from a multiline 8 bit wide std::string.
Definition: richio.h:253
TOOL_MANAGER
Master controller class:
Definition: tool_manager.h:62
TOOL_MANAGER::SetEnvironment
void SetEnvironment(EDA_ITEM *aModel, KIGFX::VIEW *aView, KIGFX::VIEW_CONTROLS *aViewControls, APP_SETTINGS_BASE *aSettings, TOOLS_HOLDER *aFrame)
Set the work environment (model, view, view controls and the parent window).
Definition: tool_manager.cpp:1098
TRACK_BALL
Definition: track_ball.h:37
TRACK_BALL::Pan_T1
void Pan_T1(const SFVEC3F &aDeltaOffsetInc) override
Definition: track_ball.cpp:125
TRACK_BALL::SetT0_and_T1_current_T
void SetT0_and_T1_current_T() override
This will set T0 and T1 with the current values.
Definition: track_ball.cpp:138
TRACK_BALL::Interpolate
void Interpolate(float t) override
It will update the matrix to interpolate between T0 and T1 values.
Definition: track_ball.cpp:152
UTF8::wx_str
wxString wx_str() const
Definition: utf8.cpp:45
VECTOR3::y
T y
Definition: vector3.h:64
VECTOR3::z
T z
Definition: vector3.h:65
VECTOR3::x
T x
Definition: vector3.h:63
GetDefaultPlotExtension
wxString GetDefaultPlotExtension(PLOT_FORMAT aFormat)
Return the default plot extension for a format.
Definition: common_plot_functions.cpp:36
DisplayErrorMessage
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:194
confirm.h
This file is part of the common library.
dialog_drc_job_config.h
dialog_export_2581.h
dialog_export_odbpp.h
dialog_export_step.h
dialog_gen_footprint_position.h
dialog_gencad_export_options.h
precisionListForInches
static DRILL_PRECISION precisionListForInches(2, 4)
precisionListForMetric
static DRILL_PRECISION precisionListForMetric(3, 3)
dialog_gendrill.h
dialog_plot.h
dialog_render_job.h
DRC_CUSTOM_MARKER_HANDLER
std::function< void(PCB_MARKER *aMarker)> DRC_CUSTOM_MARKER_HANDLER
Definition: drc_engine.h:68
drc_item.h
drc_report.h
drc_tool.h
ds_data_model.h
ds_proxy_view_item.h
_
#define _(s)
Definition: eda_3d_actions.cpp:36
ANGLE_0
static constexpr EDA_ANGLE ANGLE_0
Definition: eda_angle.h:411
IS_NEW
#define IS_NEW
New item, just created.
Definition: eda_item_flags.h:40
EDA_UNITS
EDA_UNITS
Definition: eda_units.h:48
exit_codes.h
export_d356.h
export_gencad_writer.h
resolver
static FILENAME_RESOLVER * resolver
Definition: export_idf.cpp:53
export_vrml.h
exporter_step.h
filename_resolver.h
FRAME_PCB_EDITOR
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
FRAME_SCH
@ FRAME_SCH
Definition: frame_type.h:34
gendrill_Excellon_writer.h
Classes used in drill files, map files and report files generation.
gendrill_gerber_writer.h
Classes used in drill files, map files and report files generation.
gerber_jobfile_writer.h
Classes used to generate a Gerber job file in JSON.
gerber_placefile_writer.h
Classes used in place file generation.
FILEEXT::LegacySchematicFileExtension
static const std::string LegacySchematicFileExtension
Definition: wildcards_and_files_ext.h:130
FILEEXT::BrepFileExtension
static const std::string BrepFileExtension
Definition: wildcards_and_files_ext.h:199
FILEEXT::JpegFileExtension
static const std::string JpegFileExtension
Definition: wildcards_and_files_ext.h:186
FILEEXT::GerberJobFileExtension
static const std::string GerberJobFileExtension
Definition: wildcards_and_files_ext.h:144
FILEEXT::GerberFileExtension
static const std::string GerberFileExtension
Definition: wildcards_and_files_ext.h:143
FILEEXT::XaoFileExtension
static const std::string XaoFileExtension
Definition: wildcards_and_files_ext.h:200
FILEEXT::ReportFileExtension
static const std::string ReportFileExtension
Definition: wildcards_and_files_ext.h:168
FILEEXT::GltfBinaryFileExtension
static const std::string GltfBinaryFileExtension
Definition: wildcards_and_files_ext.h:198
FILEEXT::PngFileExtension
static const std::string PngFileExtension
Definition: wildcards_and_files_ext.h:185
FILEEXT::FootprintPlaceFileExtension
static const std::string FootprintPlaceFileExtension
Definition: wildcards_and_files_ext.h:169
FILEEXT::JsonFileExtension
static const std::string JsonFileExtension
Definition: wildcards_and_files_ext.h:192
FILEEXT::KiCadSchematicFileExtension
static const std::string KiCadSchematicFileExtension
Definition: wildcards_and_files_ext.h:133
FILEEXT::CsvFileExtension
static const std::string CsvFileExtension
Definition: wildcards_and_files_ext.h:189
FILEEXT::Ipc2581FileExtension
static const std::string Ipc2581FileExtension
Definition: wildcards_and_files_ext.h:179
FILEEXT::GencadFileExtension
static const std::string GencadFileExtension
Definition: wildcards_and_files_ext.h:205
FILEEXT::StlFileExtension
static const std::string StlFileExtension
Definition: wildcards_and_files_ext.h:202
FILEEXT::IpcD356FileExtension
static const std::string IpcD356FileExtension
Definition: wildcards_and_files_ext.h:178
FILEEXT::PlyFileExtension
static const std::string PlyFileExtension
Definition: wildcards_and_files_ext.h:201
FILEEXT::StepFileExtension
static const std::string StepFileExtension
Definition: wildcards_and_files_ext.h:195
FILEEXT::SVGFileExtension
static const std::string SVGFileExtension
Definition: wildcards_and_files_ext.h:167
FILEEXT::VrmlFileExtension
static const std::string VrmlFileExtension
Definition: wildcards_and_files_ext.h:126
FILEEXT::ArchiveFileExtension
static const std::string ArchiveFileExtension
Definition: wildcards_and_files_ext.h:151
FILEEXT::KiCadPcbFileExtension
static const std::string KiCadPcbFileExtension
Definition: wildcards_and_files_ext.h:156
IO_RELEASER
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition: io_mgr.h:33
job_export_pcb_3d.h
job_export_pcb_drill.h
job_export_pcb_dxf.h
job_export_pcb_gencad.h
job_export_pcb_gerber.h
job_export_pcb_gerbers.h
job_export_pcb_hpgl.h
job_export_pcb_ipc2581.h
job_export_pcb_ipcd356.h
job_export_pcb_odb.h
job_export_pcb_pdf.h
job_export_pcb_pos.h
job_export_pcb_ps.h
job_export_pcb_svg.h
job_fp_export_svg.h
job_fp_upgrade.h
job_pcb_drc.h
job_pcb_render.h
kiface_base.h
kiface_ids.h
KIFACE_NETLIST_SCHEMATIC
@ KIFACE_NETLIST_SCHEMATIC
Definition: kiface_ids.h:56
niluuid
KIID niluuid(0)
LayerName
wxString LayerName(int aLayer)
Returns the default display name for a given layer.
Definition: layer_id.cpp:31
LAYER_3D_BACKGROUND_TOP
@ LAYER_3D_BACKGROUND_TOP
Definition: layer_ids.h:541
LAYER_3D_BACKGROUND_BOTTOM
@ LAYER_3D_BACKGROUND_BOTTOM
Definition: layer_ids.h:540
PCB_LAYER_ID
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
F_CrtYd
@ F_CrtYd
Definition: layer_ids.h:116
B_Adhes
@ B_Adhes
Definition: layer_ids.h:103
F_Paste
@ F_Paste
Definition: layer_ids.h:104
F_Adhes
@ F_Adhes
Definition: layer_ids.h:102
B_Mask
@ B_Mask
Definition: layer_ids.h:98
B_Cu
@ B_Cu
Definition: layer_ids.h:65
F_Mask
@ F_Mask
Definition: layer_ids.h:97
B_Paste
@ B_Paste
Definition: layer_ids.h:105
F_Fab
@ F_Fab
Definition: layer_ids.h:119
F_SilkS
@ F_SilkS
Definition: layer_ids.h:100
B_CrtYd
@ B_CrtYd
Definition: layer_ids.h:115
UNDEFINED_LAYER
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
B_SilkS
@ B_SilkS
Definition: layer_ids.h:101
F_Cu
@ F_Cu
Definition: layer_ids.h:64
B_Fab
@ B_Fab
Definition: layer_ids.h:118
locale_io.h
macros.h
This file contains miscellaneous commonly used macros and functions.
MAIL_SCH_GET_NETLIST
@ MAIL_SCH_GET_NETLIST
Definition: mail_type.h:49
CLI::EXIT_CODES::ERR_ARGS
static const int ERR_ARGS
Definition: exit_codes.h:31
CLI::EXIT_CODES::OK
static const int OK
Definition: exit_codes.h:30
CLI::EXIT_CODES::ERR_RC_VIOLATIONS
static const int ERR_RC_VIOLATIONS
Rules check violation count was greater than 0.
Definition: exit_codes.h:37
CLI::EXIT_CODES::ERR_INVALID_INPUT_FILE
static const int ERR_INVALID_INPUT_FILE
Definition: exit_codes.h:33
CLI::EXIT_CODES::SUCCESS
static const int SUCCESS
Definition: exit_codes.h:29
CLI::EXIT_CODES::ERR_INVALID_OUTPUT_CONFLICT
static const int ERR_INVALID_OUTPUT_CONFLICT
Definition: exit_codes.h:34
CLI::EXIT_CODES::ERR_UNKNOWN
static const int ERR_UNKNOWN
Definition: exit_codes.h:32
netlist_reader.h
pcb_io_kicad_sexpr.h
SEXPR_BOARD_FILE_VERSION
#define SEXPR_BOARD_FILE_VERSION
Current s-expression file format version. 2 was the last legacy format version.
Definition: pcb_io_kicad_sexpr.h:186
CTL_FOR_LIBRARY
#define CTL_FOR_LIBRARY
Format output for a footprint library instead of clipboard or BOARD.
Definition: pcb_io_kicad_sexpr.h:201
pcb_marker.h
pcb_netlist.h
pcb_plotter.h
precisionListForInches
static DRILL_PRECISION precisionListForInches(2, 4)
precisionListForMetric
static DRILL_PRECISION precisionListForMetric(3, 3)
pcbnew_jobs_handler.h
GetSettingsManager
SETTINGS_MANAGER * GetSettingsManager()
Definition: pcbnew_scripting_helpers.cpp:108
CreateEmptyBoard
BOARD * CreateEmptyBoard()
Construct a default BOARD with a temporary (no filename) project.
Definition: pcbnew_scripting_helpers.cpp:303
LoadBoard
BOARD * LoadBoard(const wxString &aFileName, bool aSetActive)
Loads a board from file This function identifies the file type by extension and determines the correc...
Definition: pcbnew_scripting_helpers.cpp:90
pcbnew_scripting_helpers.h
pcbnew_settings.h
GetGerberProtelExtension
const wxString GetGerberProtelExtension(int aLayer)
Definition: pcbplot.cpp:43
BuildPlotFileName
void BuildPlotFileName(wxFileName *aFilename, const wxString &aOutputDir, const wxString &aSuffix, const wxString &aExtension)
Complete a plot filename.
Definition: pcbplot.cpp:379
StartPlotBoard
PLOTTER * StartPlotBoard(BOARD *aBoard, const PCB_PLOT_PARAMS *aPlotOpts, int aLayer, const wxString &aLayerName, const wxString &aFullFileName, const wxString &aSheetName, const wxString &aSheetPath, const wxString &aPageName=wxT("1"), const wxString &aPageNumber=wxEmptyString, const int aPageCount=1)
Open a new plotfile using the options (and especially the format) specified in the options and prepar...
Definition: plot_board_layers.cpp:1212
PlotBoardLayers
void PlotBoardLayers(BOARD *aBoard, PLOTTER *aPlotter, const LSEQ &aLayerSequence, const PCB_PLOT_PARAMS &aPlotOptions)
Plot a sequence of board layer IDs.
Definition: plot_board_layers.cpp:129
Pgm
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:893
pgm_base.h
see class PGM_BASE
place_file_exporter.h
PLOT_FORMAT
PLOT_FORMAT
The set of supported output plot formats.
Definition: plotter.h:64
plotter_dxf.h
plotter_gerber.h
plotters_pslike.h
Plotting engines similar to ps (PostScript, Gerber, svg)
progress_reporter.h
project_file.h
project_pcb.h
render_3d_raytrace_ram.h
RPT_SEVERITY_ERROR
@ RPT_SEVERITY_ERROR
Definition: report_severity.h:32
RPT_SEVERITY_INFO
@ RPT_SEVERITY_INFO
Definition: report_severity.h:28
RPT_SEVERITY_ACTION
@ RPT_SEVERITY_ACTION
Definition: report_severity.h:30
SKIP_SET_DIRTY
#define SKIP_SET_DIRTY
Definition: sch_commit.h:43
SKIP_UNDO
#define SKIP_UNDO
Definition: sch_commit.h:41
settings_manager.h
scale
const int scale
Definition: spread_footprints.cpp:56
dummy
std::vector< FAB_LAYER_COLOR > dummy
Definition: stackup_predefined_prms.cpp:97
fileType
MODEL3D_FORMAT_TYPE fileType(const char *aFileName)
Definition: step_pcb_model.cpp:160
TO_UTF8
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: string_utils.h:429
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightElevation
std::vector< int > raytrace_lightElevation
Definition: eda_3d_viewer_settings.h:125
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightColorCamera
KIGFX::COLOR4D raytrace_lightColorCamera
Definition: eda_3d_viewer_settings.h:121
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_post_processing
bool raytrace_post_processing
Definition: eda_3d_viewer_settings.h:104
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightColor
std::vector< KIGFX::COLOR4D > raytrace_lightColor
Definition: eda_3d_viewer_settings.h:124
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightColorBottom
KIGFX::COLOR4D raytrace_lightColorBottom
Definition: eda_3d_viewer_settings.h:123
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_backfloor
bool raytrace_backfloor
Definition: eda_3d_viewer_settings.h:103
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_reflections
bool raytrace_reflections
Definition: eda_3d_viewer_settings.h:106
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::differentiate_plated_copper
bool differentiate_plated_copper
Definition: eda_3d_viewer_settings.h:154
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightAzimuth
std::vector< int > raytrace_lightAzimuth
Definition: eda_3d_viewer_settings.h:126
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_refractions
bool raytrace_refractions
Definition: eda_3d_viewer_settings.h:107
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_procedural_textures
bool raytrace_procedural_textures
Definition: eda_3d_viewer_settings.h:105
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_recursivelevel_refractions
int raytrace_recursivelevel_refractions
Definition: eda_3d_viewer_settings.h:119
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_shadows
bool raytrace_shadows
Definition: eda_3d_viewer_settings.h:108
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_lightColorTop
KIGFX::COLOR4D raytrace_lightColorTop
Definition: eda_3d_viewer_settings.h:122
EDA_3D_VIEWER_SETTINGS::RENDER_SETTINGS::raytrace_anti_aliasing
bool raytrace_anti_aliasing
Definition: eda_3d_viewer_settings.h:102
EDA_IU_SCALE::IUTomm
constexpr double IUTomm(int iu) const
Definition: base_units.h:90
EDA_IU_SCALE::mmToIU
constexpr int mmToIU(double mm) const
Definition: base_units.h:92
KIFACE
Implement a participant in the KIWAY alchemy.
Definition: kiway.h:153
tool_manager.h
track_ball.h
Declaration for a track ball camera.
DEG2RAD
double DEG2RAD(double deg)
Definition: trigo.h:166
VECTOR2I
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
wildcards_and_files_ext.h
Definition of file extensions used in Kicad.
SFVEC3F
glm::vec3 SFVEC3F
Definition: xv3d_types.h:44