pcb_barcode.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020 Thomas Pointhuber <[email protected]>
 * Copyright (C) 2020 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 <core/type_helpers.h>
#include <bitmaps.h>
#include <gr_basic.h>
#include <macros.h>
#include <pcb_edit_frame.h>
#include <richio.h>
#include <trigo.h>
 
#include <base_units.h>
#include <api/api_enums.h>
#include <api/board/board_types.pb.h>
#include <pcb_barcode.h>
#include <board.h>
#include <footprint.h>
#include <geometry/shape_poly_set.h>
#include <pcb_text.h>
#include <view/view.h>
#include <math/util.h> // for KiROUND
#include <convert_basic_shapes_to_polygon.h>
#include <wx/log.h>
#include <pgm_base.h>
#include <settings/color_settings.h>
#include <settings/settings_manager.h>
#include <scoped_set_reset.h>
#include <stdexcept>
#include <utility>
#include <algorithm>
#include <api/api_utils.h>
#include <footprint.h>
 
#include <backend/zint.h>
#include <board_design_settings.h>
#include <hash.h>
#include <google/protobuf/any.pb.h>
#include <properties/property.h>
#include <properties/property_mgr.h>
 
constexpr int ECI_UTF8 = 26;
 
PCB_BARCODE::PCB_BARCODE( BOARD_ITEM* aParent ) :
        BOARD_ITEM( aParent, PCB_BARCODE_T ),
        m_width( pcbIUScale.mmToIU( 40 ) ),
        m_height( pcbIUScale.mmToIU( 40 ) ),
        m_libPos( 0, 0 ),
        m_text( this ),
        m_kind( BARCODE_T::QR_CODE ),
        m_libAngle( 0 ),
        m_errorCorrection( BARCODE_ECC_T::L )
{
    m_layer = Dwgs_User;
}
 
 
PCB_BARCODE::~PCB_BARCODE()
{
}
 
 
PCB_BARCODE::PCB_BARCODE( const PCB_BARCODE& aOther ) :
        BOARD_ITEM( aOther ),
        m_width( aOther.m_width ),
        m_height( aOther.m_height ),
        m_libPos( aOther.m_libPos ),
        m_margin( aOther.m_margin ),
        m_text( aOther.m_text ),
        m_kind( aOther.m_kind ),
        m_libAngle( aOther.m_libAngle ),
        m_errorCorrection( aOther.m_errorCorrection )
{
    m_text.SetParent( this );
}
 
 
PCB_BARCODE& PCB_BARCODE::operator=( const PCB_BARCODE& aOther )
{
    if( this != &aOther )
    {
        BOARD_ITEM::operator=( aOther );
 
        m_width = aOther.m_width;
        m_height = aOther.m_height;
        m_libPos = aOther.m_libPos;
        m_margin = aOther.m_margin;
        m_text = aOther.m_text;
        m_kind = aOther.m_kind;
        m_libAngle = aOther.m_libAngle;
        m_errorCorrection = aOther.m_errorCorrection;
 
        m_cache.reset();
 
        m_text.SetParent( this );
    }
 
    return *this;
}
 
 
void PCB_BARCODE::SetPosition( const VECTOR2I& aPos )
{
    VECTOR2I delta = aPos - GetPosition();
    Move( delta );
}
 
 
VECTOR2I PCB_BARCODE::GetPosition() const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return fp->GetTransform().Apply( m_libPos );
 
    return m_libPos;
}
 
 
EDA_ANGLE PCB_BARCODE::GetAngle() const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return ( m_libAngle + fp->GetOrientation() ).Normalize();
 
    return m_libAngle;
}
 
 
void PCB_BARCODE::SetText( const wxString& aNewText )
{
    m_text.SetText( aNewText );
}
 
 
wxString PCB_BARCODE::GetText() const
{
    return m_text.GetText();
}
 
 
wxString PCB_BARCODE::GetShownText( RESOLUTION_CONTEXT aContext ) const
{
    return m_text.GetShownText( aContext );
}
 
 
void PCB_BARCODE::Serialize( google::protobuf::Any& aContainer ) const
{
    using namespace kiapi::board::types;
 
    Barcode barcode;
 
    barcode.mutable_id()->set_value( m_Uuid.AsStdString() );
    barcode.set_text( GetText().ToUTF8() );
 
    switch( m_kind )
    {
    case BARCODE_T::CODE_39:       barcode.set_kind( BK_CODE_39 );       break;
    case BARCODE_T::CODE_128:      barcode.set_kind( BK_CODE_128 );      break;
    case BARCODE_T::DATA_MATRIX:   barcode.set_kind( BK_DATA_MATRIX );   break;
    case BARCODE_T::QR_CODE:       barcode.set_kind( BK_QR_CODE );       break;
    case BARCODE_T::MICRO_QR_CODE: barcode.set_kind( BK_MICRO_QR_CODE ); break;
    }
 
    switch( m_errorCorrection )
    {
    case BARCODE_ECC_T::L: barcode.set_error_correction( BEC_L ); break;
    case BARCODE_ECC_T::M: barcode.set_error_correction( BEC_M ); break;
    case BARCODE_ECC_T::Q: barcode.set_error_correction( BEC_Q ); break;
    case BARCODE_ECC_T::H: barcode.set_error_correction( BEC_H ); break;
    }
 
    kiapi::common::PackVector2( *barcode.mutable_position(), GetPosition() );
    barcode.mutable_orientation()->set_value_degrees( GetAngle().AsDegrees() );
 
    if( FOOTPRINT* parent = GetParentFootprint() )
        barcode.mutable_parent()->set_value( parent->m_Uuid.AsStdString() );
    else if( const BOARD* board = GetBoard() )
        barcode.mutable_parent()->set_value( board->m_Uuid.AsStdString() );
 
    barcode.set_layer( ToProtoEnum<PCB_LAYER_ID, BoardLayer>( GetLayer() ) );
 
    barcode.mutable_width()->set_value_nm( m_width );
    barcode.mutable_height()->set_value_nm( m_height );
 
    barcode.set_show_text( m_text.IsVisible() );
    barcode.mutable_text_height()->set_value_nm( m_text.GetTextHeight() );
 
    barcode.set_knockout( IsKnockout() );
    kiapi::common::PackVector2( *barcode.mutable_knockout_margin(), m_margin );
 
    barcode.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
                                   : kiapi::common::types::LockedState::LS_UNLOCKED );
 
    kiapi::common::PackCustomProperties( barcode.mutable_custom_properties(), *this );
    aContainer.PackFrom( barcode );
}
 
 
bool PCB_BARCODE::Deserialize( const google::protobuf::Any& aContainer )
{
    using namespace kiapi::board::types;
 
    Barcode barcode;
 
    if( !aContainer.UnpackTo( &barcode ) )
        return false;
 
    SetUuidDirect( KIID( barcode.id().value() ) );
    SetText( wxString::FromUTF8( barcode.text() ) );
 
    switch( barcode.kind() )
    {
    case BK_CODE_39:       SetKind( BARCODE_T::CODE_39 );       break;
    case BK_CODE_128:      SetKind( BARCODE_T::CODE_128 );      break;
    case BK_DATA_MATRIX:   SetKind( BARCODE_T::DATA_MATRIX );   break;
    case BK_QR_CODE:       SetKind( BARCODE_T::QR_CODE );       break;
    case BK_MICRO_QR_CODE: SetKind( BARCODE_T::MICRO_QR_CODE ); break;
    default:               SetKind( BARCODE_T::QR_CODE );       break;
    }
 
    switch( barcode.error_correction() )
    {
    case BEC_L: SetErrorCorrection( BARCODE_ECC_T::L ); break;
    case BEC_M: SetErrorCorrection( BARCODE_ECC_T::M ); break;
    case BEC_Q: SetErrorCorrection( BARCODE_ECC_T::Q ); break;
    case BEC_H: SetErrorCorrection( BARCODE_ECC_T::H ); break;
    default:    SetErrorCorrection( BARCODE_ECC_T::L ); break;
    }
 
    SetPosition( kiapi::common::UnpackVector2( barcode.position() ) );
 
    EDA_ANGLE newAngle( barcode.orientation().value_degrees(), DEGREES_T );
 
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_libAngle = newAngle - fp->GetOrientation();
    else
        m_libAngle = newAngle;
 
    m_libAngle.Normalize();
 
    m_layer = FromProtoEnum<PCB_LAYER_ID, BoardLayer>( barcode.layer() );
 
    m_width = barcode.width().value_nm();
    m_height = barcode.height().value_nm();
 
    m_text.SetLayer( m_layer );
    m_text.SetVisible( barcode.show_text() );
 
    if( barcode.has_text_height() )
    {
        int textSize = std::max( 1, static_cast<int>( barcode.text_height().value_nm() ) );
        m_text.SetTextSize( VECTOR2I( textSize, textSize ) );
        m_text.SetTextThickness( std::max( 1, GetPenSizeForNormal( m_text.GetTextHeight() ) ) );
    }
 
    m_margin = kiapi::common::UnpackVector2( barcode.knockout_margin() );
    BOARD_ITEM::SetIsKnockout( barcode.knockout() );
    SetLocked( barcode.locked() == kiapi::common::types::LockedState::LS_LOCKED );
 
    kiapi::common::UnpackCustomProperties( barcode.custom_properties(), *this );
 
    AssembleBarcode();
 
    return true;
}
 
 
void PCB_BARCODE::SetLayer( PCB_LAYER_ID aLayer )
{
    m_layer = aLayer;
    m_text.SetLayer( aLayer );
    AssembleBarcode();
}
 
 
void PCB_BARCODE::SetTextSize( int aTextSize )
{
    m_text.SetTextSize( VECTOR2I( std::max( 1, aTextSize ), std::max( 1, aTextSize ) ) );
    m_text.SetTextThickness( std::max( 1, GetPenSizeForNormal( m_text.GetTextHeight() ) ) );
    AssembleBarcode();
}
 
 
int PCB_BARCODE::GetTextSize() const
{
    return m_text.GetTextHeight();
}
 
 
void PCB_BARCODE::Move( const VECTOR2I& offset )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
    {
        const TRANSFORM_TRS& xform = fp->GetTransform();
        VECTOR2I             libOffset = xform.InverseApply( offset ) - xform.InverseApply( VECTOR2I( 0, 0 ) );
        m_libPos += libOffset;
    }
    else
    {
        m_libPos += offset;
    }
 
    // m_text is intentionally not moved, ComputeTextPoly repositions it
    // under the symbol on the next AssembleBarcode.
}
 
 
void PCB_BARCODE::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
{
    VECTOR2I boardPos = GetPosition();
    RotatePoint( boardPos, aRotCentre, aAngle );
 
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_libPos = fp->GetTransform().InverseApply( boardPos );
    else
        m_libPos = boardPos;
 
    m_libAngle += aAngle;
    m_libAngle.Normalize();
 
    AssembleBarcode();
}
 
 
void PCB_BARCODE::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
    {
        const VECTOR2I libAxis = fp->GetTransform().InverseApply( aCentre );
 
        if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
            m_libPos.x = 2 * libAxis.x - m_libPos.x;
        else
            m_libPos.y = 2 * libAxis.y - m_libPos.y;
 
        // Reflect the library-frame angle (rotation-independent).
        if( aFlipDirection == FLIP_DIRECTION::TOP_BOTTOM )
            m_libAngle = ANGLE_180 - m_libAngle;
        else
            m_libAngle = -m_libAngle;
 
        m_libAngle.Normalize();
 
        SetLayer( GetBoard()->FlipLayer( GetLayer() ) );
        AssembleBarcode();
        return;
    }
 
    VECTOR2I boardPos = GetPosition();
    MIRROR( boardPos, aCentre, aFlipDirection );
    m_libPos = boardPos;
 
    if( aFlipDirection == FLIP_DIRECTION::TOP_BOTTOM )
        m_libAngle = ANGLE_180 - m_libAngle;
    else
        m_libAngle = -m_libAngle;
 
    m_libAngle.Normalize();
 
    SetLayer( GetBoard()->FlipLayer( GetLayer() ) );
    AssembleBarcode();
}
 
 
void PCB_BARCODE::OnFootprintRescaled( double /* aRatioX */, double /* aRatioY */, double /* aLinearFactor */,
                                       const VECTOR2I& /* aAnchor */, const EDA_ANGLE& /* aParentRotate */ )
{
    // Board values derive on read, AssembleBarcode rebuilds on next access.
}
 
 
void PCB_BARCODE::StyleFromSettings( const BOARD_DESIGN_SETTINGS& settings, bool aCheckSide )
{
    SetTextSize( settings.GetTextSize( GetLayer() ).y );
}
 
 
size_t PCB_BARCODE::computeCacheKey() const
{
    const VECTOR2I  pos = GetPosition();
    const EDA_ANGLE angle = GetAngle();
 
    return hash_val( GetShownText( FOR_CANVAS ), m_width, m_height, pos.x, pos.y, m_margin.x, m_margin.y,
                     static_cast<int>( m_kind ), angle.AsDegrees(), static_cast<int>( m_errorCorrection ),
                     m_text.IsVisible(), m_text.GetTextHeight(), IsKnockout(), static_cast<int>( m_layer ) );
}
 
 
void PCB_BARCODE::AssembleBarcode() const
{
    size_t key = computeCacheKey();
 
    if( m_cache && m_cache->keyHash == key )
        return;
 
    if( !m_cache )
        m_cache = std::make_unique<PCB_BARCODE_CACHE>();
 
    ComputeBarcode();
 
    const VECTOR2I pos = GetPosition();
 
    // Scale the symbol polygon to the desired barcode width/height and center it at pos.
    rescaleSymbolPoly( pos - VECTOR2I( m_width / 2, m_height / 2 ), pos + VECTOR2I( m_width / 2, m_height / 2 ) );
 
    ComputeTextPoly();
 
    // Build full m_poly from symbol + optional text, then apply knockout if requested
    m_cache->poly.RemoveAllContours();
    m_cache->poly.Append( m_cache->symbolPoly );
 
    if( m_text.IsVisible() && m_cache->textPoly.OutlineCount() )
        m_cache->poly.Append( m_cache->textPoly );
 
    m_cache->poly.Fracture();
 
    if( IsKnockout() )
    {
        // Enforce minimum margin: at least 10% of the smallest side of the barcode, rounded up
        // to the nearest 0.1 mm. Use this as a lower bound for both axes.
        int minSide = std::min( m_width, m_height );
        int tenPercent = ( minSide + 9 ) / 10; // ceil(minSide * 0.1)
        int step01mm = std::max( 1, pcbIUScale.mmToIU( 0.1 ) );
        int tenPercentRounded = ( ( tenPercent + step01mm - 1 ) / step01mm ) * step01mm;
 
        // Build inversion rectangle based on the local bbox of the current combined geometry
        BOX2I bbox = m_cache->poly.BBox();
        bbox.Inflate( std::max( m_margin.x, tenPercentRounded ), std::max( m_margin.y, tenPercentRounded ) );
 
        SHAPE_LINE_CHAIN rect;
        rect.Append( bbox.GetLeft(),  bbox.GetTop() );
        rect.Append( bbox.GetRight(), bbox.GetTop() );
        rect.Append( bbox.GetRight(), bbox.GetBottom() );
        rect.Append( bbox.GetLeft(),  bbox.GetBottom() );
        rect.SetClosed( true );
 
        SHAPE_POLY_SET ko;
        ko.AddOutline( rect );
        ko.BooleanSubtract( m_cache->poly );
        ko.Fracture();
        m_cache->poly = std::move( ko );
    }
 
    if( IsSideSpecific() && GetBoard() && GetBoard()->IsBackLayer( m_layer ) )
        m_cache->poly.Mirror( pos, FLIP_DIRECTION::LEFT_RIGHT );
 
    const EDA_ANGLE angle = GetAngle();
 
    if( !angle.IsZero() )
        m_cache->poly.Rotate( angle, pos );
 
    m_cache->poly.CacheTriangulation();
    m_cache->bbox = m_cache->poly.BBox();
    m_cache->keyHash = key;
}
 
 
void PCB_BARCODE::ComputeTextPoly() const
{
    if( !m_cache )
        m_cache = std::make_unique<PCB_BARCODE_CACHE>();
 
    m_cache->textPoly.RemoveAllContours();
 
    if( !m_text.IsVisible() )
        return;
 
    SHAPE_POLY_SET textPoly;
    m_text.TransformTextToPolySet( textPoly, 0, GetMaxError(), ERROR_INSIDE );
 
    if( textPoly.OutlineCount() == 0 )
        return;
 
    // PCB_TEXT::GetDrawRotation now includes the parent FP orientation, so
    // TransformTextToPolySet rendered the glyphs already rotated by the FP
    // angle. The final AssembleBarcode rotation (m_cache->poly.Rotate by
    // GetAngle = lib_angle + FP_orient) would then rotate the glyphs a
    // second time, producing twice the intended visual rotation. Undo the
    // m_text-side rotation here so the glyph-orientation contribution is
    // only the lib_angle, and the final poly rotation applies the FP-orient
    // part uniformly with the symbol.
    if( const FOOTPRINT* fp = GetParentFootprint() )
    {
        EDA_ANGLE fpOrient = fp->GetOrientation();
 
        if( !fpOrient.IsZero() )
            textPoly.Rotate( -fpOrient, m_text.GetTextPos() );
    }
 
    if( m_cache->symbolPoly.OutlineCount() == 0 )
        return;
 
    BOX2I textBBox = textPoly.BBox();
    BOX2I    symbolBBox = m_cache->symbolPoly.BBox();
    VECTOR2I textPos;
    int textOffset = pcbIUScale.mmToIU( 1 );
    textPos.x = symbolBBox.GetCenter().x - textBBox.GetCenter().x;
    textPos.y = symbolBBox.GetBottom() - textBBox.GetTop() + textOffset;
 
    textPoly.Move( textPos );
 
    m_cache->textPoly = std::move( textPoly );
    m_cache->textPoly.CacheTriangulation();
}
 
 
void PCB_BARCODE::ComputeBarcode() const
{
    if( !m_cache )
        m_cache = std::make_unique<PCB_BARCODE_CACHE>();
 
    m_cache->symbolPoly.RemoveAllContours();
    m_cache->lastError.clear();
 
    std::unique_ptr<zint_symbol, decltype( &ZBarcode_Delete )> symbol( ZBarcode_Create(), &ZBarcode_Delete );
 
    if( !symbol )
    {
        wxLogError( wxT( "Zint: failed to allocate symbol" ) );
        return;
    }
 
    symbol->input_mode = UNICODE_MODE;
    symbol->show_hrt = 0; // do not show HRT
 
    switch( m_kind )
    {
    case BARCODE_T::CODE_39:
        symbol->symbology = BARCODE_CODE39;
        break;
    case BARCODE_T::CODE_128:
        symbol->symbology = BARCODE_CODE128;
        break;
    case BARCODE_T::QR_CODE:
        symbol->symbology = BARCODE_QRCODE;
        symbol->option_1 = to_underlying( m_errorCorrection );
        break;
    case BARCODE_T::MICRO_QR_CODE:
        symbol->symbology = BARCODE_MICROQR;
        symbol->option_1 = to_underlying( m_errorCorrection );
        break;
    case BARCODE_T::DATA_MATRIX:
        symbol->symbology = BARCODE_DATAMATRIX;
        break;
    default:
        wxLogError( wxT( "Zint: invalid barcode type" ) );
        return;
    }
 
    wxString text = GetShownText( FOR_CANVAS );
    wxScopedCharBuffer utf8Text = text.ToUTF8();
    size_t length = utf8Text.length();
    unsigned char* dataPtr = reinterpret_cast<unsigned char*>( utf8Text.data() );
 
    if( text.empty() )
        return;
 
    if( ( m_kind == BARCODE_T::QR_CODE || m_kind == BARCODE_T::DATA_MATRIX ) && !text.IsAscii() )
    {
        symbol->eci = ECI_UTF8;
    }
 
    if( ZBarcode_Encode( symbol.get(), dataPtr, length ) >= ZINT_ERROR )
    {
        if( !text.IsAscii() )
        {
            m_cache->lastError = _( "This barcode type does not support international "
                                    "characters. Use QR Code or Data Matrix instead." );
        }
        else
        {
            m_cache->lastError = wxString::FromUTF8( symbol->errtxt );
        }
        return;
    }
 
    if( ZBarcode_Buffer_Vector( symbol.get(), 0 ) >= ZINT_ERROR )
    {
        m_cache->lastError = wxString::FromUTF8( symbol->errtxt );
        return;
    }
 
    for( zint_vector_rect* rect = symbol->vector->rectangles; rect != nullptr; rect = rect->next )
    {
        // Round using absolute edges to avoid cumulative rounding drift across modules.
        int x1 = KiROUND( rect->x * symbol->scale );
        int x2 = KiROUND( ( rect->x + rect->width ) * symbol->scale );
        int y1 = KiROUND( rect->y * symbol->scale );
        int y2 = KiROUND( ( rect->y + rect->height ) * symbol->scale );
 
        SHAPE_LINE_CHAIN shapeline;
        shapeline.Append( x1, y1 );
        shapeline.Append( x2, y1 );
        shapeline.Append( x2, y2 );
        shapeline.Append( x1, y2 );
        shapeline.SetClosed( true );
 
        m_cache->symbolPoly.AddOutline( shapeline );
    }
 
    for( zint_vector_hexagon* hex = symbol->vector->hexagons; hex != nullptr; hex = hex->next )
    {
        // Compute vertices from center using minimal-diameter (inscribed circle) radius.
        double r  = hex->diameter / 2.0; // minimal radius
        double cx = hex->x;
        double cy = hex->y;
 
        // Base orientation has apex at top; hex->rotation rotates by 0/90/180/270 degrees.
        double baseAngles[6] = { 90.0, 30.0, -30.0, -90.0, -150.0, 150.0 };
        double rot = static_cast<double>( hex->rotation );
 
        SHAPE_LINE_CHAIN poly;
 
        for( int k = 0; k < 6; ++k )
        {
            double ang = ( baseAngles[k] + rot ) * M_PI / 180.0;
            int vx = KiROUND( cx + r * cos( ang ) );
            int vy = KiROUND( cy + r * sin( ang ) );
            poly.Append( vx, vy );
        }
        poly.SetClosed( true );
 
        m_cache->symbolPoly.AddOutline( poly );
    }
 
    // Set the position of the barcode to the center of the symbol polygon
    if( m_cache->symbolPoly.OutlineCount() > 0 )
    {
        VECTOR2I pos = m_cache->symbolPoly.BBox().GetCenter();
        m_cache->symbolPoly.Move( -pos );
    }
 
    m_cache->symbolPoly.CacheTriangulation();
}
 
 
void PCB_BARCODE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{
    FOOTPRINT* parentFP = GetParentFootprint();
 
    if( parentFP && aFrame->GetName() == PCB_EDIT_FRAME_NAME )
        aList.emplace_back( _( "Footprint" ), parentFP->GetReference() );
 
    aList.emplace_back( _( "Barcode" ), ENUM_MAP<BARCODE_T>::Instance().ToString( m_kind ) );
 
    // Don't use GetShownText() here; we want to show the user the variable references
    aList.emplace_back( _( "Text" ), KIUI::EllipsizeStatusText( aFrame, GetText() ) );
 
    if( aFrame->GetName() == PCB_EDIT_FRAME_NAME && IsLocked() )
        aList.emplace_back( _( "Status" ), _( "Locked" ) );
 
    aList.emplace_back( _( "Layer" ), GetLayerName() );
 
    aList.emplace_back( _( "Angle" ), wxString::Format( wxT( "%g" ), GetAngle().AsDegrees() ) );
 
    aList.emplace_back( _( "Text Height" ), aFrame->MessageTextFromValue( m_text.GetTextHeight() ) );
}
 
 
bool PCB_BARCODE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
{
    AssembleBarcode();
 
    if( !GetBoundingBox().Contains( aPosition ) )
        return false;
 
    SHAPE_POLY_SET hulls;
 
    GetBoundingHull( hulls, UNDEFINED_LAYER, aAccuracy, ARC_LOW_DEF, ERROR_OUTSIDE );
 
    return hulls.Collide( aPosition );
}
 
 
bool PCB_BARCODE::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
{
    BOX2I arect = aRect;
    arect.Inflate( aAccuracy );
 
    BOX2I rect = GetBoundingBox();
 
    if( aAccuracy )
        rect.Inflate( aAccuracy );
 
    if( aContained )
        return arect.Contains( rect );
 
    return arect.Intersects( rect );
}
 
 
void PCB_BARCODE::rescaleSymbolPoly( const VECTOR2I& aTopLeft, const VECTOR2I& aBotRight ) const
{
    // Rescale only the symbol polygon to the requested rectangle
    BOX2I bbox = m_cache->symbolPoly.BBox();
    int oldW = bbox.GetWidth();
    int oldH = bbox.GetHeight();
 
    VECTOR2I newPosition = ( aTopLeft + aBotRight ) / 2;
    int newW = aBotRight.x - aTopLeft.x;
    int newH = aBotRight.y - aTopLeft.y;
    // Guard against zero/negative sizes from interactive edits; enforce a tiny minimum
    int minIU = std::max( 1, pcbIUScale.mmToIU( 0.01 ) );
    newW = std::max( newW, minIU );
    newH = std::max( newH, minIU );
 
    double scaleX = oldW ? static_cast<double>( newW ) / oldW : 1.0;
    double scaleY = oldH ? static_cast<double>( newH ) / oldH : 1.0;
 
    VECTOR2I oldCenter = bbox.GetCenter();
    m_cache->symbolPoly.Scale( scaleX, scaleY, oldCenter );
 
    // After scaling, move the symbol polygon to be centered at the new position
    VECTOR2I newCenter = m_cache->symbolPoly.BBox().GetCenter();
    VECTOR2I delta = newPosition - newCenter;
 
    if( delta != VECTOR2I( 0, 0 ) )
        m_cache->symbolPoly.Move( delta );
}
 
 
const BOX2I PCB_BARCODE::GetBoundingBox() const
{
    AssembleBarcode();
    return m_cache->bbox;
}
 
 
wxString PCB_BARCODE::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
{
    return wxString::Format( _( "Barcode '%s' on %s" ), GetText(), GetLayerName() );
}
 
 
BITMAPS PCB_BARCODE::GetMenuImage() const
{
    return BITMAPS::add_barcode;
}
 
 
const BOX2I PCB_BARCODE::ViewBBox() const
{
    AssembleBarcode();
    return m_cache->bbox;
}
 
 
double PCB_BARCODE::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
{
    // Hide the locked shadow when the barcode's own layer is not shown
    if( aLayer == LAYER_LOCKED_ITEM_SHADOW && !aView->IsLayerVisibleCached( m_layer ) )
        return LOD_HIDE;
 
    return LOD_SHOW;
}
 
 
void PCB_BARCODE::TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer,
                                           int aClearance, int aMaxError,
                                           ERROR_LOC aErrorLoc, bool ignoreLineWidth ) const
{
    if( aLayer != m_layer && aLayer != UNDEFINED_LAYER )
        return;
 
    AssembleBarcode();
 
    if( aClearance == 0 )
    {
        aBuffer.Append( m_cache->poly );
    }
    else
    {
        SHAPE_POLY_SET poly = m_cache->poly;
        poly.Inflate( aClearance, CORNER_STRATEGY::CHAMFER_ACUTE_CORNERS, aMaxError, aErrorLoc );
        aBuffer.Append( poly );
    }
}
 
 
std::shared_ptr<SHAPE> PCB_BARCODE::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING, DRC_CONSTRAINT_T ) const
{
    SHAPE_POLY_SET poly;
    TransformShapeToPolygon( poly, aLayer, 0, 0, ERROR_INSIDE, true );
 
    return std::make_shared<SHAPE_POLY_SET>( std::move( poly ) );
}
 
 
void PCB_BARCODE::GetBoundingHull( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
                                   int aMaxError, ERROR_LOC aErrorLoc ) const
{
    AssembleBarcode();
 
    auto getBoundingHull =
            [this]( SHAPE_POLY_SET& aLocBuffer, const SHAPE_POLY_SET& aSource, int aLocClearance )
            {
                BOX2I    rect = aSource.BBox( aLocClearance );
                VECTOR2I corners[4];
 
                corners[0].x = rect.GetOrigin().x;
                corners[0].y = rect.GetOrigin().y;
                corners[1].y = corners[0].y;
                corners[1].x = rect.GetRight();
                corners[2].x = corners[1].x;
                corners[2].y = rect.GetBottom();
                corners[3].y = corners[2].y;
                corners[3].x = corners[0].x;
 
                aLocBuffer.NewOutline();
 
                const VECTOR2I  pos = GetPosition();
                const EDA_ANGLE angle = GetAngle();
 
                for( VECTOR2I& corner : corners )
                {
                    RotatePoint( corner, pos, angle );
                    aLocBuffer.Append( corner.x, corner.y );
                }
            };
 
    if( aLayer == m_layer || aLayer == UNDEFINED_LAYER )
    {
        getBoundingHull( aBuffer, m_cache->symbolPoly, aClearance );
        getBoundingHull( aBuffer, m_cache->textPoly, aClearance );
    }
}
 
 
void PCB_BARCODE::SetErrorCorrection( BARCODE_ECC_T aErrorCorrection )
{
    // Micro QR codes do not support High (H) error correction level
    if( m_kind == BARCODE_T::MICRO_QR_CODE && aErrorCorrection == BARCODE_ECC_T::H )
        m_errorCorrection = BARCODE_ECC_T::Q;
    else
        m_errorCorrection = aErrorCorrection;
    // Don't auto-compute here as it may be called during loading
}
 
 
void PCB_BARCODE::SetKind( BARCODE_T aKind )
{
    m_kind = aKind;
 
    // When switching to Micro QR, validate and adjust ECC if needed
    if( m_kind == BARCODE_T::MICRO_QR_CODE && m_errorCorrection == BARCODE_ECC_T::H )
        m_errorCorrection = BARCODE_ECC_T::Q;
 
    // Don't auto-compute here as it may be called during loading
}
 
 
void PCB_BARCODE::SetBarcodeErrorCorrection( BARCODE_ECC_T aErrorCorrection )
{
    SetErrorCorrection( aErrorCorrection );
    AssembleBarcode();
}
 
 
void PCB_BARCODE::SetBarcodeWidth( int aWidth )
{
    m_width = aWidth;
 
    if( KeepSquare() )
        m_height = aWidth;
 
    AssembleBarcode();
}
 
 
void PCB_BARCODE::SetBarcodeHeight( int aHeight )
{
    m_height = aHeight;
 
    if( KeepSquare() )
        m_width = aHeight;
 
    AssembleBarcode();
}
 
 
void PCB_BARCODE::SetBarcodeKind( BARCODE_T aKind )
{
    SetKind( aKind );
    AssembleBarcode();
}
 
 
EDA_ITEM* PCB_BARCODE::Clone() const
{
    PCB_BARCODE* item = new PCB_BARCODE( *this );
    item->CopyFrom( this );
    return item;
}
 
 
void PCB_BARCODE::swapData( BOARD_ITEM* aImage )
{
    wxCHECK_RET( aImage && aImage->Type() == PCB_BARCODE_T,
                 wxT( "Cannot swap data with non-barcode item." ) );
 
    PCB_BARCODE* other = static_cast<PCB_BARCODE*>( aImage );
 
    std::swap( m_layer, other->m_layer );
    std::swap( m_isKnockout, other->m_isKnockout );
    std::swap( m_isLocked, other->m_isLocked );
    std::swap( m_width, other->m_width );
    std::swap( m_height, other->m_height );
    std::swap( m_libPos, other->m_libPos );
    std::swap( m_margin, other->m_margin );
    std::swap( m_text, other->m_text );
    std::swap( m_kind, other->m_kind );
    std::swap( m_libAngle, other->m_libAngle );
    std::swap( m_errorCorrection, other->m_errorCorrection );
    std::swap( m_cache, other->m_cache );
    std::swap( m_customProperties, other->m_customProperties );
 
    m_text.SetParent( this );
    other->m_text.SetParent( other );
}
 
