board_stackup_table.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The 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 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, see <https://www.gnu.org/licenses/>.
 */
 
 
#include <board.h>
#include <board_design_settings.h>
#include <board_design_settings_defaults.h>
#include <board_item.h>
#include <pcb_table.h>
#include <pcb_tablecell.h>
#include <pcb_edit_frame.h>
#include <units_provider.h>
#include <board_stackup_manager/stackup_predefined_prms.h>
#include <string_utils.h>
 
PCB_TABLE* Build_Board_Stackup_Table( BOARD* aBoard, EDA_UNITS aDisplayUnits )
{
    BOARD_DESIGN_SETTINGS& settings = aBoard->GetDesignSettings();
    BOARD_STACKUP&         stackup  = settings.GetStackupDescriptor();
    UNITS_PROVIDER         units_provider( pcbIUScale, aDisplayUnits );
 
    stackup.SynchronizeWithBoard( &settings );
 
    std::vector<BOARD_STACKUP_ITEM*> layers = stackup.GetList();
 
    PCB_TABLE* table = new PCB_TABLE( aBoard, pcbIUScale.mmToIU( DEFAULT_LINE_WIDTH ) );
    table->SetColCount( 7 );
 
    const auto addHeaderCell =
            [&]( const wxString& text )
            {
                PCB_TABLECELL* c = new PCB_TABLECELL( table );
                c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 1.5 ), pcbIUScale.mmToIU( 1.5 ) ) );
                c->SetTextThickness( pcbIUScale.mmToIU( 0.3 ) );
                c->SetText( text );
                table->AddCell( c );
            };
 
    const auto addDataCell =
            [&]( const wxString& text, const char align = 'L' )
            {
                PCB_TABLECELL* c = new PCB_TABLECELL( table );
                c->SetTextSize( VECTOR2I( pcbIUScale.mmToIU( 1.5 ), pcbIUScale.mmToIU( 1.5 ) ) );
                c->SetTextThickness( pcbIUScale.mmToIU( 0.2 ) );
 
                if( align == 'R' )
                    c->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 
                c->SetText( text );
                table->AddCell( c );
            };
 
    const auto layerThicknessString =
            [&]( const BOARD_STACKUP_ITEM& aStackupItem, int aSublayerId )
            {
                const int layerThickness = aStackupItem.GetThickness( aSublayerId );
 
                // Layers like silkscreen, paste, etc. have no defined thickness, but that
                // does not mean that they are specified as exactly 0mm
                if( !aStackupItem.IsThicknessEditable() )
                    return NotSpecifiedPrm();
 
                return units_provider.StringFromValue( layerThickness, true );
            };
 
    addHeaderCell( _( "Layer Name" ) );
    addHeaderCell( _( "Type" ) );
    addHeaderCell( _( "Material" ) );
    addHeaderCell( _( "Thickness" ) );
    addHeaderCell( _( "Color" ) );
    addHeaderCell( _( "Epsilon R" ) );
    addHeaderCell( _( "Loss Tangent" ) );
 
    for( int i = 0; i < stackup.GetCount(); i++ )
    {
        BOARD_STACKUP_ITEM* stackup_item = layers.at( i );
 
        for( int sublayer_id = 0; sublayer_id < stackup_item->GetSublayersCount(); sublayer_id++ )
        {
            // Layer names are empty until we close at least once the board setup dialog.
            // If the user did not open the dialog, then get the names from the board.
            // But dielectric layer names will be missing. And in stackup, the name is not very good
            // So, for dielectric, a name will be used, similar to the name build in gerber job file
            wxString layerName = stackup_item->GetLayerName();
 
            if( layerName.IsEmpty() )
            {
                if( IsValidLayer( stackup_item->GetBrdLayerId() ) )
                    layerName = aBoard->GetLayerName( stackup_item->GetBrdLayerId() );
            }
 
            if( stackup_item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
            {
                layerName = _( "Dielectric" );
 
                if( stackup_item->GetSublayersCount() < 2 )
                    layerName <<  wxT( " " ) << stackup_item->GetDielectricLayerId();
                else
                    layerName << wxString::Format( _( " %d (%d/%d)" ), stackup_item->GetDielectricLayerId(),
                                        sublayer_id + 1, stackup_item->GetSublayersCount() );
            }
 
            addDataCell( layerName );
 
            addDataCell( InitialCaps( stackup_item->GetTypeName() ) );
            addDataCell( stackup_item->GetMaterial( sublayer_id ) );
            addDataCell( layerThicknessString( *stackup_item, sublayer_id ), 'R' );
            addDataCell( stackup_item->GetColor( sublayer_id ) );
            addDataCell( EDA_UNIT_UTILS::UI::StringFromValue( unityScale, EDA_UNITS::UNSCALED,
                                                              stackup_item->GetEpsilonR( sublayer_id ) ), 'R' );
            addDataCell( EDA_UNIT_UTILS::UI::StringFromValue( unityScale, EDA_UNITS::UNSCALED,
                                                              stackup_item->GetLossTangent( sublayer_id ) ), 'R' );
        }
    }
 
    table->Autosize();
    table->SetPosition( VECTOR2I( 0, 0 ) );
 
    return table;
}