board_project_settings.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020 Jon Evans <[email protected]>
 * Copyright (C) 2020-2023 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 KICAD_BOARD_PROJECT_SETTINGS_H
#define KICAD_BOARD_PROJECT_SETTINGS_H
 
#include <layer_ids.h>
#include <lset.h>
#include <settings/parameters.h>
 
// Can be removed by refactoring PARAM_LAYER_PRESET
#include <nlohmann/json.hpp>
#include <math/box2.h>
#include <glm/glm.hpp>
 
struct KICOMMON_API PCB_SELECTION_FILTER_OPTIONS
{
 bool lockedItems; 
 bool footprints; 
 bool text; 
 bool tracks; 
 bool vias; 
 bool pads; 
 bool graphics; 
 bool zones; 
 bool keepouts; 
 bool dimensions; 
 bool otherItems; 
 
 PCB_SELECTION_FILTER_OPTIONS()
 {
 lockedItems = true;
 footprints = true;
 text = true;
 tracks = true;
 vias = true;
 pads = true;
 graphics = true;
 zones = true;
 keepouts = true;
 dimensions = true;
 otherItems = true;
 }
 
 bool Any()
 {
 return ( footprints || text || tracks || vias || pads || graphics || zones
 || keepouts || dimensions || otherItems );
 }
 
 bool All()
 {
 return ( footprints && text && tracks && vias && pads && graphics && zones
 && keepouts && dimensions && otherItems );
 }
};
 
enum class HIGH_CONTRAST_MODE
{
 NORMAL = 0, 
 DIMMED, 
 HIDDEN 
};
 
enum class ZONE_DISPLAY_MODE
{
 SHOW_FILLED,
 SHOW_ZONE_OUTLINE,
 
 // Debug modes
 
 SHOW_FRACTURE_BORDERS,
 SHOW_TRIANGULATION
};
 
enum class NET_COLOR_MODE
{
 OFF, 
 RATSNEST, 
 ALL 
};
 
enum class RATSNEST_MODE
{
 ALL, 
 VISIBLE 
};
 
struct KICOMMON_API IP2581_BOM
{
 wxString mfg; 
 wxString MPN; 
 wxString dist; 
 wxString distPN; 
 wxString id; 
};
 
struct KICOMMON_API LAYER_PRESET
{
 LAYER_PRESET( const wxString& aName = wxS( "" ) ) :
 name( aName ),
 layers( LSET::AllLayersMask() ),
 renderLayers( GAL_SET::DefaultVisible() ),
 flipBoard( false ),
 activeLayer( UNSELECTED_LAYER )
 {
 readOnly = false;
 }
 
 LAYER_PRESET( const wxString& aName, const LSET& aVisibleLayers, bool aFlipBoard ) :
 name( aName ),
 layers( aVisibleLayers ),
 renderLayers( GAL_SET::DefaultVisible() ),
 flipBoard( aFlipBoard ),
 activeLayer( UNSELECTED_LAYER )
 {
 readOnly = false;
 }
 
 LAYER_PRESET( const wxString& aName, const LSET& aVisibleLayers, const GAL_SET& aVisibleObjects,
 PCB_LAYER_ID aActiveLayer, bool aFlipBoard ) :
 name( aName ),
 layers( aVisibleLayers ),
 renderLayers( aVisibleObjects ),
 flipBoard( aFlipBoard ),
 activeLayer( aActiveLayer )
 {
 readOnly = false;
 }
 
 bool LayersMatch( const LAYER_PRESET& aOther )
 {
 return aOther.layers == layers && aOther.renderLayers == renderLayers;
 }
 
 wxString name; 
 LSET layers; 
 GAL_SET renderLayers; 
 bool flipBoard; 
 PCB_LAYER_ID activeLayer; 
 bool readOnly; 
};
 
 
class KICOMMON_API PARAM_LAYER_PRESET : public PARAM_LAMBDA<nlohmann::json>
{
public:
 PARAM_LAYER_PRESET( const std::string& aPath, std::vector<LAYER_PRESET>* aPresetList );
 
private:
 nlohmann::json presetsToJson();
 
 void jsonToPresets( const nlohmann::json& aJson );
 
 std::vector<LAYER_PRESET>* m_presets;
};
 
 
struct KICOMMON_API VIEWPORT
{
 VIEWPORT( const wxString& aName = wxEmptyString ) :
 name( aName )
 { }
 
 VIEWPORT( const wxString& aName, const BOX2D& aRect ) :
 name( aName ),
 rect( aRect )
 { }
 
 wxString name;
 BOX2D rect;
};
 
 
class KICOMMON_API PARAM_VIEWPORT : public PARAM_LAMBDA<nlohmann::json>
{
public:
 PARAM_VIEWPORT( const std::string& aPath, std::vector<VIEWPORT>* aViewportList );
 
private:
 nlohmann::json viewportsToJson();
 