double PCB_BARCODE::Similarity( const BOARD_ITEM& aItem ) const
{
    if( !ClassOf( &aItem ) )
        return 0.0;
 
    const PCB_BARCODE* other = static_cast<const PCB_BARCODE*>( &aItem );
 
    // Compare text, width, height, text height, position, and kind
    double similarity = 0.0;
    const double weight = 1.0 / 6.0;
 
    if( GetText() == other->GetText() )
        similarity += weight;
    if( m_width == other->m_width )
        similarity += weight;
    if( m_height == other->m_height )
        similarity += weight;
    if( GetTextSize() == other->GetTextSize() )
        similarity += weight;
    if( GetPosition() == other->GetPosition() )
        similarity += weight;
    if( m_kind == other->m_kind )
        similarity += weight;
 
    return similarity;
}
 
int PCB_BARCODE::Compare( const PCB_BARCODE* aBarcode, const PCB_BARCODE* aOther )
{
    int diff;
 
    if( ( diff = aBarcode->GetPosition().x - aOther->GetPosition().x ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetPosition().y - aOther->GetPosition().y ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetText().Cmp( aOther->GetText() ) ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetWidth() - aOther->GetWidth() ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetHeight() - aOther->GetHeight() ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetTextSize() - aOther->GetTextSize() ) != 0 )
        return diff;
 
    if( ( diff = (int) aBarcode->GetKind() - (int) aOther->GetKind() ) != 0 )
        return diff;
 
    if( ( diff = aBarcode->GetAngle().AsTenthsOfADegree() - aOther->GetAngle().AsTenthsOfADegree() ) != 0 )
        return diff;
 
    if( ( diff = (int) aBarcode->GetErrorCorrection() - (int) aOther->GetErrorCorrection() ) != 0 )
        return diff;
 
    return 0;
}
 
 
bool PCB_BARCODE::operator==( const BOARD_ITEM& aItem ) const
{
    if( !ClassOf( &aItem ) )
        return false;
 
    const PCB_BARCODE& other = static_cast<const PCB_BARCODE&>( aItem );
 
    return *this == other;
}
 
 
bool PCB_BARCODE::operator==( const PCB_BARCODE& aOther ) const
{
    // Compare text, width, height, text height, position, and kind
    return ( GetText() == aOther.GetText()
            && m_width == aOther.m_width
            && m_height == aOther.m_height
            && GetTextSize() == aOther.GetTextSize()
            && GetPosition() == aOther.GetPosition()
            && m_kind == aOther.m_kind );
}
 
