diff options
Diffstat (limited to 'include/class_board_design_settings.h')
| -rw-r--r-- | include/class_board_design_settings.h | 568 |
1 files changed, 568 insertions, 0 deletions
diff --git a/include/class_board_design_settings.h b/include/class_board_design_settings.h new file mode 100644 index 0000000..a7b200e --- /dev/null +++ b/include/class_board_design_settings.h @@ -0,0 +1,568 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2009-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr + * Copyright (C) 1992-2015 KiCad Developers, see CHANGELOG.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 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 + */ + +#ifndef BOARD_DESIGN_SETTINGS_H_ +#define BOARD_DESIGN_SETTINGS_H_ + +#include <pcbstruct.h> // NB_COLORS +#include <class_pad.h> +#include <class_track.h> +#include <class_netclass.h> +#include <config_params.h> + +// Some default values for the board editor and the fp editor (given in mm) +#define DEFAULT_TEXT_MODULE_SIZE 1.0 +#define DEFAULT_GR_MODULE_THICKNESS 0.15 // given in mm + +// Board thickness, mainly for 3D view: +#define DEFAULT_BOARD_THICKNESS_MM 1.6 + +// Default values for some board items (given in mm) +#define DEFAULT_TEXT_PCB_SIZE 1.5 +#define DEFAULT_TEXT_PCB_THICKNESS 0.3 +#define DEFAULT_PCB_EDGE_THICKNESS 0.15 +#define DEFAULT_GRAPHIC_THICKNESS 0.2 + +#define DEFAULT_SOLDERMASK_CLEARANCE 0.2 +#define DEFAULT_SOLDERMASK_MIN_WIDTH Millimeter2iu( 0.0 ) + +#define DEFAULT_CUSTOMTRACKWIDTH 0.2 +#define DEFAULT_TRACKMINWIDTH 0.2 // track width min value +#define DEFAULT_VIASMINSIZE 0.4 // vias (not micro vias) min diameter +#define DEFAULT_VIASMINDRILL 0.3 // vias (not micro vias) min drill diameter +#define DEFAULT_MICROVIASMINSIZE 0.2 // micro vias (not vias) min diameter +#define DEFAULT_MICROVIASMINDRILL 0.1 // micro vias (not vias) min drill diameter + +/** + * Struct VIA_DIMENSION + * is a small helper container to handle a stock of specific vias each with + * unique diameter and drill sizes in the BOARD class. + */ +struct VIA_DIMENSION +{ + int m_Diameter; // <= 0 means use Netclass via diameter + int m_Drill; // <= 0 means use Netclass via drill + + VIA_DIMENSION() + { + m_Diameter = 0; + m_Drill = 0; + } + + VIA_DIMENSION( int aDiameter, int aDrill ) + { + m_Diameter = aDiameter; + m_Drill = aDrill; + } + + bool operator==( const VIA_DIMENSION& aOther ) const + { + return ( m_Diameter == aOther.m_Diameter ) && ( m_Drill == aOther.m_Drill ); + } + + bool operator<( const VIA_DIMENSION& aOther ) const + { + if( m_Diameter != aOther.m_Diameter ) + return m_Diameter < aOther.m_Diameter; + + return m_Drill < aOther.m_Drill; + } +}; + + +/** + * Class BOARD_DESIGN_SETTINGS + * contains design settings for a BOARD object. + */ +class BOARD_DESIGN_SETTINGS +{ +public: + // The first value is the current netclass via size + /// Vias size and drill list + std::vector<VIA_DIMENSION> m_ViasDimensionsList; + + // The first value is the current netclass track width + /// Track width list + std::vector<int> m_TrackWidthList; + + /// List of current netclasses. There is always the default netclass. + NETCLASSES m_NetClasses; + + bool m_MicroViasAllowed; ///< true to allow micro vias + bool m_BlindBuriedViaAllowed; ///< true to allow blind/buried vias + VIATYPE_T m_CurrentViaType; ///< via type (VIA_BLIND_BURIED, VIA_THROUGH VIA_MICROVIA) + + /// if true, when creating a new track starting on an existing track, use this track width + bool m_UseConnectedTrackWidth; + int m_DrawSegmentWidth; ///< current graphic line width (not EDGE layer) + int m_EdgeSegmentWidth; ///< current graphic line width (EDGE layer only) + int m_PcbTextWidth; ///< current Pcb (not module) Text width + wxSize m_PcbTextSize; ///< current Pcb (not module) Text size + int m_TrackMinWidth; ///< track min value for width ((min copper size value + int m_ViasMinSize; ///< vias (not micro vias) min diameter + int m_ViasMinDrill; ///< vias (not micro vias) min drill diameter + int m_MicroViasMinSize; ///< micro vias (not vias) min diameter + int m_MicroViasMinDrill; ///< micro vias (not vias) min drill diameter + + // Global mask margins: + int m_SolderMaskMargin; ///< Solder mask margin + int m_SolderMaskMinWidth; ///< Solder mask min width + // 2 areas near than m_SolderMaskMinWidth + // are merged + int m_SolderPasteMargin; ///< Solder paste margin absolute value + double m_SolderPasteMarginRatio; ///< Solder pask margin ratio value of pad size + ///< The final margin is the sum of these 2 values + + // Variables used in footprint edition (default value in item/footprint creation) + int m_ModuleSegmentWidth; ///< Default width for all graphic lines + // Note: the default layer is the active layer + wxSize m_ModuleTextSize; ///< Default footprint texts size + int m_ModuleTextWidth; ///< Default footprint texts thickness + + wxString m_RefDefaultText; ///< Default ref text on fp creation + // if empty, use footprint name as default + bool m_RefDefaultVisibility; ///< Default ref text visibility on fp creation + int m_RefDefaultlayer; ///< Default ref text layer on fp creation + // should be a LAYER_ID, but use an int + // to save this param in config + + wxString m_ValueDefaultText; ///< Default value text on fp creation + // if empty, use footprint name as default + bool m_ValueDefaultVisibility; ///< Default value text visibility on fp creation + int m_ValueDefaultlayer; ///< Default value text layer on fp creation + // should be a LAYER_ID, but use an int + // to save this param in config + + // Miscellaneous + wxPoint m_AuxOrigin; ///< origin for plot exports + wxPoint m_GridOrigin; ///< origin for grid offsets + + D_PAD m_Pad_Master; ///< A dummy pad to store all default parameters + // when importing values or create a new pad + +private: + /// Index for #m_ViasDimensionsList to select the current via size. + /// 0 is the index selection of the default value Netclass + unsigned m_viaSizeIndex; + + // Index for m_TrackWidthList to select the value. + /// 0 is the index selection of the default value Netclass + unsigned m_trackWidthIndex; + + ///> Use custom values for track/via sizes (not specified in net class nor in the size lists). + bool m_useCustomTrackVia; + + ///> Custom track width (used after UseCustomTrackViaSize( true ) was called). + int m_customTrackWidth; + + ///> Custom via size (used after UseCustomTrackViaSize( true ) was called). + VIA_DIMENSION m_customViaSize; + + int m_copperLayerCount; ///< Number of copper layers for this design + + LSET m_enabledLayers; ///< Bit-mask for layer enabling + LSET m_visibleLayers; ///< Bit-mask for layer visibility + + int m_visibleElements; ///< Bit-mask for element category visibility + int m_boardThickness; ///< Board thickness for 3D viewer + + /// Current net class name used to display netclass info. + /// This is also the last used netclass after starting a track. + wxString m_currentNetClassName; + +public: + BOARD_DESIGN_SETTINGS(); + + /** + * Function GetDefault + * @return the default netclass. + */ + inline NETCLASSPTR GetDefault() const + { + return m_NetClasses.GetDefault(); + } + + /** + * Function GetCurrentNetClassName + * @return the current net class name. + */ + inline const wxString& GetCurrentNetClassName() const + { + return m_currentNetClassName; + } + + /** + * Function UseNetClassTrack + * returns true if netclass values should be used to obtain appropriate track width. + */ + inline bool UseNetClassTrack() const + { + return ( m_trackWidthIndex == 0 && !m_useCustomTrackVia ); + } + + /** + * Function UseNetClassVia + * returns true if netclass values should be used to obtain appropriate via size. + */ + inline bool UseNetClassVia() const + { + return ( m_viaSizeIndex == 0 && !m_useCustomTrackVia ); + } + + /** + * Function SetCurrentNetClass + * Must be called after a netclass selection (or after a netclass parameter change + * Initialize vias and tracks values displayed in comb boxes of the auxiliary toolbar + * and some others parameters (netclass name ....) + * @param aNetClassName = the new netclass name + * @return true if lists of tracks and vias sizes are modified + */ + bool SetCurrentNetClass( const wxString& aNetClassName ); + + /** + * Function GetBiggestClearanceValue + * @return the biggest clearance value found in NetClasses list + */ + int GetBiggestClearanceValue(); + + /** + * Function GetSmallestClearanceValue + * @return the smallest clearance value found in NetClasses list + */ + int GetSmallestClearanceValue(); + + /** + * Function GetCurrentMicroViaSize + * @return the current micro via size, + * that is the current netclass value + */ + int GetCurrentMicroViaSize(); + + /** + * Function GetCurrentMicroViaDrill + * @return the current micro via drill, + * that is the current netclass value + */ + int GetCurrentMicroViaDrill(); + + /** + * Function GetTrackWidthIndex + * @return the current track width list index. + */ + inline unsigned GetTrackWidthIndex() const { return m_trackWidthIndex; } + + /** + * Function SetTrackWidthIndex + * sets the current track width list index to \a aIndex. + * + * @param aIndex is the track width list index. + */ + void SetTrackWidthIndex( unsigned aIndex ); + + /** + * Function GetCurrentTrackWidth + * @return the current track width, according to the selected options + * ( using the default netclass value or a preset/custom value ) + * the default netclass is always in m_TrackWidthList[0] + */ + inline int GetCurrentTrackWidth() const + { + return m_useCustomTrackVia ? m_customTrackWidth : m_TrackWidthList[m_trackWidthIndex]; + } + + /** + * Function SetCustomTrackWidth + * Sets custom width for track (i.e. not available in netclasses or preset list). To have + * it returned with GetCurrentTrackWidth() you need to enable custom track & via sizes + * (UseCustomTrackViaSize()). + * @param aWidth is the new track width. + */ + inline void SetCustomTrackWidth( int aWidth ) + { + m_customTrackWidth = aWidth; + } + + /** + * Function GetCustomTrackWidth + * @return Current custom width for a track. + */ + inline int GetCustomTrackWidth() const + { + return m_customTrackWidth; + } + + /** + * Function GetViaSizeIndex + * @return the current via size list index. + */ + inline unsigned GetViaSizeIndex() const + { + return m_viaSizeIndex; + } + + /** + * Function SetViaSizeIndex + * sets the current via size list index to \a aIndex. + * + * @param aIndex is the via size list index. + */ + void SetViaSizeIndex( unsigned aIndex ); + + /** + * Function GetCurrentViaSize + * @return the current via size, according to the selected options + * ( using the default netclass value or a preset/custom value ) + * the default netclass is always in m_TrackWidthList[0] + */ + inline int GetCurrentViaSize() const + { + if( m_useCustomTrackVia ) + return m_customViaSize.m_Diameter; + else + return m_ViasDimensionsList[m_viaSizeIndex].m_Diameter; + } + + /** + * Function SetCustomViaSize + * Sets custom size for via diameter (i.e. not available in netclasses or preset list). To have + * it returned with GetCurrentViaSize() you need to enable custom track & via sizes + * (UseCustomTrackViaSize()). + * @param aSize is the new drill diameter. + */ + inline void SetCustomViaSize( int aSize ) + { + m_customViaSize.m_Diameter = aSize; + } + + /** + * Function GetCustomViaSize + * @return Current custom size for the via diameter. + */ + inline int GetCustomViaSize() const + { + return m_customViaSize.m_Diameter; + } + + /** + * Function GetCurrentViaDrill + * @return the current via size, according to the selected options + * ( using the default netclass value or a preset/custom value ) + * the default netclass is always in m_TrackWidthList[0] + */ + int GetCurrentViaDrill() const; + + /** + * Function SetCustomViaDrill + * Sets custom size for via drill (i.e. not available in netclasses or preset list). To have + * it returned with GetCurrentViaDrill() you need to enable custom track & via sizes + * (UseCustomTrackViaSize()). + * @param aDrill is the new drill size. + */ + inline void SetCustomViaDrill( int aDrill ) + { + m_customViaSize.m_Drill = aDrill; + } + + /** + * Function GetCustomViaDrill + * @return Current custom size for the via drill. + */ + inline int GetCustomViaDrill() const + { + return m_customViaSize.m_Drill; + } + + /** + * Function UseCustomTrackViaSize + * Enables/disables custom track/via size settings. If enabled, values set with + * SetCustomTrackWidth()/SetCustomViaSize()/SetCustomViaDrill() are used for newly created + * tracks and vias. + * @param aEnabled decides if custom settings should be used for new tracks/vias. + */ + inline void UseCustomTrackViaSize( bool aEnabled ) + { + m_useCustomTrackVia = aEnabled; + } + + /** + * Function UseCustomTrackViaSize + * @return True if custom sizes of tracks & vias are enabled, false otherwise. + */ + inline bool UseCustomTrackViaSize() const + { + return m_useCustomTrackVia; + } + + /** + * Function GetVisibleLayers + * returns a bit-mask of all the layers that are visible + * @return int - the visible layers in bit-mapped form. + */ + inline LSET GetVisibleLayers() const + { + return m_visibleLayers; + } + + /** + * Function SetVisibleAlls + * Set the bit-mask of all visible elements categories, + * including enabled layers + */ + void SetVisibleAlls(); + + /** + * Function SetVisibleLayers + * changes the bit-mask of visible layers + * @param aMask = The new bit-mask of visible layers + */ + inline void SetVisibleLayers( LSET aMask ) + { + m_visibleLayers = aMask & m_enabledLayers; + } + + /** + * Function IsLayerVisible + * tests whether a given layer is visible + * @param aLayerId = The layer to be tested + * @return bool - true if the layer is visible. + */ + inline bool IsLayerVisible( LAYER_ID aLayerId ) const + { + // If a layer is disabled, it is automatically invisible + return (m_visibleLayers & m_enabledLayers)[aLayerId]; + } + + /** + * Function SetLayerVisibility + * changes the visibility of a given layer + * @param aLayerId = The layer to be changed + * @param aNewState = The new visibility state of the layer + */ + void SetLayerVisibility( LAYER_ID aLayerId, bool aNewState ); + + /** + * Function GetVisibleElements + * returns a bit-mask of all the element categories that are visible + * @return int - the visible element categories in bit-mapped form. + */ + inline int GetVisibleElements() const + { + return m_visibleElements; + } + + /** + * Function SetVisibleElements + * changes the bit-mask of visible element categories + * @param aMask = The new bit-mask of visible element categories + */ + inline void SetVisibleElements( int aMask ) + { + m_visibleElements = aMask; + } + + /** + * Function IsElementVisible + * tests whether a given element category is visible. Keep this as an + * inline function. + * @param aElementCategory is from the enum by the same name + * @return bool - true if the element is visible. + * @see enum PCB_VISIBLE + */ + inline bool IsElementVisible( int aElementCategory ) const + { + assert( aElementCategory >= 0 && aElementCategory < END_PCB_VISIBLE_LIST ); + + return ( m_visibleElements & ( 1 << aElementCategory ) ); + } + + /** + * Function SetElementVisibility + * changes the visibility of an element category + * @param aElementCategory is from the enum by the same name + * @param aNewState = The new visibility state of the element category + * @see enum PCB_VISIBLE + */ + void SetElementVisibility( int aElementCategory, bool aNewState ); + + /** + * Function GetEnabledLayers + * returns a bit-mask of all the layers that are enabled + * @return int - the enabled layers in bit-mapped form. + */ + inline LSET GetEnabledLayers() const + { + return m_enabledLayers; + } + + /** + * Function SetEnabledLayers + * changes the bit-mask of enabled layers + * @param aMask = The new bit-mask of enabled layers + */ + void SetEnabledLayers( LSET aMask ); + + /** + * Function IsLayerEnabled + * tests whether a given layer is enabled + * @param aLayerId = The layer to be tested + * @return bool - true if the layer is enabled + */ + inline bool IsLayerEnabled( LAYER_ID aLayerId ) const + { + return m_enabledLayers[aLayerId]; + } + + /** + * Function GetCopperLayerCount + * @return int - the number of neabled copper layers + */ + inline int GetCopperLayerCount() const + { + return m_copperLayerCount; + } + + /** + * Function SetCopperLayerCount + * do what its name says... + * @param aNewLayerCount = The new number of enabled copper layers + */ + void SetCopperLayerCount( int aNewLayerCount ); + + /** + * Function AppendConfigs + * appends to @a aResult the configuration setting accessors which will later + * allow reading or writing of configuration file information directly into + * this object. + */ + void AppendConfigs( PARAM_CFG_ARRAY* aResult ); + + inline int GetBoardThickness() const { return m_boardThickness; } + inline void SetBoardThickness( int aThickness ) { m_boardThickness = aThickness; } + +private: + void formatNetClass( NETCLASS* aNetClass, OUTPUTFORMATTER* aFormatter, int aNestLevel, + int aControlBits ) const throw( IO_ERROR ); +}; + +#endif // BOARD_DESIGN_SETTINGS_H_ |