 void jsonToViewports( const nlohmann::json& aJson );
 
 std::vector<VIEWPORT>* m_viewports;
};
 
 
struct KICOMMON_API VIEWPORT3D
{
 VIEWPORT3D( const wxString& aName = wxEmptyString ) :
 name( aName )
 { }
 
 VIEWPORT3D( const wxString& aName, glm::mat4 aViewMatrix ) :
 name( aName ),
 matrix( std::move( aViewMatrix ) )
 { }
 
 wxString name;
 glm::mat4 matrix;
};
 
 
class KICOMMON_API PARAM_VIEWPORT3D : public PARAM_LAMBDA<nlohmann::json>
{
public:
 PARAM_VIEWPORT3D( const std::string& aPath, std::vector<VIEWPORT3D>* aViewportList );
 
private:
 nlohmann::json viewportsToJson();
 
 void jsonToViewports( const nlohmann::json & aJson );
 
 std::vector<VIEWPORT3D>* m_viewports;
};
 
 
class KICOMMON_API LAYER_PAIR
{
public:
 LAYER_PAIR() :
 m_layerA( UNDEFINED_LAYER ), m_layerB( UNDEFINED_LAYER )
 {
 }
 
 LAYER_PAIR( PCB_LAYER_ID a, PCB_LAYER_ID b ) :
 m_layerA( a ), m_layerB( b )
 {
 }
 
 PCB_LAYER_ID GetLayerA() const { return m_layerA; }
 PCB_LAYER_ID GetLayerB() const { return m_layerB; }
 
 void SetLayerA( PCB_LAYER_ID aLayer ) { m_layerA = aLayer; }
 void SetLayerB( PCB_LAYER_ID aLayer ) { m_layerB = aLayer; }
 
 bool HasSameLayers( const LAYER_PAIR& aOther ) const
 {
 return ( m_layerA == aOther.m_layerA && m_layerB == aOther.m_layerB )
 || ( m_layerA == aOther.m_layerB && m_layerB == aOther.m_layerA );
 }
 
private:
 PCB_LAYER_ID m_layerA;
 PCB_LAYER_ID m_layerB;
};
 
 
class KICOMMON_API LAYER_PAIR_INFO
{
public:
 LAYER_PAIR_INFO( LAYER_PAIR aPair, bool aEnabled, std::optional<wxString> aName ) :
 m_pair( std::move( aPair ) ), m_enabled( aEnabled), m_name( std::move( aName ) )
 {
 }
 
 const LAYER_PAIR& GetLayerPair() const { return m_pair; }
 
 const std::optional<wxString>& GetName() const { return m_name; }
 
 void SetName( const wxString& aNewName ) { m_name = aNewName; }
 void UnsetName() { m_name = std::nullopt; }
 
 bool IsEnabled() const { return m_enabled; }
 void SetEnabled( bool aNewEnabled ) { m_enabled = aNewEnabled; }
 
private:
 LAYER_PAIR m_pair;
 bool m_enabled = true;
 std::optional<wxString> m_name;
};
 
 
class KICOMMON_API PARAM_LAYER_PAIRS : public PARAM_LAMBDA<nlohmann::json>
{
public:
 PARAM_LAYER_PAIRS( const std::string& aPath, std::vector<LAYER_PAIR_INFO>& m_layerPairInfos );
 
private:
 nlohmann::json layerPairsToJson();
 
 void jsonToLayerPairs( const nlohmann::json& aJson );
 
 std::vector<LAYER_PAIR_INFO>& m_layerPairInfos;
};
 
 
struct KICOMMON_API PANEL_NET_INSPECTOR_SETTINGS
{
 wxString filter_text;
 bool filter_by_net_name;
 bool filter_by_netclass;
 bool group_by_netclass;
 bool group_by_constraint;
 std::vector<wxString> custom_group_rules;
 bool show_zero_pad_nets;
 bool show_unconnected_nets;
 int sorting_column;
 bool sort_order_asc;
 std::vector<int> col_order;
 std::vector<int> col_widths;
 std::vector<bool> col_hidden;
 
 std::vector<wxString> expanded_rows;
 
 PANEL_NET_INSPECTOR_SETTINGS()
 {
 filter_text = "";
 filter_by_net_name = true;
 filter_by_netclass = true;
 group_by_netclass = false;
 group_by_constraint = false;
 show_zero_pad_nets = false;
 show_unconnected_nets = false;
 sorting_column = -1;
 sort_order_asc = true;
 }
};
 
 
#endif // KICAD_BOARD_PROJECT_SETTINGS_H