Shove kicad2step into pcbnew itself with a new cli

CMakeLists.txt

@@ -155,10 +155,6 @@ cmake_dependent_option( KICAD_WIN32_INSTALL_PDBS
     OFF "WIN32"
     OFF )
 
-option( KICAD_STEP_EXPORT_LIB
-    "Build and use kicad2step as a library, meant for debugging"
-    OFF )
-
 option( KICAD_USE_3DCONNEXION
     "Build KiCad with support for 3Dconnexion devices (Currently only for Mac/MSW)"
     OFF )

bitmap2component/CMakeLists.txt

@@ -53,6 +53,7 @@ add_executable( bitmap2component WIN32 MACOSX_BUNDLE
 
 target_link_libraries( bitmap2component
     common
+    argparse::argparse
     ${wxWidgets_LIBRARIES}
     potrace
     )

common/CMakeLists.txt

@@ -287,6 +287,12 @@ set( COMMON_SRCS
     ${PLUGINS_CADSTAR_SRCS}
     ${PLUGINS_EAGLE_SRCS}
 	${FONT_SRCS}
+    cli/command_export_kicad_pcbnew.cpp
+    cli/command_export_pcb_svg.cpp
+    cli/command_export_pcbnew.cpp
+    cli/command_export_step.cpp
+    jobs/job_export_step.cpp
+    jobs/job_dispatcher.cpp
     advanced_config.cpp
     array_axis.cpp
     array_options.cpp
@@ -481,6 +487,7 @@ target_link_libraries( common
     compoundfilereader
     pcm_settings
     nanodbc # for now; maybe hoist out of common
+    argparse::argparse
     ${Boost_LIBRARIES}
     ${CURL_LIBRARIES}
     ${wxWidgets_LIBRARIES}
@@ -574,6 +581,7 @@ set( PCB_COMMON_SRCS
     ${CMAKE_SOURCE_DIR}/pcbnew/pcb_painter.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/plugins/kicad/pcb_parser.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/pcb_plot_params.cpp
+    ${CMAKE_SOURCE_DIR}/pcbnew/pcb_plot_svg.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/pcb_screen.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/pcb_view.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/pcbnew_settings.cpp

common/cli/command.h

@@ -0,0 +1,48 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CLI_COMMAND_H
+#define CLI_COMMAND_H
+
+#include <argparse/argparse.hpp>
+#include <kiway.h>
+
+namespace CLI
+{
+
+struct COMMAND
+{
+    COMMAND( std::string aName ) : m_name( aName ), m_argParser( aName ){};
+
+    virtual int Perform( KIWAY& aKiway ) const = 0;
+
+    virtual ~COMMAND() = default;
+
+    argparse::ArgumentParser& GetArgParser() { return m_argParser; }
+    const std::string&        GetName() const { return m_name; }
+
+protected:
+    std::string              m_name;
+    argparse::ArgumentParser m_argParser;
+};
+
+}
+
+#endif

common/cli/command_export_kicad_pcbnew.cpp

@@ -0,0 +1,31 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "command_export_kicad_pcbnew.h"
+
+CLI::EXPORT_KICAD_PCBNEW_COMMAND::EXPORT_KICAD_PCBNEW_COMMAND() : COMMAND( "export-pcb" )
+{
+}
+
+
+int CLI::EXPORT_KICAD_PCBNEW_COMMAND::Perform( KIWAY& aKiway ) const
+{
+    return 0;
+}

common/cli/command_export_kicad_pcbnew.h

@@ -0,0 +1,36 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMMAND_EXPORT_KICAD_PCBNEW_H
+#define COMMAND_EXPORT_KICAD_PCBNEW_H
+
+#include "command.h"
+
+namespace CLI
+{
+struct EXPORT_KICAD_PCBNEW_COMMAND : public COMMAND
+{
+    EXPORT_KICAD_PCBNEW_COMMAND();
+
+    int Perform( KIWAY& aKiway ) const override;
+};
+}
+
+#endif

common/cli/command_export_pcb_svg.cpp

@@ -0,0 +1,126 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 2016 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "command_export_pcb_svg.h"
+#include "exit_codes.h"
+#include "jobs/job_export_pcb_svg.h"
+#include <kiface_base.h>
+#include <layer_ids.h>
+#include <regex>
+
+#include <macros.h>
+#include <wx/tokenzr.h>
+
+#define ARG_PAGE_SIZE "--page-size-mode"
+#define ARG_MIRROR "--mirror"
+#define ARG_BLACKANDWHITE "--black-and-white"
+#define ARG_OUTPUT "--output"
+#define ARG_THEME "--theme"
+#define ARG_LAYERS "--layers"
+#define ARG_INPUT "input"
+
+
+CLI::EXPORT_PCB_SVG_COMMAND::EXPORT_PCB_SVG_COMMAND() : COMMAND( "svg" )
+{
+    m_argParser.add_argument( "-o", ARG_OUTPUT )
+            .default_value( std::string() )
+            .help( "output file name" );
+
+    m_argParser.add_argument( "-l", ARG_LAYERS )
+            .default_value( std::string() )
+            .help( "comma separated list of untranslated layer names to include such as F.Cu,B.Cu" );
+
+    m_argParser.add_argument( "-m", ARG_MIRROR )
+            .help( "Mirror the board (useful for trying to show bottom layers)" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( "-t", ARG_THEME )
+            .default_value( std::string() )
+            .help( "Color theme to use (will default to pcbnew settings)" );
+
+    m_argParser.add_argument( ARG_BLACKANDWHITE )
+            .help( "Black and white only" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_PAGE_SIZE )
+            .help( "Set page sizing mode (0 = page with frame and title block, 1 = current page size, 2 = board area only)" )
+            .default_value( 0 );
+
+    m_argParser.add_argument( ARG_INPUT ).help( "input file" );
+}
+
+
+int CLI::EXPORT_PCB_SVG_COMMAND::Perform( KIWAY& aKiway ) const
+{
+    std::map<std::string, LSET> layerMasks;
+    for( int layer = 0; layer < PCB_LAYER_ID_COUNT; ++layer )
+    {
+        std::string untranslated = TO_UTF8( wxString( LSET::Name( PCB_LAYER_ID( layer ) ) ) );
+
+        //m_layerIndices[untranslated] = PCB_LAYER_ID( layer );
+        layerMasks[untranslated] = LSET( PCB_LAYER_ID( layer ) );
+    }
+    layerMasks["*.Cu"] = LSET::AllCuMask();
+    layerMasks["*In.Cu"] = LSET::InternalCuMask();
+    layerMasks["F&B.Cu"] = LSET( 2, F_Cu, B_Cu );
+    layerMasks["*.Adhes"] = LSET( 2, B_Adhes, F_Adhes );
+    layerMasks["*.Paste"] = LSET( 2, B_Paste, F_Paste );
+    layerMasks["*.Mask"] = LSET( 2, B_Mask, F_Mask );
+    layerMasks["*.SilkS"] = LSET( 2, B_SilkS, F_SilkS );
+    layerMasks["*.Fab"] = LSET( 2, B_Fab, F_Fab );
+    layerMasks["*.CrtYd"] = LSET( 2, B_CrtYd, F_CrtYd );
+
+    JOB_EXPORT_PCB_SVG* svgJob = new JOB_EXPORT_PCB_SVG( true );
+
+    svgJob->m_mirror = m_argParser.get<bool>( ARG_MIRROR );
+    svgJob->m_blackAndWhite = m_argParser.get<bool>( ARG_BLACKANDWHITE );
+    svgJob->m_pageSizeMode = m_argParser.get<int>( ARG_PAGE_SIZE );
+
+    svgJob->m_filename = FROM_UTF8( m_argParser.get<std::string>( ARG_INPUT ).c_str() );
+    svgJob->m_outputFile = FROM_UTF8( m_argParser.get<std::string>( ARG_OUTPUT ).c_str() );
+    svgJob->m_colorTheme = FROM_UTF8( m_argParser.get<std::string>( ARG_THEME ).c_str() );
+
+    wxString layers = FROM_UTF8( m_argParser.get<std::string>( ARG_LAYERS ).c_str() );
+
+    LSET              layerMask = LSET::AllCuMask();
+
+    if( !layers.IsEmpty() )
+    {
+        layerMask.reset();
+        wxStringTokenizer layerTokens( layers, "," );
+        while( layerTokens.HasMoreTokens() )
+        {
+            std::string token = TO_UTF8(layerTokens.GetNextToken());
+            if( layerMasks.count( token ) )
+            {
+                layerMask |= layerMasks[token];
+            }
+        }
+    }
+
+    svgJob->m_printMaskLayer = layerMask;
+
+    int exitCode = aKiway.ProcessJob( KIWAY::FACE_PCB, svgJob );
+
+    return exitCode;
+}

common/cli/command_export_pcb_svg.h

@@ -0,0 +1,36 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMMAND_EXPORT_PCB_SVG_H
+#define COMMAND_EXPORT_PCB_SVG_H
+
+#include "command.h"
+
+namespace CLI
+{
+struct EXPORT_PCB_SVG_COMMAND : public COMMAND
+{
+    EXPORT_PCB_SVG_COMMAND();
+
+    int Perform( KIWAY& aKiway ) const override;
+};
+} // namespace CLI
+
+#endif

common/cli/command_export_pcbnew.cpp

@@ -0,0 +1,30 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "command_export_pcbnew.h"
+
+CLI::EXPORT_PCBNEW_COMMAND::EXPORT_PCBNEW_COMMAND() : COMMAND( "export" )
+{
+}
+
+int CLI::EXPORT_PCBNEW_COMMAND::Perform( KIWAY& aKiway ) const
+{
+    return 0;
+}

common/cli/command_export_pcbnew.h

@@ -0,0 +1,36 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMMAND_EXPORT_PCBNEW_H
+#define COMMAND_EXPORT_PCBNEW_H
+
+#include "command.h"
+
+namespace CLI
+{
+struct EXPORT_PCBNEW_COMMAND : public COMMAND
+{
+    EXPORT_PCBNEW_COMMAND();
+
+    int Perform( KIWAY& aKiway ) const override;
+};
+}
+
+#endif

common/cli/command_export_step.cpp

@@ -0,0 +1,174 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 2016 Cirilo Bernardo <cirilo.bernardo@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "command_export_step.h"
+#include "exit_codes.h"
+#include "jobs/job_export_step.h"
+#include <kiface_base.h>
+#include <regex>
+
+#include <macros.h>
+
+#define ARG_DRILL_ORIGIN "--drill-origin"
+#define ARG_GRID_ORIGIN "--grid-origin"
+#define ARG_NO_VIRTUAL "--no-virtual"
+#define ARG_SUBST_MODELS "--subst-models"
+#define ARG_FORCE "--force"
+#define ARG_OUTPUT "--output"
+#define ARG_INPUT "input"
+#define ARG_MIN_DISTANCE "--min-distance"
+#define ARG_USER_ORIGIN "--user-origin"
+#define ARG_GUI "--gui"
+
+#define REGEX_QUANTITY "([\\s]*[+-]?[\\d]*[.]?[\\d]*)"
+#define REGEX_DELIMITER "(?:[\\s]*x)"
+#define REGEX_UNIT "([m]{2}|(?:in))"
+
+CLI::EXPORT_STEP_COMMAND::EXPORT_STEP_COMMAND() : COMMAND( "step" )
+{
+    m_argParser.add_argument( ARG_DRILL_ORIGIN )
+            .help( "Use Drill Origin for output origin" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_GRID_ORIGIN )
+            .help( "Use Grid Origin for output origin" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_NO_VIRTUAL )
+            .help( "Exclude 3D models for components with 'virtual' attribute" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( "--subst-models" )
+            .help( "Substitute STEP or IGS models with the same name in place of VRML models" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_FORCE, "-f" )
+            .help( "overwrite output file" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_GUI )
+            .help( "Show GUI (log window)" )
+            .implicit_value( true )
+            .default_value( false );
+
+    m_argParser.add_argument( ARG_MIN_DISTANCE )
+            .default_value( std::string() )
+            .help( "Minimum distance between points to treat them as separate ones (default 0.01mm)" );
+
+    m_argParser.add_argument( ARG_USER_ORIGIN )
+            .default_value( std::string() )
+            .help( "User-specified output origin ex. 1x1in, 1x1inch, 25.4x25.4mm (default mm)" );
+
+    m_argParser.add_argument( "-o", ARG_OUTPUT )
+            .default_value( std::string() )
+            .help( "output file name" );
+
+    m_argParser.add_argument( ARG_INPUT ).help( "input file" );
+}
+
+int CLI::EXPORT_STEP_COMMAND::Perform( KIWAY& aKiway ) const
+{
+    JOB_EXPORT_STEP* step = new JOB_EXPORT_STEP( true );
+
+    step->m_useDrillOrigin = m_argParser.get<bool>( ARG_DRILL_ORIGIN );
+    step->m_useGridOrigin = m_argParser.get<bool>( ARG_GRID_ORIGIN );
+    step->m_includeVirtual = !m_argParser.get<bool>( ARG_NO_VIRTUAL );
+    step->m_substModels = m_argParser.get<bool>( ARG_SUBST_MODELS );
+    step->m_overwrite = m_argParser.get<bool>( ARG_FORCE );
+    step->m_filename = FROM_UTF8( m_argParser.get<std::string>( ARG_INPUT ).c_str() );
+    step->m_outputFile = FROM_UTF8( m_argParser.get<std::string>( ARG_OUTPUT ).c_str() );
+    step->m_gui = m_argParser.get<bool>( ARG_GUI );
+
+    wxString userOrigin = FROM_UTF8( m_argParser.get<std::string>( ARG_USER_ORIGIN ).c_str() );
+    if( !userOrigin.IsEmpty() )
+    {
+        std::regex  re_pattern( REGEX_QUANTITY REGEX_DELIMITER REGEX_QUANTITY REGEX_UNIT,
+                                std::regex_constants::icase );
+        std::smatch sm;
+        std::string str( userOrigin.ToUTF8() );
+        std::regex_search( str, sm, re_pattern );
+        step->m_xOrigin = atof( sm.str( 1 ).c_str() );
+        step->m_yOrigin = atof( sm.str( 2 ).c_str() );
+
+        std::string tunit( sm[3] );
+
+        if( tunit.size() > 0 ) // No unit accepted ( default = mm )
+        {
+            if( ( !sm.str( 1 ).compare( " " ) || !sm.str( 2 ).compare( " " ) )
+                || ( sm.size() != 4 ) )
+            {
+                std::cout << m_argParser;
+                return CLI::EXIT_CODES::ERR_ARGS;
+            }
+
+            // only in, inch and mm are valid:
+            if( !tunit.compare( "in" ) || !tunit.compare( "inch" ) )
+            {
+                step->m_xOrigin *= 25.4;
+                step->m_yOrigin *= 25.4;
+            }
+            else if( tunit.compare( "mm" ) )
+            {
+                std::cout << m_argParser;
+                return CLI::EXIT_CODES::ERR_ARGS;
+            }
+        }
+    }
+
+    wxString minDistance = FROM_UTF8( m_argParser.get<std::string>( ARG_MIN_DISTANCE ).c_str() );
+    if( !minDistance.IsEmpty() )
+    {
+        std::istringstream istr;
+        istr.str( std::string( minDistance.ToUTF8() ) );
+        istr >> step->m_minDistance;
+
+        if( istr.fail() )
+        {
+            std::cout << m_argParser;
+            return CLI::EXIT_CODES::ERR_ARGS;
+        }
+
+        if( !istr.eof() )
+        {
+            std::string tunit;
+            istr >> tunit;
+
+            if( !tunit.compare( "in" ) || !tunit.compare( "inch" ) )
+            {
+                step->m_minDistance *= 25.4;
+            }
+            else if( tunit.compare( "mm" ) )
+            {
+                std::cout << m_argParser;
+                return CLI::EXIT_CODES::ERR_ARGS;
+            }
+        }
+    }
+
+    int exitCode = aKiway.ProcessJob( KIWAY::FACE_PCB, step );
+
+    return exitCode;
+}

common/cli/command_export_step.h

@@ -0,0 +1,36 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMMAND_EXPORT_STEP_H
+#define COMMAND_EXPORT_STEP_H
+
+#include "command.h"
+
+namespace CLI
+{
+struct EXPORT_STEP_COMMAND : public COMMAND
+{
+    EXPORT_STEP_COMMAND();
+
+    int Perform( KIWAY& aKiway ) const override;
+};
+}
+
+#endif

common/cli/exit_codes.h

@@ -0,0 +1,38 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CLI_EXIT_CODES_H
+#define CLI_EXIT_CODES_H
+
+namespace CLI
+{
+    namespace EXIT_CODES
+    {
+        static const int  AVOID_CLOSING = -1;
+        static const int SUCCESS = 0;
+        static const int  OK = 0;
+        static const int ERR_ARGS = 1;
+        static const int ERR_UNKNOWN = 2;
+        static const int  ERR_INVALID_INPUT_FILE = 3;
+        static const int  ERR_INVALID_OUTPUT_CONFLICT = 4;
+    };
+}
+
+#endif

common/jobs/job.h

@@ -0,0 +1,42 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef JOB_H
+#define JOB_H
+
+/**
+ * An simple container class that lets us dispatch output jobs to kifaces
+ */
+class JOB
+{
+public:
+    JOB( const std::string& aType, bool aIsCli ) : m_type( aType ), m_isCli( aIsCli ) {}
+
+    virtual ~JOB() {}
+
+    const std::string& GetType() const { return m_type; };
+    bool IsCli() const { return m_isCli; };
+
+private:
+    std::string m_type;
+    bool m_isCli;
+};
+
+#endif

common/jobs/job_dispatcher.cpp

@@ -0,0 +1,38 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cli/exit_codes.h>
+#include <jobs/job_dispatcher.h>
+
+void JOB_DISPATCHER::Register( const std::string&             aJobTypeName,
+                               std::function<int( JOB* job )> aHandler )
+{
+    m_jobHandlers.emplace( aJobTypeName, aHandler );
+}
+
+int JOB_DISPATCHER::RunJob( JOB* job )
+{
+    if( m_jobHandlers.count( job->GetType() ) )
+    {
+        return m_jobHandlers[job->GetType()]( job );
+    }
+
+    return CLI::EXIT_CODES::ERR_UNKNOWN;
+}

common/jobs/job_dispatcher.h

@@ -0,0 +1,39 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef JOB_DISPATCHER_H
+#define JOB_DISPATCHER_H
+
+#include <functional>
+#include <string>
+#include <map>
+#include <jobs/job.h>
+
+class JOB_DISPATCHER
+{
+public:
+    void Register( const std::string& aJobTypeName, std::function<int( JOB* job )> aHandler );
+    int RunJob( JOB* job );
+
+private:
+    std::map<std::string, std::function<int( JOB* job )>> m_jobHandlers;
+};
+
+#endif

common/jobs/job_export_pcb_svg.h

@@ -0,0 +1,49 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef JOB_EXPORT_PCB_SVG_H
+#define JOB_EXPORT_PCB_SVG_H
+
+#include <layer_ids.h>
+#include <wx/string.h>
+#include "job.h"
+
+class JOB_EXPORT_PCB_SVG : public JOB
+{
+public:
+    JOB_EXPORT_PCB_SVG( bool aIsCli ) :
+            JOB( "svg", aIsCli ), m_filename(), m_outputFile(), m_colorTheme(), m_mirror( false ),
+            m_blackAndWhite( false ), m_pageSizeMode( 0 ), m_printMaskLayer()
+    {
+    }
+
+    wxString m_filename;
+    wxString m_outputFile;
+    wxString m_colorTheme;
+
+    bool m_mirror;
+    bool m_blackAndWhite;
+
+    int m_pageSizeMode;
+
+    LSET m_printMaskLayer;
+};
+
+#endif

common/jobs/job_export_step.cpp

@@ -0,0 +1,34 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "jobs/job_export_step.h"
+
+JOB_EXPORT_STEP::JOB_EXPORT_STEP( bool aIsCli ) : JOB( "step", aIsCli )
+{
+    m_overwrite = false;
+    m_useGridOrigin = false;
+    m_useDrillOrigin = false;
+    m_includeVirtual = true;
+    m_substModels = false;
+    m_xOrigin = 0.0;
+    m_yOrigin = 0.0;
+    m_minDistance = 0.0;
+    m_gui = false;
+}

common/jobs/job_export_step.h

@@ -0,0 +1,45 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2022 Mark Roszko <mark.roszko@gmail.com>
+ * Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef JOB_EXPORT_STEP_H
+#define JOB_EXPORT_STEP_H
+
+#include <wx/string.h>
+#include "job.h"
+
+class JOB_EXPORT_STEP : public JOB
+{
+public:
+    JOB_EXPORT_STEP( bool aIsCli );
+
+    bool     m_overwrite;
+    bool     m_useGridOrigin;
+    bool     m_useDrillOrigin;
+    bool     m_includeVirtual;
+    bool     m_substModels;
+    wxString m_filename;
+    wxString m_outputFile;
+    double   m_xOrigin;
+    double   m_yOrigin;
+    double   m_minDistance;
+    bool     m_gui;
+};
+
+#endif

common/kiway.cpp

@@ -654,6 +654,14 @@ bool KIWAY::ProcessEvent( wxEvent& aEvent )
 }
 
 
+int KIWAY::ProcessJob( KIWAY::FACE_T aFace, JOB* job )
+{
+    KIFACE* kiface = KiFACE( aFace );
+
+    return kiface->HandleJob( job );
+}
+
+
 void KIWAY::OnKiCadExit()
 {
     if( m_ctl & KFCTL_CPP_PROJECT_SUITE )

common/pgm_base.cpp

@@ -124,6 +124,8 @@ PGM_BASE::PGM_BASE()
     m_Printing = false;
     m_Quitting = false;
     m_ModalDialogCount = 0;
+    m_argcUtf8 = 0;
+    m_argvUtf8 = nullptr;
 
     setLanguageId( wxLANGUAGE_DEFAULT );
 
@@ -134,6 +136,13 @@ PGM_BASE::PGM_BASE()
 PGM_BASE::~PGM_BASE()
 {
     Destroy();
+
+    for( size_t n = 0; n < m_argcUtf8; n++ )
+    {
+        delete m_argvUtf8[n];
+    }
+
+    delete m_argvUtf8;
 }
 
 
@@ -370,6 +379,21 @@ void PGM_BASE::sentryPrompt()
 #endif
 
 
+void PGM_BASE::BuildArgvUtf8()
+{
+    const wxArrayString& argArray = App().argv.GetArguments();
+    m_argcUtf8 = argArray.size();
+
+    m_argvUtf8 = new char*[m_argcUtf8 + 1];
+    for( size_t n = 0; n < m_argcUtf8; n++ )
+    {
+        m_argvUtf8[n] = wxStrdup( argArray[n].ToUTF8() );
+    }
+
+    m_argvUtf8[m_argcUtf8] = NULL;  // null terminator at end of argv
+}
+
+
 bool PGM_BASE::InitPgm( bool aHeadless, bool aSkipPyInit )
 {
     // Just make sure we init precreate any folders early for later code

common/single_top.cpp

@@ -40,6 +40,7 @@
 #include <wx/stdpaths.h>
 #include <wx/snglinst.h>
 #include <wx/html/htmlwin.h>
+#include <argparse/argparse.hpp>
 
 #include <kiway.h>
 #include <pgm_base.h>
@@ -48,9 +49,14 @@
 #include <confirm.h>
 #include <settings/settings_manager.h>
 
+#include <kicad_build_version.h>
 #include <kiplatform/app.h>
 #include <kiplatform/environment.h>
 
+#include "cli/command_export_pcbnew.h"
+#include "cli/command_export_pcb_svg.h"
+#include "cli/command_export_step.h"
+#include "cli/exit_codes.h"
 
 // Only a single KIWAY is supported in this single_top top level component,
 // which is dedicated to loading only a single DSO.
@@ -274,8 +280,36 @@ struct APP_SINGLE_TOP : public wxApp
 IMPLEMENT_APP( APP_SINGLE_TOP )
 
 
+
+struct COMMAND_ENTRY
+{
+    CLI::COMMAND* handler;
+
+    std::vector<COMMAND_ENTRY> subCommands;
+
+    COMMAND_ENTRY( CLI::COMMAND* aHandler ) : handler( aHandler ){};
+    COMMAND_ENTRY( CLI::COMMAND* aHandler, std::vector<COMMAND_ENTRY> aSub ) :
+            handler( aHandler ), subCommands( aSub ) {};
+};
+
+#ifdef PCBNEW
+static CLI::EXPORT_STEP_COMMAND   stepCmd{};
+static CLI::EXPORT_PCB_SVG_COMMAND   svgCmd{};
+static CLI::EXPORT_PCBNEW_COMMAND exportCmd{};
+
+static std::vector<COMMAND_ENTRY> commandStack = {
+    { &exportCmd, { &stepCmd, &svgCmd } }
+};
+#else
+
+static std::vector<COMMAND_ENTRY> commandStack = {
+};
+#endif
+
 bool PGM_SINGLE_TOP::OnPgmInit()
 {
+    PGM_BASE::BuildArgvUtf8();
+
 #if defined(DEBUG)
     wxString absoluteArgv0 = wxStandardPaths::Get().GetExecutablePath();
 
@@ -285,10 +319,62 @@ bool PGM_SINGLE_TOP::OnPgmInit()
         return false;
     }
 #endif
+    wxString pgm_name;
+    if( App().argc == 0 )
+        pgm_name = wxT( "kicad" );
+    else
+        pgm_name = wxFileName( App().argv[0] ).GetName().Lower();
+
+    argparse::ArgumentParser argParser( std::string( pgm_name.utf8_str() ), KICAD_MAJOR_MINOR_VERSION );
+
+    for(COMMAND_ENTRY& entry : commandStack)
+    {
+        argParser.add_subparser( entry.handler->GetArgParser() );
+
+        for( COMMAND_ENTRY& subentry : entry.subCommands )
+        {
+            entry.handler->GetArgParser().add_subparser( subentry.handler->GetArgParser() );
+        }
+    }
+
+    try
+    {
+        argParser.parse_args( m_argcUtf8, m_argvUtf8 );
+    }
+    catch( const std::runtime_error& err )
+    {
+        // this provides the nice pretty print
+        std::cerr << err.what() << std::endl;
+        std::cerr << argParser;
+
+        std::exit( CLI::EXIT_CODES::ERR_ARGS );
+    }
+
+    bool cliCmdRequested = false;
+    CLI::COMMAND* cliCmd = nullptr;
+    for( COMMAND_ENTRY& entry : commandStack )
+    {
+        if( argParser.is_subcommand_used( entry.handler->GetName() ) )
+        {
+            for( COMMAND_ENTRY& subentry : entry.subCommands )
+            {
+                if( entry.handler->GetArgParser().is_subcommand_used( subentry.handler->GetName() ) )
+                {
+                    cliCmd = subentry.handler;
+                    cliCmdRequested = true;
+                }
+            }
+
+            if( !cliCmdRequested )
+            {
+                cliCmd = entry.handler;
+            }
+        }
+    }
 
     // Not all kicad applications use the python stuff. skip python init
     // for these apps.
-    bool skip_python_initialization = false;
+    bool skip_python_initialization = cliCmdRequested;
 #if defined( BITMAP_2_CMP ) || defined( PL_EDITOR ) || defined( GERBVIEW ) ||\
         defined( PCB_CALCULATOR_BUILD )
     skip_python_initialization = true;
@@ -320,53 +406,29 @@ bool PGM_SINGLE_TOP::OnPgmInit()
     Kiway.set_kiface( KIWAY::KifaceType( TOP_FRAME ), kiface );
 #endif
 
-    static const wxCmdLineEntryDesc desc[] = {
-        { wxCMD_LINE_OPTION, "f", "frame", "Frame to load", wxCMD_LINE_VAL_STRING, 0 },
-        { wxCMD_LINE_PARAM, nullptr, nullptr, "File to load", wxCMD_LINE_VAL_STRING,
-                wxCMD_LINE_PARAM_MULTIPLE | wxCMD_LINE_PARAM_OPTIONAL },
-        { wxCMD_LINE_NONE, nullptr, nullptr, nullptr, wxCMD_LINE_VAL_NONE, 0 }
-    };
-
-    wxCmdLineParser parser( App().argc, App().argv );
-    parser.SetDesc( desc );
-    parser.Parse( false );
-
     FRAME_T appType = TOP_FRAME;
 
-    const struct
-    {
-        wxString name;
-        FRAME_T type;
-    } frameTypes[] = {
-        { wxT( "pcb" ),    FRAME_PCB_EDITOR },
-        { wxT( "fpedit" ), FRAME_FOOTPRINT_EDITOR },
-        { wxT( "" ),       FRAME_T_COUNT }
-    };
-
-    wxString frameName;
-
-    if( parser.Found( "frame", &frameName ) )
-    {
-        appType = FRAME_T_COUNT;
-
-        for( const auto& it : frameTypes )
-        {
-            if( it.name == frameName )
-                appType = it.type;
-        }
-
-        if( appType == FRAME_T_COUNT )
-        {
-            wxLogError( wxT( "Unknown frame: %s" ), frameName );
-            // Clean up
-            OnPgmExit();
-            return false;
-        }
-    }
-
     // Tell the settings manager about the current Kiway
     GetSettingsManager().SetKiway( &Kiway );
 
+    if( cliCmdRequested )
+    {
+        int exitCode = CLI::EXIT_CODES::ERR_UNKNOWN;
+        if( cliCmd )
+        {
+            exitCode = cliCmd->Perform( Kiway );
+        }
+
+        if( exitCode != CLI::EXIT_CODES::AVOID_CLOSING )
+        {
+            std::exit( exitCode );
+        }
+        else
+        {
+            return true;
+        }
+    }
+
     // Use KIWAY to create a top window, which registers its existence also.
     // "TOP_FRAME" is a macro that is passed on compiler command line from CMake,
     // and is one of the types in FRAME_T.
@@ -390,14 +452,10 @@ bool PGM_SINGLE_TOP::OnPgmInit()
     frame->Show();
     wxSafeYield();
 
-    // Individual frames may provide additional option/switch processing, but for compatibility,
-    // any positional arguments are treated as a list of files to pass to OpenProjectFiles
-    frame->ParseArgs( parser );
-
     // Now after the frame processing, the rest of the positional args are files
     std::vector<wxString> fileArgs;
 
-    if( parser.GetParamCount() )
+    if( App().argc > 1 )
     {
         /*
             gerbview handles multiple project data files, i.e. gerber files on
@@ -408,15 +466,15 @@ bool PGM_SINGLE_TOP::OnPgmInit()
             launcher.
         */
 
-        for( size_t i = 0; i < parser.GetParamCount(); i++ )
-            fileArgs.push_back( parser.GetParam( i ) );
+        for( size_t i = 1; i < App().argc; i++ )
+            fileArgs.push_back( App().argv[i] );
 
         // special attention to a single argument: argv[1] (==argSet[0])
         if( fileArgs.size() == 1 )
         {
             wxFileName argv1( fileArgs[0] );
 
-#if defined(PGM_DATA_FILE_EXT)
+#if defined( PGM_DATA_FILE_EXT )
             // PGM_DATA_FILE_EXT, if present, may be different for each compile,
             // it may come from CMake on the compiler command line, but often does not.
             // This facility is mostly useful for those program footprints

eeschema/CMakeLists.txt

@@ -278,7 +278,7 @@ set( EESCHEMA_SRCS
 
     ${CMAKE_SOURCE_DIR}/pcbnew/ibis/ibis_parser.cpp
     ${CMAKE_SOURCE_DIR}/pcbnew/ibis/kibis.cpp
-    
+
     # Some simulation features must be built even if libngspice is not linked.
     sim/sim_library.cpp
     sim/sim_library_spice.cpp
@@ -427,6 +427,7 @@ target_link_libraries( eeschema
     # There's way too much crap coming in from common yet.
     gal
     common
+    argparse::argparse
     ${wxWidgets_LIBRARIES}
     )
 

eeschema/eeschema.cpp

@@ -298,6 +298,9 @@ static struct IFACE : public KIFACE_BASE
                      const wxString& aNewProjectBasePath, const wxString& aNewProjectName,
                      const wxString& aSrcFilePath, wxString& aErrors ) override;
 
+
+    int HandleJob( JOB* aJob ) override;
+
 } kiface( "eeschema", KIWAY::FACE_SCH );
 
 } // namespace
@@ -560,3 +563,7 @@ void IFACE::SaveFileAs( const wxString& aProjectBasePath, const wxString& aProje
     }
 }
 
+int IFACE::HandleJob( JOB* aJob )
+{
+    return 0;
+}

gerbview/CMakeLists.txt

@@ -112,6 +112,7 @@ target_link_libraries( gerbview
     gal
     common
     nlohmann_json
+    argparse::argparse
     ${wxWidgets_LIBRARIES}
     )