2012-09-15 12:13:03 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2018-05-25 16:33:00 +00:00
|
|
|
* Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors.
|
2012-09-15 12:13:03 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, you may find one here:
|
|
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
|
|
|
|
#include <kiface_i.h>
|
2018-01-28 18:12:26 +00:00
|
|
|
#include <plotter.h>
|
2012-09-15 12:13:03 +00:00
|
|
|
#include <confirm.h>
|
2018-01-29 20:58:58 +00:00
|
|
|
#include <pcb_edit_frame.h>
|
2020-01-13 01:44:19 +00:00
|
|
|
#include <pcbnew_settings.h>
|
2012-09-15 12:13:03 +00:00
|
|
|
#include <pcbplot.h>
|
2021-06-09 01:56:00 +00:00
|
|
|
#include <pgm_base.h>
|
2017-08-19 16:28:11 +00:00
|
|
|
#include <gerber_jobfile_writer.h>
|
2013-05-10 19:22:29 +00:00
|
|
|
#include <reporter.h>
|
2017-08-19 16:28:11 +00:00
|
|
|
#include <wildcards_and_files_ext.h>
|
2019-07-08 19:44:40 +00:00
|
|
|
#include <layers_id_colors_and_visibility.h>
|
2020-10-24 01:38:50 +00:00
|
|
|
#include <locale_io.h>
|
2018-02-09 18:00:13 +00:00
|
|
|
#include <bitmaps.h>
|
2020-11-12 20:19:22 +00:00
|
|
|
#include <board.h>
|
2021-06-06 19:03:10 +00:00
|
|
|
#include <board_design_settings.h>
|
2012-09-15 12:13:03 +00:00
|
|
|
#include <dialog_plot.h>
|
2019-02-13 10:41:52 +00:00
|
|
|
#include <dialog_gendrill.h>
|
2015-06-16 12:20:42 +00:00
|
|
|
#include <wx_html_report_panel.h>
|
2019-07-08 19:44:40 +00:00
|
|
|
#include <tool/tool_manager.h>
|
|
|
|
#include <tools/zone_filler_tool.h>
|
2020-09-14 17:54:14 +00:00
|
|
|
#include <tools/drc_tool.h>
|
2020-01-07 17:12:59 +00:00
|
|
|
#include <math/util.h> // for KiROUND
|
2020-04-24 23:44:09 +00:00
|
|
|
#include <macros.h>
|
2018-01-28 21:02:31 +00:00
|
|
|
|
2021-06-07 07:26:13 +00:00
|
|
|
#include <wx/dirdlg.h>
|
|
|
|
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
DIALOG_PLOT::DIALOG_PLOT( PCB_EDIT_FRAME* aParent ) :
|
2018-06-13 12:20:29 +00:00
|
|
|
DIALOG_PLOT_BASE( aParent ), m_parent( aParent ),
|
2021-03-12 15:12:49 +00:00
|
|
|
m_defaultPenSize( aParent, m_hpglPenLabel, m_hpglPenCtrl, m_hpglPenUnits ),
|
|
|
|
m_trackWidthCorrection( aParent, m_widthAdjustLabel, m_widthAdjustCtrl, m_widthAdjustUnits )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2018-05-25 16:33:00 +00:00
|
|
|
SetName( DLG_WINDOW_NAME );
|
2017-04-28 10:53:30 +00:00
|
|
|
m_plotOpts = aParent->GetPlotSettings();
|
2020-03-06 12:04:47 +00:00
|
|
|
m_DRCWarningTemplate = m_DRCExclusionsWarning->GetLabel();
|
|
|
|
|
2021-02-25 15:05:26 +00:00
|
|
|
m_messagesPanel->SetFileName( Prj().GetProjectPath() + wxT( "report.txt" ) );
|
|
|
|
|
2017-07-10 13:16:57 +00:00
|
|
|
init_Dialog();
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2018-02-28 09:44:22 +00:00
|
|
|
// We use a sdbSizer to get platform-dependent ordering of the action buttons, but
|
|
|
|
// that requires us to correct the button labels here.
|
2018-05-08 19:01:29 +00:00
|
|
|
m_sdbSizer1OK->SetLabel( _( "Plot" ) );
|
2018-05-07 23:21:21 +00:00
|
|
|
m_sdbSizer1Apply->SetLabel( _( "Generate Drill Files..." ) );
|
2018-05-03 22:23:47 +00:00
|
|
|
m_sdbSizer1Cancel->SetLabel( _( "Close" ) );
|
2018-05-08 19:01:29 +00:00
|
|
|
m_sizerButtons->Layout();
|
2018-05-03 22:23:47 +00:00
|
|
|
|
|
|
|
m_sdbSizer1OK->SetDefault();
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
GetSizer()->Fit( this );
|
|
|
|
GetSizer()->SetSizeHints( this );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-07-10 13:16:57 +00:00
|
|
|
void DIALOG_PLOT::init_Dialog()
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2018-02-22 15:25:31 +00:00
|
|
|
BOARD* board = m_parent->GetBoard();
|
2012-09-15 12:13:03 +00:00
|
|
|
wxFileName fileName;
|
|
|
|
|
2020-05-06 01:43:37 +00:00
|
|
|
auto cfg = m_parent->GetPcbNewSettings();
|
2012-09-24 06:39:59 +00:00
|
|
|
|
2020-01-13 01:44:19 +00:00
|
|
|
m_XScaleAdjust = cfg->m_Plot.fine_scale_x;
|
|
|
|
m_YScaleAdjust = cfg->m_Plot.fine_scale_y;
|
|
|
|
|
|
|
|
m_zoneFillCheck->SetValue( cfg->m_Plot.check_zones_before_plotting );
|
2018-05-07 23:21:21 +00:00
|
|
|
|
2021-03-08 02:59:07 +00:00
|
|
|
m_browseButton->SetBitmap( KiBitmap( BITMAPS::small_folder ) );
|
2018-02-09 18:00:13 +00:00
|
|
|
|
2012-09-24 06:39:59 +00:00
|
|
|
// m_PSWidthAdjust is stored in mm in user config
|
2020-01-13 01:44:19 +00:00
|
|
|
m_PSWidthAdjust = KiROUND( cfg->m_Plot.ps_fine_width_adjust * IU_PER_MM );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// The reasonable width correction value must be in a range of
|
|
|
|
// [-(MinTrackWidth-1), +(MinClearanceValue-1)] decimils.
|
2018-02-22 15:25:31 +00:00
|
|
|
m_widthAdjustMinValue = -( board->GetDesignSettings().m_TrackMinWidth - 1 );
|
|
|
|
m_widthAdjustMaxValue = board->GetDesignSettings().GetSmallestClearanceValue() - 1;
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
switch( m_plotOpts.GetFormat() )
|
|
|
|
{
|
|
|
|
default:
|
2020-03-06 12:04:47 +00:00
|
|
|
case PLOT_FORMAT::GERBER: m_plotFormatOpt->SetSelection( 0 ); break;
|
|
|
|
case PLOT_FORMAT::POST: m_plotFormatOpt->SetSelection( 1 ); break;
|
|
|
|
case PLOT_FORMAT::SVG: m_plotFormatOpt->SetSelection( 2 ); break;
|
|
|
|
case PLOT_FORMAT::DXF: m_plotFormatOpt->SetSelection( 3 ); break;
|
|
|
|
case PLOT_FORMAT::HPGL: m_plotFormatOpt->SetSelection( 4 ); break;
|
|
|
|
case PLOT_FORMAT::PDF: m_plotFormatOpt->SetSelection( 5 ); break;
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
2018-02-28 09:44:22 +00:00
|
|
|
// Set units and value for HPGL pen size (this param is in mils).
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.SetValue( m_plotOpts.GetHPGLPenDiameter() * IU_PER_MILS );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// Test for a reasonable scale value. Set to 1 if problem
|
|
|
|
if( m_XScaleAdjust < PLOT_MIN_SCALE || m_YScaleAdjust < PLOT_MIN_SCALE
|
|
|
|
|| m_XScaleAdjust > PLOT_MAX_SCALE || m_YScaleAdjust > PLOT_MAX_SCALE )
|
|
|
|
m_XScaleAdjust = m_YScaleAdjust = 1.0;
|
|
|
|
|
2019-12-20 14:11:39 +00:00
|
|
|
m_fineAdjustXCtrl->SetValue( StringFromValue( EDA_UNITS::UNSCALED, m_XScaleAdjust ) );
|
|
|
|
m_fineAdjustYCtrl->SetValue( StringFromValue( EDA_UNITS::UNSCALED, m_YScaleAdjust ) );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// Test for a reasonable PS width correction value. Set to 0 if problem.
|
2012-09-24 06:39:59 +00:00
|
|
|
if( m_PSWidthAdjust < m_widthAdjustMinValue || m_PSWidthAdjust > m_widthAdjustMaxValue )
|
2012-09-15 12:13:03 +00:00
|
|
|
m_PSWidthAdjust = 0.;
|
|
|
|
|
2018-06-13 12:20:29 +00:00
|
|
|
m_trackWidthCorrection.SetValue( m_PSWidthAdjust );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
m_plotPSNegativeOpt->SetValue( m_plotOpts.GetNegative() );
|
|
|
|
m_forcePSA4OutputOpt->SetValue( m_plotOpts.GetA4Output() );
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
// Could devote a PlotOrder() function in place of UIOrder().
|
2018-02-22 15:25:31 +00:00
|
|
|
m_layerList = board->GetEnabledLayers().UIOrder();
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2015-11-15 18:04:19 +00:00
|
|
|
// Populate the check list box by all enabled layers names
|
2014-06-24 16:17:18 +00:00
|
|
|
for( LSEQ seq = m_layerList; seq; ++seq )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2017-03-13 03:19:33 +00:00
|
|
|
PCB_LAYER_ID layer = *seq;
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2018-02-22 15:25:31 +00:00
|
|
|
int checkIndex = m_layerCheckListBox->Append( board->GetLayerName( layer ) );
|
2014-06-24 16:17:18 +00:00
|
|
|
|
|
|
|
if( m_plotOpts.GetLayerSelection()[layer] )
|
2012-09-15 12:13:03 +00:00
|
|
|
m_layerCheckListBox->Check( checkIndex );
|
|
|
|
}
|
|
|
|
|
2020-10-10 12:39:54 +00:00
|
|
|
// Option for disabling Gerber Aperture Macro (for broken Gerber readers)
|
|
|
|
m_disableApertMacros->SetValue( m_plotOpts.GetDisableGerberMacros() );
|
|
|
|
|
2018-12-08 16:46:41 +00:00
|
|
|
// Option for using proper Gerber extensions. Note also Protel extensions are
|
|
|
|
// a broken feature. However, for now, we need to handle it.
|
2015-10-21 06:55:30 +00:00
|
|
|
m_useGerberExtensions->SetValue( m_plotOpts.GetUseGerberProtelExtensions() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2018-12-08 16:46:41 +00:00
|
|
|
// Option for including Gerber attributes, from Gerber X2 format, in the output
|
|
|
|
// In X1 format, they will be added as comments
|
|
|
|
m_useGerberX2Format->SetValue( m_plotOpts.GetUseGerberX2format() );
|
2016-09-19 11:01:36 +00:00
|
|
|
|
|
|
|
// Option for including Gerber netlist info (from Gerber X2 format) in the output
|
|
|
|
m_useGerberNetAttributes->SetValue( m_plotOpts.GetIncludeGerberNetlistInfo() );
|
2016-11-22 08:10:47 +00:00
|
|
|
|
2017-08-19 16:28:11 +00:00
|
|
|
// Option to generate a Gerber job file
|
|
|
|
m_generateGerberJobFile->SetValue( m_plotOpts.GetCreateGerberJobFile() );
|
|
|
|
|
2014-07-04 14:22:38 +00:00
|
|
|
// Gerber precision for coordinates
|
2018-06-13 12:20:29 +00:00
|
|
|
m_coordFormatCtrl->SetSelection( m_plotOpts.GetGerberPrecision() == 5 ? 0 : 1 );
|
2014-07-04 14:22:38 +00:00
|
|
|
|
2020-04-20 22:02:03 +00:00
|
|
|
// SVG precision and units for coordinates
|
|
|
|
m_svgPrecsision->SetValue( m_plotOpts.GetSvgPrecision() );
|
|
|
|
m_svgUnits->SetSelection( m_plotOpts.GetSvgUseInch() );
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
// Option for excluding contents of "Edges Pcb" layer
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->SetValue( !m_plotOpts.GetExcludeEdgeLayer() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2018-02-09 01:05:35 +00:00
|
|
|
// Option to exclude pads from silkscreen layers
|
2020-05-01 16:24:01 +00:00
|
|
|
m_sketchPadsOnFabLayers->SetValue( m_plotOpts.GetSketchPadsOnFabLayers() );
|
2018-02-09 01:05:35 +00:00
|
|
|
|
2019-07-20 13:54:06 +00:00
|
|
|
// Option to tent vias
|
2012-09-15 12:13:03 +00:00
|
|
|
m_subtractMaskFromSilk->SetValue( m_plotOpts.GetSubtractMaskFromSilk() );
|
|
|
|
|
2019-07-20 13:54:06 +00:00
|
|
|
// Option to use aux origin
|
|
|
|
m_useAuxOriginCheckBox->SetValue( m_plotOpts.GetUseAuxOrigin() );
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
// Option to plot page references:
|
|
|
|
m_plotSheetRef->SetValue( m_plotOpts.GetPlotFrameRef() );
|
|
|
|
|
|
|
|
// Options to plot texts on footprints
|
|
|
|
m_plotModuleValueOpt->SetValue( m_plotOpts.GetPlotValue() );
|
|
|
|
m_plotModuleRefOpt->SetValue( m_plotOpts.GetPlotReference() );
|
|
|
|
m_plotInvisibleText->SetValue( m_plotOpts.GetPlotInvisibleText() );
|
|
|
|
|
|
|
|
// Options to plot pads and vias holes
|
|
|
|
m_drillShapeOpt->SetSelection( m_plotOpts.GetDrillMarksType() );
|
|
|
|
|
|
|
|
// Scale option
|
|
|
|
m_scaleOpt->SetSelection( m_plotOpts.GetScaleSelection() );
|
|
|
|
|
|
|
|
// Plot mode
|
2015-02-03 10:35:46 +00:00
|
|
|
setPlotModeChoiceSelection( m_plotOpts.GetPlotMode() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2019-07-20 13:54:06 +00:00
|
|
|
// DXF outline mode
|
2017-07-30 18:27:03 +00:00
|
|
|
m_DXF_plotModeOpt->SetValue( m_plotOpts.GetDXFPlotPolygonMode() );
|
2017-04-22 20:15:08 +00:00
|
|
|
|
2019-07-20 13:54:06 +00:00
|
|
|
// DXF text mode
|
2019-12-28 00:55:11 +00:00
|
|
|
m_DXF_plotTextStrokeFontOpt->SetValue( m_plotOpts.GetTextMode() == PLOT_TEXT_MODE::DEFAULT );
|
2017-04-16 17:07:31 +00:00
|
|
|
|
2019-07-20 13:54:06 +00:00
|
|
|
// DXF units selection
|
2020-10-21 16:29:53 +00:00
|
|
|
m_DXF_plotUnits->SetSelection( m_plotOpts.GetDXFPlotUnits() == DXF_UNITS::INCHES ? 0 : 1);
|
2019-07-20 13:45:08 +00:00
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
// Plot mirror option
|
|
|
|
m_plotMirrorOpt->SetValue( m_plotOpts.GetMirror() );
|
|
|
|
|
|
|
|
// Put vias on mask layer
|
|
|
|
m_plotNoViaOnMaskOpt->SetValue( m_plotOpts.GetPlotViaOnMaskLayer() );
|
|
|
|
|
2017-07-10 13:16:57 +00:00
|
|
|
// Initialize a few other parameters, which can also be modified
|
|
|
|
// from the drill dialog
|
|
|
|
reInitDialog();
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// Update options values:
|
|
|
|
wxCommandEvent cmd_event;
|
|
|
|
SetPlotFormat( cmd_event );
|
|
|
|
OnSetScaleOpt( cmd_event );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-07-10 13:16:57 +00:00
|
|
|
void DIALOG_PLOT::reInitDialog()
|
|
|
|
{
|
2020-03-06 12:04:47 +00:00
|
|
|
// after calling the Drill or DRC dialogs some parameters can be modified....
|
2017-07-10 13:16:57 +00:00
|
|
|
|
|
|
|
// Output directory
|
|
|
|
m_outputDirectoryName->SetValue( m_plotOpts.GetOutputDirectory() );
|
|
|
|
|
|
|
|
// Origin of coordinates:
|
|
|
|
m_useAuxOriginCheckBox->SetValue( m_plotOpts.GetUseAuxOrigin() );
|
2020-03-06 12:04:47 +00:00
|
|
|
|
|
|
|
int knownViolations = 0;
|
|
|
|
int exclusions = 0;
|
|
|
|
|
2020-11-14 18:11:28 +00:00
|
|
|
for( PCB_MARKER* marker : m_parent->GetBoard()->Markers() )
|
2020-03-06 12:04:47 +00:00
|
|
|
{
|
|
|
|
if( marker->IsExcluded() )
|
|
|
|
exclusions++;
|
|
|
|
else
|
|
|
|
knownViolations++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( knownViolations || exclusions )
|
|
|
|
{
|
|
|
|
m_DRCExclusionsWarning->SetLabel( wxString::Format( m_DRCWarningTemplate,
|
|
|
|
knownViolations,
|
|
|
|
exclusions ) );
|
|
|
|
m_DRCExclusionsWarning->Show();
|
|
|
|
}
|
|
|
|
else
|
2020-09-20 20:17:33 +00:00
|
|
|
{
|
2020-03-06 12:04:47 +00:00
|
|
|
m_DRCExclusionsWarning->Hide();
|
2020-09-20 20:17:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BOARD* board = m_parent->GetBoard();
|
|
|
|
const BOARD_DESIGN_SETTINGS& brd_settings = board->GetDesignSettings();
|
|
|
|
|
|
|
|
if( getPlotFormat() == PLOT_FORMAT::GERBER &&
|
|
|
|
( brd_settings.m_SolderMaskMargin || brd_settings.m_SolderMaskMinWidth ) )
|
|
|
|
{
|
|
|
|
m_PlotOptionsSizer->Show( m_SizerSolderMaskAlert );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_PlotOptionsSizer->Hide( m_SizerSolderMaskAlert );
|
|
|
|
}
|
2017-07-10 13:16:57 +00:00
|
|
|
}
|
|
|
|
|
2018-05-25 16:33:00 +00:00
|
|
|
|
2013-02-21 20:53:50 +00:00
|
|
|
// A helper function to show a popup menu, when the dialog is right clicked.
|
|
|
|
void DIALOG_PLOT::OnRightClick( wxMouseEvent& event )
|
|
|
|
{
|
|
|
|
PopupMenu( m_popMenu );
|
|
|
|
}
|
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2013-02-21 20:53:50 +00:00
|
|
|
// Select or deselect groups of layers in the layers list:
|
|
|
|
void DIALOG_PLOT::OnPopUpLayers( wxCommandEvent& event )
|
|
|
|
{
|
2018-11-23 17:34:38 +00:00
|
|
|
// Build a list of layers for usual fabrication:
|
|
|
|
// copper layers + tech layers without courtyard
|
|
|
|
LSET fab_layer_set = ( LSET::AllCuMask() | LSET::AllTechMask() )
|
|
|
|
& ~LSET( 2, B_CrtYd, F_CrtYd );
|
2013-02-21 20:53:50 +00:00
|
|
|
|
|
|
|
switch( event.GetId() )
|
|
|
|
{
|
2014-06-24 16:17:18 +00:00
|
|
|
case ID_LAYER_FAB: // Select layers usually needed to build a board
|
2018-11-23 17:34:38 +00:00
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
|
|
|
LSET layermask( m_layerList[ i ] );
|
|
|
|
|
2018-11-23 17:34:38 +00:00
|
|
|
if( ( layermask & fab_layer_set ).any() )
|
2014-06-24 16:17:18 +00:00
|
|
|
m_layerCheckListBox->Check( i, true );
|
|
|
|
else
|
|
|
|
m_layerCheckListBox->Check( i, false );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_SELECT_COPPER_LAYERS:
|
2018-11-23 17:34:38 +00:00
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
|
|
|
if( IsCopperLayer( m_layerList[i] ) )
|
2013-02-21 20:53:50 +00:00
|
|
|
m_layerCheckListBox->Check( i, true );
|
2014-06-24 16:17:18 +00:00
|
|
|
}
|
|
|
|
break;
|
2013-02-21 20:53:50 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
case ID_DESELECT_COPPER_LAYERS:
|
2018-11-23 17:34:38 +00:00
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
|
|
|
if( IsCopperLayer( m_layerList[i] ) )
|
2013-02-21 20:53:50 +00:00
|
|
|
m_layerCheckListBox->Check( i, false );
|
2014-06-24 16:17:18 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_SELECT_ALL_LAYERS:
|
2018-11-23 17:34:38 +00:00
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2014-06-24 16:17:18 +00:00
|
|
|
m_layerCheckListBox->Check( i, true );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ID_DESELECT_ALL_LAYERS:
|
2018-11-23 17:34:38 +00:00
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2014-06-24 16:17:18 +00:00
|
|
|
m_layerCheckListBox->Check( i, false );
|
|
|
|
break;
|
2013-02-21 20:53:50 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
default:
|
|
|
|
break;
|
2013-02-21 20:53:50 +00:00
|
|
|
}
|
|
|
|
}
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
void DIALOG_PLOT::CreateDrillFile( wxCommandEvent& event )
|
|
|
|
{
|
2017-04-28 10:53:30 +00:00
|
|
|
// Be sure drill file use the same settings (axis option, plot directory)
|
2019-02-13 10:41:52 +00:00
|
|
|
// as plot files:
|
2017-04-28 10:53:30 +00:00
|
|
|
applyPlotSettings();
|
2019-02-13 10:41:52 +00:00
|
|
|
|
|
|
|
DIALOG_GENDRILL dlg( m_parent, this );
|
|
|
|
dlg.ShowModal();
|
2017-04-28 10:53:30 +00:00
|
|
|
|
|
|
|
// a few plot settings can be modified: take them in account
|
|
|
|
m_plotOpts = m_parent->GetPlotSettings();
|
2017-07-10 13:16:57 +00:00
|
|
|
reInitDialog();
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-07-30 18:27:03 +00:00
|
|
|
void DIALOG_PLOT::OnChangeDXFPlotMode( wxCommandEvent& event )
|
2017-04-16 17:07:31 +00:00
|
|
|
{
|
2017-07-30 18:27:03 +00:00
|
|
|
// m_DXF_plotTextStrokeFontOpt is disabled if m_DXF_plotModeOpt
|
|
|
|
// is checked (plot in DXF polygon mode)
|
|
|
|
m_DXF_plotTextStrokeFontOpt->Enable( !m_DXF_plotModeOpt->GetValue() );
|
|
|
|
|
|
|
|
// if m_DXF_plotTextStrokeFontOpt option is disabled (plot DXF in polygon mode),
|
|
|
|
// force m_DXF_plotTextStrokeFontOpt to true to use Pcbnew stroke font
|
|
|
|
if( !m_DXF_plotTextStrokeFontOpt->IsEnabled() )
|
|
|
|
m_DXF_plotTextStrokeFontOpt->SetValue( true );
|
2017-04-16 17:07:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
void DIALOG_PLOT::OnSetScaleOpt( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
/* Disable sheet reference for scale != 1:1 */
|
|
|
|
bool scale1 = ( m_scaleOpt->GetSelection() == 1 );
|
|
|
|
|
|
|
|
m_plotSheetRef->Enable( scale1 );
|
|
|
|
|
|
|
|
if( !scale1 )
|
|
|
|
m_plotSheetRef->SetValue( false );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void DIALOG_PLOT::OnOutputDirectoryBrowseClicked( wxCommandEvent& event )
|
|
|
|
{
|
2020-04-05 21:10:42 +00:00
|
|
|
// Build the absolute path of current output directory to preselect it in the file browser.
|
|
|
|
wxString path = ExpandEnvVarSubstitutions( m_outputDirectoryName->GetValue(), &Prj() );
|
|
|
|
path = Prj().AbsolutePath( path );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
wxDirDialog dirDialog( this, _( "Select Output Directory" ), path );
|
|
|
|
|
|
|
|
if( dirDialog.ShowModal() == wxID_CANCEL )
|
|
|
|
return;
|
|
|
|
|
|
|
|
wxFileName dirName = wxFileName::DirName( dirDialog.GetPath() );
|
|
|
|
|
2020-04-05 21:10:42 +00:00
|
|
|
wxFileName fn( Prj().AbsolutePath( m_parent->GetBoard()->GetFileName() ) );
|
2020-08-20 00:10:36 +00:00
|
|
|
wxString defaultPath = fn.GetPathWithSep();
|
|
|
|
wxString msg;
|
|
|
|
wxFileName relPathTest; // Used to test if we can make the path relative
|
2014-11-06 15:27:22 +00:00
|
|
|
|
2020-08-20 00:10:36 +00:00
|
|
|
relPathTest.Assign( dirDialog.GetPath() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2020-08-20 00:10:36 +00:00
|
|
|
// Test if making the path relative is possible before asking the user if they want to do it
|
|
|
|
if( relPathTest.MakeRelativeTo( defaultPath ) )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2020-10-16 00:39:55 +00:00
|
|
|
msg.Printf( _( "Do you want to use a path relative to\n\"%s\"" ), defaultPath );
|
2020-08-20 00:10:36 +00:00
|
|
|
|
|
|
|
wxMessageDialog dialog( this, msg, _( "Plot Output Directory" ),
|
|
|
|
wxYES_NO | wxICON_QUESTION | wxYES_DEFAULT );
|
|
|
|
|
|
|
|
if( dialog.ShowModal() == wxID_YES )
|
|
|
|
dirName.MakeRelativeTo( defaultPath );
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
m_outputDirectoryName->SetValue( dirName.GetFullPath() );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
PLOT_FORMAT DIALOG_PLOT::getPlotFormat()
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
|
|
|
// plot format id's are ordered like displayed in m_plotFormatOpt
|
2019-12-28 00:55:11 +00:00
|
|
|
static const PLOT_FORMAT plotFmt[] = { PLOT_FORMAT::GERBER, PLOT_FORMAT::POST, PLOT_FORMAT::SVG,
|
|
|
|
PLOT_FORMAT::DXF, PLOT_FORMAT::HPGL, PLOT_FORMAT::PDF };
|
|
|
|
|
|
|
|
return plotFmt[m_plotFormatOpt->GetSelection()];
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2012-09-24 06:39:59 +00:00
|
|
|
// Enable or disable widgets according to the plot format selected
|
|
|
|
// and clear also some optional values
|
2012-09-15 12:13:03 +00:00
|
|
|
void DIALOG_PLOT::SetPlotFormat( wxCommandEvent& event )
|
|
|
|
{
|
2017-07-30 18:27:03 +00:00
|
|
|
// this option exist only in DXF format:
|
2019-12-28 00:55:11 +00:00
|
|
|
m_DXF_plotModeOpt->Enable( getPlotFormat() == PLOT_FORMAT::DXF );
|
2017-07-30 18:27:03 +00:00
|
|
|
|
2020-06-05 14:06:03 +00:00
|
|
|
// The alert message about non 0 solder mask min width and margin is shown
|
|
|
|
// only in gerber format and if min mask width or mask margin is not 0
|
|
|
|
BOARD* board = m_parent->GetBoard();
|
|
|
|
const BOARD_DESIGN_SETTINGS& brd_settings = board->GetDesignSettings();
|
|
|
|
|
|
|
|
if( getPlotFormat() == PLOT_FORMAT::GERBER &&
|
|
|
|
( brd_settings.m_SolderMaskMargin || brd_settings.m_SolderMaskMinWidth ) )
|
2020-09-20 20:17:33 +00:00
|
|
|
{
|
2020-06-05 14:06:03 +00:00
|
|
|
m_PlotOptionsSizer->Show( m_SizerSolderMaskAlert );
|
2020-09-20 20:17:33 +00:00
|
|
|
}
|
2020-06-05 14:06:03 +00:00
|
|
|
else
|
2020-09-20 20:17:33 +00:00
|
|
|
{
|
2020-06-05 14:06:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_SizerSolderMaskAlert );
|
2020-09-20 20:17:33 +00:00
|
|
|
}
|
2020-06-05 14:06:03 +00:00
|
|
|
|
|
|
|
|
2015-02-03 10:35:46 +00:00
|
|
|
switch( getPlotFormat() )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::SVG:
|
2020-04-20 22:02:03 +00:00
|
|
|
case PLOT_FORMAT::PDF:
|
2012-09-15 12:13:03 +00:00
|
|
|
m_drillShapeOpt->Enable( true );
|
|
|
|
m_plotModeOpt->Enable( false );
|
2015-02-03 10:35:46 +00:00
|
|
|
setPlotModeChoiceSelection( FILLED );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotMirrorOpt->Enable( true );
|
|
|
|
m_useAuxOriginCheckBox->Enable( false );
|
|
|
|
m_useAuxOriginCheckBox->SetValue( false );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.Enable( false );
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_scaleOpt->Enable( false );
|
2012-09-24 06:39:59 +00:00
|
|
|
m_scaleOpt->SetSelection( 1 );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->Enable( false );
|
|
|
|
m_fineAdjustYCtrl->Enable( false );
|
|
|
|
m_trackWidthCorrection.Enable( false );
|
2012-09-24 06:39:59 +00:00
|
|
|
m_plotPSNegativeOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_forcePSA4OutputOpt->Enable( false );
|
2012-09-24 06:39:59 +00:00
|
|
|
m_forcePSA4OutputOpt->SetValue( false );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2020-06-06 18:50:24 +00:00
|
|
|
if( getPlotFormat() == PLOT_FORMAT::SVG )
|
|
|
|
m_PlotOptionsSizer->Show( m_svgOptionsSizer );
|
|
|
|
else
|
|
|
|
m_PlotOptionsSizer->Hide( m_svgOptionsSizer );
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_GerberOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_HPGLOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_PSOptionsSizer );
|
2017-07-30 18:27:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_SizerDXF_options );
|
2012-09-15 12:13:03 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::POST:
|
2012-09-15 12:13:03 +00:00
|
|
|
m_drillShapeOpt->Enable( true );
|
|
|
|
m_plotModeOpt->Enable( true );
|
|
|
|
m_plotMirrorOpt->Enable( true );
|
|
|
|
m_useAuxOriginCheckBox->Enable( false );
|
|
|
|
m_useAuxOriginCheckBox->SetValue( false );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.Enable( false );
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_scaleOpt->Enable( true );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->Enable( true );
|
|
|
|
m_fineAdjustYCtrl->Enable( true );
|
|
|
|
m_trackWidthCorrection.Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotPSNegativeOpt->Enable( true );
|
|
|
|
m_forcePSA4OutputOpt->Enable( true );
|
|
|
|
|
|
|
|
m_PlotOptionsSizer->Hide( m_GerberOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_HPGLOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Show( m_PSOptionsSizer );
|
2017-07-30 18:27:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_SizerDXF_options );
|
2020-04-20 22:02:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_svgOptionsSizer );
|
2012-09-15 12:13:03 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::GERBER:
|
2012-09-15 12:13:03 +00:00
|
|
|
m_drillShapeOpt->Enable( false );
|
|
|
|
m_drillShapeOpt->SetSelection( 0 );
|
|
|
|
m_plotModeOpt->Enable( false );
|
2015-02-03 10:35:46 +00:00
|
|
|
setPlotModeChoiceSelection( FILLED );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotMirrorOpt->Enable( false );
|
|
|
|
m_plotMirrorOpt->SetValue( false );
|
|
|
|
m_useAuxOriginCheckBox->Enable( true );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.Enable( false );
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_scaleOpt->Enable( false );
|
|
|
|
m_scaleOpt->SetSelection( 1 );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->Enable( false );
|
|
|
|
m_fineAdjustYCtrl->Enable( false );
|
|
|
|
m_trackWidthCorrection.Enable( false );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotPSNegativeOpt->Enable( false );
|
|
|
|
m_plotPSNegativeOpt->SetValue( false );
|
|
|
|
m_forcePSA4OutputOpt->Enable( false );
|
|
|
|
m_forcePSA4OutputOpt->SetValue( false );
|
|
|
|
|
|
|
|
m_PlotOptionsSizer->Show( m_GerberOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_HPGLOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_PSOptionsSizer );
|
2017-07-30 18:27:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_SizerDXF_options );
|
2020-04-20 22:02:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_svgOptionsSizer );
|
2012-09-15 12:13:03 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::HPGL:
|
2012-09-15 12:13:03 +00:00
|
|
|
m_drillShapeOpt->Enable( true );
|
|
|
|
m_plotModeOpt->Enable( true );
|
|
|
|
m_plotMirrorOpt->Enable( true );
|
|
|
|
m_useAuxOriginCheckBox->Enable( false );
|
|
|
|
m_useAuxOriginCheckBox->SetValue( false );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.Enable( true );
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_scaleOpt->Enable( true );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->Enable( false );
|
|
|
|
m_fineAdjustYCtrl->Enable( false );
|
|
|
|
m_trackWidthCorrection.Enable( false );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotPSNegativeOpt->SetValue( false );
|
|
|
|
m_plotPSNegativeOpt->Enable( false );
|
|
|
|
m_forcePSA4OutputOpt->Enable( true );
|
|
|
|
|
|
|
|
m_PlotOptionsSizer->Hide( m_GerberOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Show( m_HPGLOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_PSOptionsSizer );
|
2017-07-30 18:27:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_SizerDXF_options );
|
2020-04-20 22:02:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_svgOptionsSizer );
|
2012-09-15 12:13:03 +00:00
|
|
|
break;
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::DXF:
|
2012-09-15 12:13:03 +00:00
|
|
|
m_drillShapeOpt->Enable( true );
|
2014-05-19 18:24:07 +00:00
|
|
|
m_plotModeOpt->Enable( false );
|
2017-04-22 20:15:08 +00:00
|
|
|
setPlotModeChoiceSelection( FILLED );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotMirrorOpt->Enable( false );
|
|
|
|
m_plotMirrorOpt->SetValue( false );
|
|
|
|
m_useAuxOriginCheckBox->Enable( true );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.Enable( false );
|
2021-04-16 12:12:55 +00:00
|
|
|
m_includeEdgeLayerOpt->Enable( true );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_scaleOpt->Enable( false );
|
|
|
|
m_scaleOpt->SetSelection( 1 );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->Enable( false );
|
|
|
|
m_fineAdjustYCtrl->Enable( false );
|
|
|
|
m_trackWidthCorrection.Enable( false );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotPSNegativeOpt->Enable( false );
|
|
|
|
m_plotPSNegativeOpt->SetValue( false );
|
|
|
|
m_forcePSA4OutputOpt->Enable( false );
|
|
|
|
m_forcePSA4OutputOpt->SetValue( false );
|
|
|
|
|
2014-05-19 18:24:07 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_GerberOptionsSizer );
|
2012-09-15 12:13:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_HPGLOptionsSizer );
|
|
|
|
m_PlotOptionsSizer->Hide( m_PSOptionsSizer );
|
2017-07-30 18:27:03 +00:00
|
|
|
m_PlotOptionsSizer->Show( m_SizerDXF_options );
|
2020-04-20 22:02:03 +00:00
|
|
|
m_PlotOptionsSizer->Hide( m_svgOptionsSizer );
|
2017-04-16 17:07:31 +00:00
|
|
|
|
2017-07-30 18:27:03 +00:00
|
|
|
OnChangeDXFPlotMode( event );
|
2012-09-15 12:13:03 +00:00
|
|
|
break;
|
2018-07-27 09:18:24 +00:00
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
case PLOT_FORMAT::UNDEFINED:
|
2018-07-27 09:18:24 +00:00
|
|
|
break;
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the interlock between scale and frame reference
|
|
|
|
* (scaling would mess up the frame border...) */
|
|
|
|
OnSetScaleOpt( event );
|
|
|
|
|
|
|
|
Layout();
|
|
|
|
m_MainSizer->SetSizeHints( this );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// A helper function to "clip" aValue between aMin and aMax
|
|
|
|
// and write result in * aResult
|
|
|
|
// return false if clipped, true if aValue is just copied into * aResult
|
|
|
|
static bool setDouble( double* aResult, double aValue, double aMin, double aMax )
|
|
|
|
{
|
|
|
|
if( aValue < aMin )
|
|
|
|
{
|
|
|
|
*aResult = aMin;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if( aValue > aMax )
|
|
|
|
{
|
|
|
|
*aResult = aMax;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = aValue;
|
|
|
|
return true;
|
|
|
|
}
|
2013-05-10 19:22:29 +00:00
|
|
|
|
|
|
|
|
2012-09-24 06:39:59 +00:00
|
|
|
static bool setInt( int* aResult, int aValue, int aMin, int aMax )
|
|
|
|
{
|
|
|
|
if( aValue < aMin )
|
|
|
|
{
|
|
|
|
*aResult = aMin;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if( aValue > aMax )
|
|
|
|
{
|
|
|
|
*aResult = aMax;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aResult = aValue;
|
|
|
|
return true;
|
|
|
|
}
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
void DIALOG_PLOT::applyPlotSettings()
|
|
|
|
{
|
2019-07-20 13:45:08 +00:00
|
|
|
REPORTER& reporter = m_messagesPanel->Reporter();
|
|
|
|
int sel;
|
2012-09-15 12:13:03 +00:00
|
|
|
PCB_PLOT_PARAMS tempOptions;
|
|
|
|
|
2021-04-16 12:12:55 +00:00
|
|
|
tempOptions.SetExcludeEdgeLayer( !m_includeEdgeLayerOpt->GetValue() );
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetSubtractMaskFromSilk( m_subtractMaskFromSilk->GetValue() );
|
|
|
|
tempOptions.SetPlotFrameRef( m_plotSheetRef->GetValue() );
|
2020-11-24 22:16:41 +00:00
|
|
|
tempOptions.SetSketchPadsOnFabLayers( m_sketchPadsOnFabLayers->GetValue() );
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetUseAuxOrigin( m_useAuxOriginCheckBox->GetValue() );
|
|
|
|
tempOptions.SetPlotValue( m_plotModuleValueOpt->GetValue() );
|
|
|
|
tempOptions.SetPlotReference( m_plotModuleRefOpt->GetValue() );
|
|
|
|
tempOptions.SetPlotInvisibleText( m_plotInvisibleText->GetValue() );
|
|
|
|
tempOptions.SetScaleSelection( m_scaleOpt->GetSelection() );
|
2019-07-20 13:45:08 +00:00
|
|
|
|
|
|
|
sel = m_drillShapeOpt->GetSelection();
|
|
|
|
tempOptions.SetDrillMarksType( static_cast<PCB_PLOT_PARAMS::DrillMarksType>( sel ) );
|
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetMirror( m_plotMirrorOpt->GetValue() );
|
2015-02-02 08:06:39 +00:00
|
|
|
tempOptions.SetPlotMode( m_plotModeOpt->GetSelection() == 1 ? SKETCH : FILLED );
|
2017-07-30 18:27:03 +00:00
|
|
|
tempOptions.SetDXFPlotPolygonMode( m_DXF_plotModeOpt->GetValue() );
|
2019-07-20 13:45:08 +00:00
|
|
|
|
|
|
|
sel = m_DXF_plotUnits->GetSelection();
|
2020-10-21 16:29:53 +00:00
|
|
|
tempOptions.SetDXFPlotUnits( sel == 0 ? DXF_UNITS::INCHES : DXF_UNITS::MILLIMETERS );
|
2019-07-20 13:45:08 +00:00
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetPlotViaOnMaskLayer( m_plotNoViaOnMaskOpt->GetValue() );
|
2017-07-30 08:57:16 +00:00
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
if( !m_DXF_plotTextStrokeFontOpt->IsEnabled() ) // Currently, only DXF supports this option
|
|
|
|
tempOptions.SetTextMode( PLOT_TEXT_MODE::DEFAULT );
|
2017-07-30 08:57:16 +00:00
|
|
|
else
|
2019-12-28 00:55:11 +00:00
|
|
|
tempOptions.SetTextMode( m_DXF_plotTextStrokeFontOpt->GetValue() ? PLOT_TEXT_MODE::DEFAULT :
|
|
|
|
PLOT_TEXT_MODE::NATIVE );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// Update settings from text fields. Rewrite values back to the fields,
|
|
|
|
// since the values may have been constrained by the setters.
|
2018-05-26 15:34:00 +00:00
|
|
|
wxString msg;
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// read HPLG pen size (this param is stored in mils)
|
2018-05-26 15:34:00 +00:00
|
|
|
// However, due to issues when converting this value from or to mm
|
|
|
|
// that can slightly change the value, update this param only if it
|
|
|
|
// is in use
|
2019-12-28 00:55:11 +00:00
|
|
|
if( getPlotFormat() == PLOT_FORMAT::HPGL )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2018-06-13 12:20:29 +00:00
|
|
|
if( !tempOptions.SetHPGLPenDiameter( m_defaultPenSize.GetValue() / IU_PER_MILS ) )
|
2018-05-26 15:34:00 +00:00
|
|
|
{
|
2018-06-13 12:20:29 +00:00
|
|
|
m_defaultPenSize.SetValue( tempOptions.GetHPGLPenDiameter() * IU_PER_MILS );
|
2018-05-26 15:34:00 +00:00
|
|
|
msg.Printf( _( "HPGL pen size constrained." ) );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_INFO );
|
2018-05-26 15:34:00 +00:00
|
|
|
}
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
2018-05-26 15:34:00 +00:00
|
|
|
else // keep the last value (initial value if no HPGL plot made)
|
|
|
|
tempOptions.SetHPGLPenDiameter( m_plotOpts.GetHPGLPenDiameter() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
|
|
|
// X scale
|
|
|
|
double tmpDouble;
|
2018-06-13 12:20:29 +00:00
|
|
|
msg = m_fineAdjustXCtrl->GetValue();
|
2012-09-15 12:13:03 +00:00
|
|
|
msg.ToDouble( &tmpDouble );
|
|
|
|
|
|
|
|
if( !setDouble( &m_XScaleAdjust, tmpDouble, PLOT_MIN_SCALE, PLOT_MAX_SCALE ) )
|
|
|
|
{
|
|
|
|
msg.Printf( wxT( "%f" ), m_XScaleAdjust );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustXCtrl->SetValue( msg );
|
2015-06-16 12:20:42 +00:00
|
|
|
msg.Printf( _( "X scale constrained." ) );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_INFO );
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Y scale
|
2018-06-13 12:20:29 +00:00
|
|
|
msg = m_fineAdjustYCtrl->GetValue();
|
2012-09-15 12:13:03 +00:00
|
|
|
msg.ToDouble( &tmpDouble );
|
|
|
|
|
|
|
|
if( !setDouble( &m_YScaleAdjust, tmpDouble, PLOT_MIN_SCALE, PLOT_MAX_SCALE ) )
|
|
|
|
{
|
|
|
|
msg.Printf( wxT( "%f" ), m_YScaleAdjust );
|
2018-06-13 12:20:29 +00:00
|
|
|
m_fineAdjustYCtrl->SetValue( msg );
|
2015-06-16 12:20:42 +00:00
|
|
|
msg.Printf( _( "Y scale constrained." ) );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_INFO );
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
2020-05-06 01:43:37 +00:00
|
|
|
auto cfg = m_parent->GetPcbNewSettings();
|
2020-01-13 01:44:19 +00:00
|
|
|
|
|
|
|
cfg->m_Plot.fine_scale_x = m_XScaleAdjust;
|
|
|
|
cfg->m_Plot.fine_scale_y = m_YScaleAdjust;
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2020-01-13 01:44:19 +00:00
|
|
|
cfg->m_Plot.check_zones_before_plotting = m_zoneFillCheck->GetValue();
|
2018-05-07 23:21:21 +00:00
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
// PS Width correction
|
2018-06-13 12:20:29 +00:00
|
|
|
if( !setInt( &m_PSWidthAdjust, m_trackWidthCorrection.GetValue(),
|
|
|
|
m_widthAdjustMinValue, m_widthAdjustMaxValue ) )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
2018-06-13 12:20:29 +00:00
|
|
|
m_trackWidthCorrection.SetValue( m_PSWidthAdjust );
|
2015-06-16 12:20:42 +00:00
|
|
|
msg.Printf( _( "Width correction constrained. "
|
|
|
|
"The reasonable width correction value must be in a range of "
|
2018-06-13 12:20:29 +00:00
|
|
|
" [%s; %s] (%s) for current design rules." ),
|
2020-10-02 20:51:24 +00:00
|
|
|
StringFromValue( GetUserUnits(), m_widthAdjustMinValue, false ),
|
|
|
|
StringFromValue( GetUserUnits(), m_widthAdjustMaxValue, false ),
|
|
|
|
GetAbbreviatedUnitsLabel( GetUserUnits() ) );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_WARNING );
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
|
|
|
|
2012-09-24 06:39:59 +00:00
|
|
|
// Store m_PSWidthAdjust in mm in user config
|
2020-01-13 01:44:19 +00:00
|
|
|
cfg->m_Plot.ps_fine_width_adjust = Iu2Millimeter( m_PSWidthAdjust );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2015-02-03 10:35:46 +00:00
|
|
|
tempOptions.SetFormat( getPlotFormat() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2020-10-10 12:39:54 +00:00
|
|
|
tempOptions.SetDisableGerberMacros( m_disableApertMacros->GetValue() );
|
2015-10-21 06:55:30 +00:00
|
|
|
tempOptions.SetUseGerberProtelExtensions( m_useGerberExtensions->GetValue() );
|
2018-12-08 16:46:41 +00:00
|
|
|
tempOptions.SetUseGerberX2format( m_useGerberX2Format->GetValue() );
|
2016-09-19 11:01:36 +00:00
|
|
|
tempOptions.SetIncludeGerberNetlistInfo( m_useGerberNetAttributes->GetValue() );
|
2017-08-19 16:28:11 +00:00
|
|
|
tempOptions.SetCreateGerberJobFile( m_generateGerberJobFile->GetValue() );
|
|
|
|
|
2018-06-13 12:20:29 +00:00
|
|
|
tempOptions.SetGerberPrecision( m_coordFormatCtrl->GetSelection() == 0 ? 5 : 6 );
|
2020-04-20 22:02:03 +00:00
|
|
|
tempOptions.SetSvgPrecision( m_svgPrecsision->GetValue(), m_svgUnits->GetSelection() );
|
2012-09-15 12:13:03 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
LSET selectedLayers;
|
|
|
|
for( unsigned i = 0; i < m_layerList.size(); i++ )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
|
|
|
if( m_layerCheckListBox->IsChecked( i ) )
|
2014-06-24 16:17:18 +00:00
|
|
|
selectedLayers.set( m_layerList[i] );
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
2015-12-08 15:15:24 +00:00
|
|
|
// Get a list of copper layers that aren't being used by inverting enabled layers.
|
2018-02-22 15:25:31 +00:00
|
|
|
LSET disabledCopperLayers = LSET::AllCuMask() & ~m_parent->GetBoard()->GetEnabledLayers();
|
2015-12-08 15:15:24 +00:00
|
|
|
// Enable all of the disabled copper layers.
|
|
|
|
// If someone enables more copper layers they will be selected by default.
|
|
|
|
selectedLayers = selectedLayers | disabledCopperLayers;
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetLayerSelection( selectedLayers );
|
2015-12-14 21:20:54 +00:00
|
|
|
|
2012-09-15 12:13:03 +00:00
|
|
|
tempOptions.SetNegative( m_plotPSNegativeOpt->GetValue() );
|
|
|
|
tempOptions.SetA4Output( m_forcePSA4OutputOpt->GetValue() );
|
|
|
|
|
|
|
|
// Set output directory and replace backslashes with forward ones
|
|
|
|
wxString dirStr;
|
|
|
|
dirStr = m_outputDirectoryName->GetValue();
|
|
|
|
dirStr.Replace( wxT( "\\" ), wxT( "/" ) );
|
|
|
|
tempOptions.SetOutputDirectory( dirStr );
|
|
|
|
|
2021-01-03 13:59:23 +00:00
|
|
|
if( !m_plotOpts.IsSameAs( tempOptions ) )
|
2012-09-15 12:13:03 +00:00
|
|
|
{
|
|
|
|
m_parent->SetPlotSettings( tempOptions );
|
2021-01-03 13:59:23 +00:00
|
|
|
m_parent->OnModify();
|
2012-09-15 12:13:03 +00:00
|
|
|
m_plotOpts = tempOptions;
|
|
|
|
}
|
2016-11-22 08:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void DIALOG_PLOT::OnGerberX2Checked( wxCommandEvent& event )
|
|
|
|
{
|
2018-12-08 16:46:41 +00:00
|
|
|
// Currently: do nothing
|
2012-09-15 12:13:03 +00:00
|
|
|
}
|
2013-05-10 19:22:29 +00:00
|
|
|
|
|
|
|
|
2018-05-07 23:21:21 +00:00
|
|
|
void DIALOG_PLOT::Plot( wxCommandEvent& event )
|
2013-05-10 19:22:29 +00:00
|
|
|
{
|
2018-02-22 15:25:31 +00:00
|
|
|
BOARD* board = m_parent->GetBoard();
|
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
applyPlotSettings();
|
|
|
|
|
2020-06-06 17:57:28 +00:00
|
|
|
SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
|
|
|
|
PCBNEW_SETTINGS* cfg = mgr.GetAppSettings<PCBNEW_SETTINGS>();
|
|
|
|
|
|
|
|
m_plotOpts.SetColorSettings( mgr.GetColorSettings( cfg->m_ColorTheme ) );
|
|
|
|
|
2020-05-01 16:24:01 +00:00
|
|
|
m_plotOpts.SetSketchPadLineWidth( board->GetDesignSettings().GetLineThickness( F_Fab ) );
|
|
|
|
|
2017-08-19 16:28:11 +00:00
|
|
|
// If no layer selected, we have nothing plotted.
|
|
|
|
// Prompt user if it happens because he could think there is a bug in Pcbnew.
|
|
|
|
if( !m_plotOpts.GetLayerSelection().any() )
|
|
|
|
{
|
|
|
|
DisplayError( this, _( "No layer selected, Nothing to plot" ) );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
// Create output directory if it does not exist (also transform it in
|
|
|
|
// absolute form). Bail if it fails
|
2020-04-05 21:10:42 +00:00
|
|
|
wxString path = ExpandEnvVarSubstitutions( m_plotOpts.GetOutputDirectory(), &Prj() );
|
|
|
|
wxFileName outputDir = wxFileName::DirName( path );
|
2015-06-16 12:20:42 +00:00
|
|
|
wxString boardFilename = m_parent->GetBoard()->GetFileName();
|
|
|
|
REPORTER& reporter = m_messagesPanel->Reporter();
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2014-10-26 13:59:01 +00:00
|
|
|
if( !EnsureFileDirectoryExists( &outputDir, boardFilename, &reporter ) )
|
2013-05-10 19:22:29 +00:00
|
|
|
{
|
|
|
|
wxString msg;
|
2020-10-16 00:39:55 +00:00
|
|
|
msg.Printf( _( "Could not write plot files to folder \"%s\"." ), outputDir.GetPath() );
|
2013-05-10 19:22:29 +00:00
|
|
|
DisplayError( this, msg );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-05-07 23:21:21 +00:00
|
|
|
if( m_zoneFillCheck->GetValue() )
|
2019-07-08 19:44:40 +00:00
|
|
|
m_parent->GetToolManager()->GetTool<ZONE_FILLER_TOOL>()->CheckAllZones( this );
|
2018-05-03 22:23:47 +00:00
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
m_plotOpts.SetAutoScale( false );
|
|
|
|
|
|
|
|
switch( m_plotOpts.GetScaleSelection() )
|
|
|
|
{
|
2020-03-06 12:04:47 +00:00
|
|
|
default: m_plotOpts.SetScale( 1 ); break;
|
|
|
|
case 0: m_plotOpts.SetAutoScale( true ); break;
|
|
|
|
case 2: m_plotOpts.SetScale( 1.5 ); break;
|
|
|
|
case 3: m_plotOpts.SetScale( 2 ); break;
|
|
|
|
case 4: m_plotOpts.SetScale( 3 ); break;
|
2013-05-10 19:22:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If the scale factor edit controls are disabled or the scale value
|
2017-08-19 16:28:11 +00:00
|
|
|
* is 0, don't adjust the base scale factor. This fixes a bug when
|
2013-05-10 19:22:29 +00:00
|
|
|
* the default scale adjust is initialized to 0 and saved in program
|
|
|
|
* settings resulting in a divide by zero fault.
|
|
|
|
*/
|
2019-12-28 00:55:11 +00:00
|
|
|
if( getPlotFormat() == PLOT_FORMAT::POST )
|
2018-06-13 12:20:29 +00:00
|
|
|
{
|
|
|
|
if( m_XScaleAdjust != 0.0 )
|
|
|
|
m_plotOpts.SetFineScaleAdjustX( m_XScaleAdjust );
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2018-06-13 12:20:29 +00:00
|
|
|
if( m_YScaleAdjust != 0.0 )
|
|
|
|
m_plotOpts.SetFineScaleAdjustY( m_YScaleAdjust );
|
2013-05-10 19:22:29 +00:00
|
|
|
|
|
|
|
m_plotOpts.SetWidthAdjust( m_PSWidthAdjust );
|
2018-06-13 12:20:29 +00:00
|
|
|
}
|
2013-05-10 19:22:29 +00:00
|
|
|
|
|
|
|
wxString file_ext( GetDefaultPlotExtension( m_plotOpts.GetFormat() ) );
|
|
|
|
|
|
|
|
// Test for a reasonable scale value
|
|
|
|
// XXX could this actually happen? isn't it constrained in the apply
|
|
|
|
// function?
|
|
|
|
if( m_plotOpts.GetScale() < PLOT_MIN_SCALE )
|
2018-02-28 09:44:22 +00:00
|
|
|
DisplayInfoMessage( this, _( "Warning: Scale option set to a very small value" ) );
|
2013-05-10 19:22:29 +00:00
|
|
|
|
|
|
|
if( m_plotOpts.GetScale() > PLOT_MAX_SCALE )
|
2018-02-28 09:44:22 +00:00
|
|
|
DisplayInfoMessage( this, _( "Warning: Scale option set to a very large value" ) );
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2018-02-22 15:25:31 +00:00
|
|
|
GERBER_JOBFILE_WRITER jobfile_writer( board, &reporter );
|
2017-08-19 16:28:11 +00:00
|
|
|
|
2013-05-10 19:22:29 +00:00
|
|
|
// Save the current plot options in the board
|
|
|
|
m_parent->SetPlotSettings( m_plotOpts );
|
|
|
|
|
2014-05-16 19:03:45 +00:00
|
|
|
wxBusyCursor dummy;
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
for( LSEQ seq = m_plotOpts.GetLayerSelection().UIOrder(); seq; ++seq )
|
2013-05-10 19:22:29 +00:00
|
|
|
{
|
2017-03-13 03:19:33 +00:00
|
|
|
PCB_LAYER_ID layer = *seq;
|
2015-12-14 21:20:54 +00:00
|
|
|
|
2015-12-08 15:15:24 +00:00
|
|
|
// All copper layers that are disabled are actually selected
|
|
|
|
// This is due to wonkyness in automatically selecting copper layers
|
|
|
|
// for plotting when adding more than two layers to a board.
|
|
|
|
// If plot options become accessible to the layers setup dialog
|
|
|
|
// please move this functionality there!
|
|
|
|
// This skips a copper layer if it is actually disabled on the board.
|
2018-02-22 15:25:31 +00:00
|
|
|
if( ( LSET::AllCuMask() & ~board->GetEnabledLayers() )[layer] )
|
2015-12-08 15:15:24 +00:00
|
|
|
continue;
|
2015-12-14 21:20:54 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
// Pick the basename from the board file
|
|
|
|
wxFileName fn( boardFilename );
|
|
|
|
|
|
|
|
// Use Gerber Extensions based on layer number
|
|
|
|
// (See http://en.wikipedia.org/wiki/Gerber_File)
|
2019-12-28 00:55:11 +00:00
|
|
|
if( m_plotOpts.GetFormat() == PLOT_FORMAT::GERBER && m_useGerberExtensions->GetValue() )
|
2015-10-20 18:03:07 +00:00
|
|
|
file_ext = GetGerberProtelExtension( layer );
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2018-02-22 15:25:31 +00:00
|
|
|
BuildPlotFileName( &fn, outputDir.GetPath(), board->GetLayerName( layer ), file_ext );
|
2017-08-19 16:28:11 +00:00
|
|
|
wxString fullname = fn.GetFullName();
|
|
|
|
jobfile_writer.AddGbrFile( layer, fullname );
|
2014-06-24 16:17:18 +00:00
|
|
|
|
|
|
|
LOCALE_IO toggle;
|
|
|
|
|
2020-10-10 12:39:54 +00:00
|
|
|
PLOTTER* plotter = StartPlotBoard( board, &m_plotOpts, layer, fn.GetFullPath(), wxEmptyString );
|
2014-06-24 16:17:18 +00:00
|
|
|
|
|
|
|
// Print diags in messages box:
|
|
|
|
wxString msg;
|
|
|
|
|
|
|
|
if( plotter )
|
2013-05-10 19:22:29 +00:00
|
|
|
{
|
2014-06-24 16:17:18 +00:00
|
|
|
PlotOneBoardLayer( board, plotter, layer, m_plotOpts );
|
|
|
|
plotter->EndPlot();
|
2020-07-06 01:11:17 +00:00
|
|
|
delete plotter->RenderSettings();
|
2014-06-24 16:17:18 +00:00
|
|
|
delete plotter;
|
2013-05-10 19:22:29 +00:00
|
|
|
|
2019-08-27 11:32:00 +00:00
|
|
|
msg.Printf( _( "Plot file \"%s\" created." ), fn.GetFullPath() );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_ACTION );
|
2013-05-10 19:22:29 +00:00
|
|
|
}
|
2014-06-24 16:17:18 +00:00
|
|
|
else
|
2015-06-16 12:20:42 +00:00
|
|
|
{
|
2019-08-27 11:32:00 +00:00
|
|
|
msg.Printf( _( "Unable to create file \"%s\"." ), fn.GetFullPath() );
|
2020-03-04 09:48:18 +00:00
|
|
|
reporter.Report( msg, RPT_SEVERITY_ERROR );
|
2015-06-16 12:20:42 +00:00
|
|
|
}
|
2019-08-27 11:32:00 +00:00
|
|
|
|
|
|
|
wxSafeYield(); // displays report message.
|
2013-05-10 19:22:29 +00:00
|
|
|
}
|
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
if( m_plotOpts.GetFormat() == PLOT_FORMAT::GERBER && m_plotOpts.GetCreateGerberJobFile() )
|
2017-08-19 16:28:11 +00:00
|
|
|
{
|
|
|
|
// Pick the basename from the board file
|
|
|
|
wxFileName fn( boardFilename );
|
|
|
|
// Build gerber job file from basename
|
|
|
|
BuildPlotFileName( &fn, outputDir.GetPath(), "job", GerberJobFileExtension );
|
|
|
|
jobfile_writer.CreateJobFile( fn.GetFullPath() );
|
|
|
|
}
|
2013-05-10 19:22:29 +00:00
|
|
|
}
|
2016-07-27 12:53:45 +00:00
|
|
|
|
2018-01-28 21:02:31 +00:00
|
|
|
|
2016-07-27 12:53:45 +00:00
|
|
|
void DIALOG_PLOT::onRunDRC( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
PCB_EDIT_FRAME* parent = dynamic_cast<PCB_EDIT_FRAME*>( GetParent() );
|
|
|
|
|
|
|
|
if( parent )
|
|
|
|
{
|
2020-09-14 17:54:14 +00:00
|
|
|
DRC_TOOL* drcTool = parent->GetToolManager()->GetTool<DRC_TOOL>();
|
2019-06-03 13:49:17 +00:00
|
|
|
|
2016-07-27 12:53:45 +00:00
|
|
|
// First close an existing dialog if open
|
|
|
|
// (low probability, but can happen)
|
2020-09-16 20:38:23 +00:00
|
|
|
drcTool->DestroyDRCDialog();
|
2016-07-27 12:53:45 +00:00
|
|
|
|
2016-07-28 12:07:35 +00:00
|
|
|
// Open a new drc dialod, with the right parent frame, and in Modal Mode
|
2019-06-03 13:49:17 +00:00
|
|
|
drcTool->ShowDRCDialog( this );
|
2020-03-06 12:04:47 +00:00
|
|
|
|
|
|
|
// Update DRC warnings on return to this dialog
|
|
|
|
reInitDialog();
|
2016-07-27 12:53:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-20 20:17:33 +00:00
|
|
|
|
|
|
|
void DIALOG_PLOT::onBoardSetup( wxHyperlinkEvent& aEvent )
|
|
|
|
{
|
|
|
|
PCB_EDIT_FRAME* parent = dynamic_cast<PCB_EDIT_FRAME*>( GetParent() );
|
|
|
|
|
|
|
|
if( parent )
|
|
|
|
{
|
|
|
|
parent->ShowBoardSetupDialog( _( "Solder Mask/Paste" ) );
|
|
|
|
|
|
|
|
// Update warnings on return to this dialog
|
|
|
|
reInitDialog();
|
|
|
|
}
|
|
|
|
}
|