// ---- Property registration ----
static struct PCB_BARCODE_DESC
{
    PCB_BARCODE_DESC()
    {
        PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
        REGISTER_TYPE( PCB_BARCODE );
        propMgr.InheritsAfter( TYPE_HASH( PCB_BARCODE ), TYPE_HASH( BOARD_ITEM ) );
 
        const wxString groupBarcode = _HKI( "Barcode Properties" );
 
        ENUM_MAP<BARCODE_T>& kindMap = ENUM_MAP<BARCODE_T>::Instance();
        if( kindMap.Choices().GetCount() == 0 )
        {
            kindMap.Undefined( BARCODE_T::QR_CODE );
            kindMap.Map( BARCODE_T::CODE_39,       _HKI( "CODE_39" ) )
                   .Map( BARCODE_T::CODE_128,      _HKI( "CODE_128" ) )
                   .Map( BARCODE_T::DATA_MATRIX,   _HKI( "DATA_MATRIX" ) )
                   .Map( BARCODE_T::QR_CODE,       _HKI( "QR_CODE" ) )
                   .Map( BARCODE_T::MICRO_QR_CODE, _HKI( "MICRO_QR_CODE" ) );
        }
 
        ENUM_MAP<BARCODE_ECC_T>& eccMap = ENUM_MAP<BARCODE_ECC_T>::Instance();
        if( eccMap.Choices().GetCount() == 0 )
        {
            eccMap.Undefined( BARCODE_ECC_T::L );
            eccMap.Map( BARCODE_ECC_T::L, _HKI( "L (Low)" ) )
                  .Map( BARCODE_ECC_T::M, _HKI( "M (Medium)" ) )
                  .Map( BARCODE_ECC_T::Q, _HKI( "Q (Quartile)" ) )
                  .Map( BARCODE_ECC_T::H, _HKI( "H (High)" ) );
        }
 
        auto hasKnockout =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( PCB_BARCODE* bc = dynamic_cast<PCB_BARCODE*>( aItem ) )
                        return bc->IsKnockout();
                    return false;
                };
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, wxString>( _HKI( "Text" ),
                    &PCB_BARCODE::SetBarcodeText, &PCB_BARCODE::GetText ),
                    groupBarcode );
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, bool>( _HKI( "Show Text" ),
                    &PCB_BARCODE::SetShowText, &PCB_BARCODE::GetShowText ),
                    groupBarcode ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, int>( _HKI( "Text Size" ),
                    &PCB_BARCODE::SetTextSize, &PCB_BARCODE::GetTextSize, PROPERTY_DISPLAY::PT_COORD ),
                    groupBarcode );
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, int>( _HKI( "Width" ),
                    &PCB_BARCODE::SetBarcodeWidth, &PCB_BARCODE::GetWidth, PROPERTY_DISPLAY::PT_COORD ),
                    groupBarcode ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, int>( _HKI( "Height" ),
                    &PCB_BARCODE::SetBarcodeHeight, &PCB_BARCODE::GetHeight, PROPERTY_DISPLAY::PT_COORD ),
                    groupBarcode ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, double>( _HKI( "Orientation" ),
                    &PCB_BARCODE::SetOrientation, &PCB_BARCODE::GetOrientation ),
                    groupBarcode );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PCB_BARCODE, BARCODE_T>( _HKI( "Barcode Type" ),
                    &PCB_BARCODE::SetBarcodeKind, &PCB_BARCODE::GetKind ),
                    groupBarcode );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PCB_BARCODE, BARCODE_ECC_T>( _HKI( "Error Correction" ),
                     &PCB_BARCODE::SetBarcodeErrorCorrection, &PCB_BARCODE::GetErrorCorrection ),
                     groupBarcode )
                .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
                                   {
                                       if( PCB_BARCODE* bc = dynamic_cast<PCB_BARCODE*>( aItem ) )
                                       {
                                           return bc->GetKind() == BARCODE_T::QR_CODE
                                                    || bc->GetKind() == BARCODE_T::MICRO_QR_CODE;
                                       }
 
                                       return false;
                                   } )
                .SetChoicesFunc( []( INSPECTABLE* aItem )
                                 {
                                     PCB_BARCODE* barcode = static_cast<PCB_BARCODE*>( aItem );
                                     wxPGChoices  choices;
 
                                     choices.Add( _( "L (Low)" ), static_cast<int>( BARCODE_ECC_T::L ) );
                                     choices.Add( _( "M (Medium)" ), static_cast<int>( BARCODE_ECC_T::M ) );
                                     choices.Add( _( "Q (Quartile)" ), static_cast<int>( BARCODE_ECC_T::Q ) );
 
                                     // Only QR_CODE has High
                                     if( barcode->GetKind() == BARCODE_T::QR_CODE )
                                         choices.Add( _( "H (High)" ), static_cast<int>( BARCODE_ECC_T::H ) );
 
                                     return choices;
                                 } );
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, bool>( _HKI( "Knockout" ),
                    &PCB_BARCODE::SetIsKnockout, &PCB_BARCODE::IsKnockout ),
                    groupBarcode ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, int>( _HKI( "Margin X" ),
                    &PCB_BARCODE::SetMarginX, &PCB_BARCODE::GetMarginX, PROPERTY_DISPLAY::PT_COORD ),
                    groupBarcode )
                .SetAvailableFunc( hasKnockout );
 
        propMgr.AddProperty( new PROPERTY<PCB_BARCODE, int>( _HKI( "Margin Y" ),
                    &PCB_BARCODE::SetMarginY, &PCB_BARCODE::GetMarginY, PROPERTY_DISPLAY::PT_COORD ),
                    groupBarcode )
                .SetAvailableFunc( hasKnockout );
    }
} _PCB_BARCODE_DESC;
 
IMPLEMENT_ENUM_TO_WXANY( BARCODE_T );
IMPLEMENT_ENUM_TO_WXANY( BARCODE_ECC_T );