haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Property Inspector support for dimension objects. 

Includes changing the class hierarchy so that dimension objects inherit
from PCB_TEXT rather than containing a PCB_TEXT member variable.

(cherry picked from commit 23accffc6d)
This commit is contained in:
Jeff Young 2023-03-04 23:15:43 +00:00
parent bf55e610b9
commit c0ddca12df
19 changed files with 477 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3d-viewer/3d_canvas/create_3Dgraphic_brd_items.cpp
View File

@ -145,7 +145,7 @@ void BOARD_ADAPTER::addText( const EDA_TEXT* aText, CONTAINER_2D_BASE* aContaine
void BOARD_ADAPTER::addShape( const PCB_DIMENSION_BASE* aDimension, CONTAINER_2D_BASE* aContainer, void BOARD_ADAPTER::addShape( const PCB_DIMENSION_BASE* aDimension, CONTAINER_2D_BASE* aContainer,
const BOARD_ITEM* aOwner ) const BOARD_ITEM* aOwner )
{ {
addText( &aDimension->Text(), aContainer, aDimension ); addText( aDimension, aContainer, aDimension );
const int linewidth = aDimension->GetLineThickness(); const int linewidth = aDimension->GetLineThickness();

2
common/eda_text.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr * Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2004-2022 KiCad Developers, see change_log.txt for contributors. * Copyright (C) 2004-2023 KiCad Developers, see change_log.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License

56
pcbnew/dialogs/dialog_dimension_properties.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2020 Jon Evans <jon@craftyjon.com> * Copyright (C) 2020 Jon Evans <jon@craftyjon.com>
* Copyright (C) 2020-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2020-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software: you can redistribute it and/or modify it * 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 * under the terms of the GNU General Public License as published by the
@ -227,16 +227,14 @@ bool DIALOG_DIMENSION_PROPERTIES::TransferDataToWindow()
m_cbSuppressZeroes->SetValue( m_dimension->GetSuppressZeroes() ); m_cbSuppressZeroes->SetValue( m_dimension->GetSuppressZeroes() );
PCB_TEXT& text = m_dimension->Text(); m_fontCtrl->SetFontSelection( m_dimension->GetFont() );
m_fontCtrl->SetFontSelection( text.GetFont() ); m_textWidth.SetValue( m_dimension->GetTextSize().x );
m_textHeight.SetValue( m_dimension->GetTextSize().y );
m_textThickness.SetValue( m_dimension->GetTextThickness() );
m_textWidth.SetValue( text.GetTextSize().x ); m_textPosX.SetValue( m_dimension->GetTextPos().x );
m_textHeight.SetValue( text.GetTextSize().y ); m_textPosY.SetValue( m_dimension->GetTextPos().y );
m_textThickness.SetValue( text.GetTextThickness() );
m_textPosX.SetValue( text.GetTextPos().x );
m_textPosY.SetValue( text.GetTextPos().y );
m_cbTextPositionMode->SetSelection( static_cast<int>( m_dimension->GetTextPositionMode() ) ); m_cbTextPositionMode->SetSelection( static_cast<int>( m_dimension->GetTextPositionMode() ) );
if( m_dimension->GetTextPositionMode() != DIM_TEXT_POSITION::MANUAL ) if( m_dimension->GetTextPositionMode() != DIM_TEXT_POSITION::MANUAL )
@ -245,22 +243,22 @@ bool DIALOG_DIMENSION_PROPERTIES::TransferDataToWindow()
m_txtTextPosY->Disable(); m_txtTextPosY->Disable();
} }
EDA_ANGLE orientation = text.GetTextAngle(); EDA_ANGLE orientation = m_dimension->GetTextAngle();
m_orientation.SetAngleValue( orientation.Normalize180() ); m_orientation.SetAngleValue( orientation.Normalize180() );
m_cbTextOrientation->Enable( !m_dimension->GetKeepTextAligned() ); m_cbTextOrientation->Enable( !m_dimension->GetKeepTextAligned() );
m_cbKeepAligned->SetValue( m_dimension->GetKeepTextAligned() ); m_cbKeepAligned->SetValue( m_dimension->GetKeepTextAligned() );
m_bold->Check( text.IsBold() ); m_bold->Check( m_dimension->IsBold() );
m_italic->Check( text.IsItalic() ); m_italic->Check( m_dimension->IsItalic() );
switch ( text.GetHorizJustify() ) switch ( m_dimension->GetHorizJustify() )
{ {
case GR_TEXT_H_ALIGN_LEFT: m_alignLeft->Check( true ); break; case GR_TEXT_H_ALIGN_LEFT: m_alignLeft->Check( true ); break;
case GR_TEXT_H_ALIGN_CENTER: m_alignCenter->Check( true ); break; case GR_TEXT_H_ALIGN_CENTER: m_alignCenter->Check( true ); break;
case GR_TEXT_H_ALIGN_RIGHT: m_alignRight->Check( true ); break; case GR_TEXT_H_ALIGN_RIGHT: m_alignRight->Check( true ); break;
} }
m_mirrored->Check( text.IsMirrored() ); m_mirrored->Check( m_dimension->IsMirrored() );
m_lineThickness.SetValue( m_dimension->GetLineThickness() ); m_lineThickness.SetValue( m_dimension->GetLineThickness() );
m_arrowLength.SetValue( m_dimension->GetArrowLength() ); m_arrowLength.SetValue( m_dimension->GetArrowLength() );
@ -407,38 +405,36 @@ void DIALOG_DIMENSION_PROPERTIES::updateDimensionFromDialog( PCB_DIMENSION_BASE*
aTarget->SetPrecision( m_cbPrecision->GetSelection() ); aTarget->SetPrecision( m_cbPrecision->GetSelection() );
aTarget->SetSuppressZeroes( m_cbSuppressZeroes->GetValue() ); aTarget->SetSuppressZeroes( m_cbSuppressZeroes->GetValue() );
PCB_TEXT& text = aTarget->Text();
DIM_TEXT_POSITION tpm = static_cast<DIM_TEXT_POSITION>( m_cbTextPositionMode->GetSelection() ); DIM_TEXT_POSITION tpm = static_cast<DIM_TEXT_POSITION>( m_cbTextPositionMode->GetSelection() );
aTarget->SetTextPositionMode( tpm ); aTarget->SetTextPositionMode( tpm );
if( tpm == DIM_TEXT_POSITION::MANUAL ) if( tpm == DIM_TEXT_POSITION::MANUAL )
{ {
wxPoint pos( m_textPosX.GetValue(), m_textPosY.GetValue() ); VECTOR2I pos( m_textPosX.GetValue(), m_textPosY.GetValue() );
text.SetPosition( pos ); aTarget->SetTextPos( pos );
} }
aTarget->SetKeepTextAligned( m_cbKeepAligned->GetValue() ); aTarget->SetKeepTextAligned( m_cbKeepAligned->GetValue() );
text.SetTextAngle( m_orientation.GetAngleValue().Normalize() ); aTarget->SetTextAngle( m_orientation.GetAngleValue().Normalize() );
text.SetTextWidth( m_textWidth.GetValue() ); aTarget->SetTextWidth( m_textWidth.GetValue() );
text.SetTextHeight( m_textHeight.GetValue() ); aTarget->SetTextHeight( m_textHeight.GetValue() );
text.SetTextThickness( m_textThickness.GetValue() ); aTarget->SetTextThickness( m_textThickness.GetValue() );
if( m_fontCtrl->HaveFontSelection() ) if( m_fontCtrl->HaveFontSelection() )
text.SetFont( m_fontCtrl->GetFontSelection( m_bold->IsChecked(), m_italic->IsChecked() ) ); aTarget->SetFont( m_fontCtrl->GetFontSelection( m_bold->IsChecked(), m_italic->IsChecked() ) );
text.SetBold( m_bold->IsChecked() ); aTarget->SetBold( m_bold->IsChecked() );
text.SetItalic( m_italic->IsChecked() ); aTarget->SetItalic( m_italic->IsChecked() );
if( m_alignLeft->IsChecked() ) if( m_alignLeft->IsChecked() )
text.SetHorizJustify( GR_TEXT_H_ALIGN_LEFT ); aTarget->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
else if( m_alignCenter->IsChecked() ) else if( m_alignCenter->IsChecked() )
text.SetHorizJustify( GR_TEXT_H_ALIGN_CENTER ); aTarget->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
else else
text.SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT ); aTarget->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
text.SetMirrored( m_mirrored->IsChecked() ); aTarget->SetMirrored( m_mirrored->IsChecked() );
aTarget->SetLineThickness( m_lineThickness.GetValue() ); aTarget->SetLineThickness( m_lineThickness.GetValue() );
aTarget->SetArrowLength( m_arrowLength.GetValue() ); aTarget->SetArrowLength( m_arrowLength.GetValue() );
@ -457,5 +453,5 @@ void DIALOG_DIMENSION_PROPERTIES::updateDimensionFromDialog( PCB_DIMENSION_BASE*
void DIALOG_DIMENSION_PROPERTIES::updatePreviewText() void DIALOG_DIMENSION_PROPERTIES::updatePreviewText()
{ {
updateDimensionFromDialog( m_previewDimension ); updateDimensionFromDialog( m_previewDimension );
m_staticTextPreview->SetLabel( m_previewDimension->Text().GetShownText() ); m_staticTextPreview->SetLabel( m_previewDimension->GetShownText() );
} }

3
pcbnew/dialogs/dialog_global_edit_text_and_graphics.cpp
View File

@ -332,9 +332,6 @@ void DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS::processItem( BOARD_COMMIT& aCommit, B
PCB_SHAPE* shape = dynamic_cast<PCB_SHAPE*>( aItem ); PCB_SHAPE* shape = dynamic_cast<PCB_SHAPE*>( aItem );
PCB_DIMENSION_BASE* dimension = dynamic_cast<PCB_DIMENSION_BASE*>( aItem ); PCB_DIMENSION_BASE* dimension = dynamic_cast<PCB_DIMENSION_BASE*>( aItem );
if( dimension )
edaText = &dimension->Text();
if( m_setToSpecifiedValues->GetValue() ) if( m_setToSpecifiedValues->GetValue() )
{ {
if( m_LayerCtrl->GetLayerSelection() != UNDEFINED_LAYER ) if( m_LayerCtrl->GetLayerSelection() != UNDEFINED_LAYER )

381
pcbnew/pcb_dimension.cpp
View File

@ -4,7 +4,7 @@
* Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr * Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com> * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2012 Wayne Stambaugh <stambaughw@gmail.com> * Copyright (C) 2012 Wayne Stambaugh <stambaughw@gmail.com>
* Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -42,7 +42,7 @@ static const EDA_ANGLE s_arrowAngle( 27.5, DEGREES_T );
PCB_DIMENSION_BASE::PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) : PCB_DIMENSION_BASE::PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) :
BOARD_ITEM( aParent, aType ), PCB_TEXT( aParent, aType ),
m_overrideTextEnabled( false ), m_overrideTextEnabled( false ),
m_units( EDA_UNITS::INCHES ), m_units( EDA_UNITS::INCHES ),
m_autoUnits( false ), m_autoUnits( false ),
@ -54,20 +54,13 @@ PCB_DIMENSION_BASE::PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) :
m_extensionOffset( 0 ), m_extensionOffset( 0 ),
m_textPosition( DIM_TEXT_POSITION::OUTSIDE ), m_textPosition( DIM_TEXT_POSITION::OUTSIDE ),
m_keepTextAligned( true ), m_keepTextAligned( true ),
m_text( aParent ), m_measuredValue( 0 ),
m_measuredValue( 0 ) m_inClearRenderCache( false )
{ {
m_layer = Dwgs_User; m_layer = Dwgs_User;
} }
void PCB_DIMENSION_BASE::SetParent( EDA_ITEM* aParent )
{
BOARD_ITEM::SetParent( aParent );
m_text.SetParent( aParent );
}
void PCB_DIMENSION_BASE::updateText() void PCB_DIMENSION_BASE::updateText()
{ {
wxString text = m_overrideTextEnabled ? m_valueString : GetValueText(); wxString text = m_overrideTextEnabled ? m_valueString : GetValueText();
@ -89,7 +82,23 @@ void PCB_DIMENSION_BASE::updateText()
text.Prepend( m_prefix ); text.Prepend( m_prefix );
text.Append( m_suffix ); text.Append( m_suffix );
m_text.SetText( text ); SetText( text );
}
void PCB_DIMENSION_BASE::ClearRenderCache()
{
PCB_TEXT::ClearRenderCache();
// We use EDA_TEXT::ClearRenderCache() as a signal that the properties of the EDA_TEXT
// have changed and we may need to update the dimension text
if( !m_inClearRenderCache )
{
m_inClearRenderCache = true;
updateText();
m_inClearRenderCache = false;
}
} }
@ -193,29 +202,9 @@ void PCB_DIMENSION_BASE::SetUnitsMode( DIM_UNITS_MODE aMode )
} }
void PCB_DIMENSION_BASE::SetText( const wxString& aNewText )
{
m_valueString = aNewText;
updateText();
}
const wxString PCB_DIMENSION_BASE::GetText() const
{
return m_text.GetText();
}
void PCB_DIMENSION_BASE::SetLayer( PCB_LAYER_ID aLayer )
{
m_layer = aLayer;
m_text.SetLayer( aLayer );
}
void PCB_DIMENSION_BASE::Move( const VECTOR2I& offset ) void PCB_DIMENSION_BASE::Move( const VECTOR2I& offset )
{ {
m_text.Offset( offset ); PCB_TEXT::Offset( offset );
m_start += offset; m_start += offset;
m_end += offset; m_end += offset;
@ -226,15 +215,15 @@ void PCB_DIMENSION_BASE::Move( const VECTOR2I& offset )
void PCB_DIMENSION_BASE::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle ) void PCB_DIMENSION_BASE::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
{ {
EDA_ANGLE newAngle = m_text.GetTextAngle() + aAngle; EDA_ANGLE newAngle = GetTextAngle() + aAngle;
newAngle.Normalize(); newAngle.Normalize();
m_text.SetTextAngle( newAngle ); SetTextAngle( newAngle );
VECTOR2I pt = m_text.GetTextPos(); VECTOR2I pt = GetTextPos();
RotatePoint( pt, aRotCentre, aAngle ); RotatePoint( pt, aRotCentre, aAngle );
m_text.SetTextPos( pt ); SetTextPos( pt );
RotatePoint( m_start, aRotCentre, aAngle ); RotatePoint( m_start, aRotCentre, aAngle );
RotatePoint( m_end, aRotCentre, aAngle ); RotatePoint( m_end, aRotCentre, aAngle );
@ -254,7 +243,7 @@ void PCB_DIMENSION_BASE::Flip( const VECTOR2I& aCentre, bool aFlipLeftRight )
void PCB_DIMENSION_BASE::Mirror( const VECTOR2I& axis_pos, bool aMirrorLeftRight ) void PCB_DIMENSION_BASE::Mirror( const VECTOR2I& axis_pos, bool aMirrorLeftRight )
{ {
int axis = aMirrorLeftRight ? axis_pos.x : axis_pos.y; int axis = aMirrorLeftRight ? axis_pos.x : axis_pos.y;
VECTOR2I newPos = m_text.GetTextPos(); VECTOR2I newPos = GetTextPos();
#define INVERT( pos ) ( ( pos ) = axis - ( ( pos ) - axis ) ) #define INVERT( pos ) ( ( pos ) = axis - ( ( pos ) - axis ) )
if( aMirrorLeftRight ) if( aMirrorLeftRight )
@ -262,10 +251,10 @@ void PCB_DIMENSION_BASE::Mirror( const VECTOR2I& axis_pos, bool aMirrorLeftRight
else else
INVERT( newPos.y ); INVERT( newPos.y );
m_text.SetTextPos( newPos ); SetTextPos( newPos );
// invert angle // invert angle
m_text.SetTextAngle( -m_text.GetTextAngle() ); SetTextAngle( -GetTextAngle() );
if( aMirrorLeftRight ) if( aMirrorLeftRight )
{ {
@ -279,7 +268,7 @@ void PCB_DIMENSION_BASE::Mirror( const VECTOR2I& axis_pos, bool aMirrorLeftRight
} }
if( ( GetLayerSet() & LSET::SideSpecificMask() ).any() ) if( ( GetLayerSet() & LSET::SideSpecificMask() ).any() )
m_text.SetMirrored( !m_text.IsMirrored() ); SetMirrored( !IsMirrored() );
Update(); Update();
} }
@ -293,7 +282,7 @@ void PCB_DIMENSION_BASE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame,
wxCHECK_RET( m_parent != nullptr, wxT( "PCB_TEXT::GetMsgPanelInfo() m_Parent is NULL." ) ); wxCHECK_RET( m_parent != nullptr, wxT( "PCB_TEXT::GetMsgPanelInfo() m_Parent is NULL." ) );
aList.emplace_back( _( "Dimension" ), m_text.GetShownText() ); aList.emplace_back( _( "Dimension" ), GetShownText() );
aList.emplace_back( _( "Prefix" ), GetPrefix() ); aList.emplace_back( _( "Prefix" ), GetPrefix() );
@ -326,13 +315,10 @@ void PCB_DIMENSION_BASE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame,
aList.emplace_back( _( "Units" ), EDA_UNIT_UTILS::GetLabel( GetUnits() ) ); aList.emplace_back( _( "Units" ), EDA_UNIT_UTILS::GetLabel( GetUnits() ) );
aList.emplace_back( _( "Font" ), m_text.GetFont() ? m_text.GetFont()->GetName() : _( "Default" ) ); aList.emplace_back( _( "Font" ), GetFont() ? GetFont()->GetName() : _( "Default" ) );
aList.emplace_back( _( "Text Thickness" ), aList.emplace_back( _( "Text Thickness" ), unitsProvider.MessageTextFromValue( GetTextThickness() ) );
unitsProvider.MessageTextFromValue( m_text.GetTextThickness() ) ); aList.emplace_back( _( "Text Width" ), unitsProvider.MessageTextFromValue( GetTextWidth() ) );
aList.emplace_back( _( "Text Width" ), aList.emplace_back( _( "Text Height" ), unitsProvider.MessageTextFromValue( GetTextHeight() ) );
unitsProvider.MessageTextFromValue( m_text.GetTextWidth() ) );
aList.emplace_back( _( "Text Height" ),
unitsProvider.MessageTextFromValue( m_text.GetTextHeight() ) );
ORIGIN_TRANSFORMS originTransforms = aFrame->GetOriginTransforms(); ORIGIN_TRANSFORMS originTransforms = aFrame->GetOriginTransforms();
@ -370,7 +356,7 @@ std::shared_ptr<SHAPE> PCB_DIMENSION_BASE::GetEffectiveShape( PCB_LAYER_ID aLaye
{ {
std::shared_ptr<SHAPE_COMPOUND> effectiveShape = std::make_shared<SHAPE_COMPOUND>(); std::shared_ptr<SHAPE_COMPOUND> effectiveShape = std::make_shared<SHAPE_COMPOUND>();
effectiveShape->AddShape( Text().GetEffectiveTextShape()->Clone() ); effectiveShape->AddShape( GetEffectiveTextShape()->Clone() );
for( const std::shared_ptr<SHAPE>& shape : GetShapes() ) for( const std::shared_ptr<SHAPE>& shape : GetShapes() )
effectiveShape->AddShape( shape->Clone() ); effectiveShape->AddShape( shape->Clone() );
@ -381,7 +367,7 @@ std::shared_ptr<SHAPE> PCB_DIMENSION_BASE::GetEffectiveShape( PCB_LAYER_ID aLaye
bool PCB_DIMENSION_BASE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const bool PCB_DIMENSION_BASE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
{ {
if( m_text.TextHitTest( aPosition ) ) if( TextHitTest( aPosition ) )
return true; return true;
int dist_max = aAccuracy + ( m_lineThickness / 2 ); int dist_max = aAccuracy + ( m_lineThickness / 2 );
@ -420,7 +406,7 @@ const BOX2I PCB_DIMENSION_BASE::GetBoundingBox() const
BOX2I bBox; BOX2I bBox;
int xmin, xmax, ymin, ymax; int xmin, xmax, ymin, ymax;
bBox = m_text.GetTextBox(); bBox = GetTextBox();
xmin = bBox.GetX(); xmin = bBox.GetX();
xmax = bBox.GetRight(); xmax = bBox.GetRight();
ymin = bBox.GetY(); ymin = bBox.GetY();
@ -459,7 +445,7 @@ const BOX2I PCB_DIMENSION_BASE::ViewBBox() const
{ {
BOX2I dimBBox = BOX2I( VECTOR2I( GetBoundingBox().GetPosition() ), BOX2I dimBBox = BOX2I( VECTOR2I( GetBoundingBox().GetPosition() ),
VECTOR2I( GetBoundingBox().GetSize() ) ); VECTOR2I( GetBoundingBox().GetSize() ) );
dimBBox.Merge( m_text.ViewBBox() ); dimBBox.Merge( PCB_TEXT::ViewBBox() );
return dimBBox; return dimBBox;
} }
@ -639,8 +625,7 @@ void PCB_DIM_ALIGNED::updateGeometry()
// Now that we have the text updated, we can determine how to draw the crossbar. // Now that we have the text updated, we can determine how to draw the crossbar.
// First we need to create an appropriate bounding polygon to collide with // First we need to create an appropriate bounding polygon to collide with
BOX2I textBox = m_text.GetTextBox().Inflate( m_text.GetTextWidth() / 2, BOX2I textBox = GetTextBox().Inflate( GetTextWidth() / 2, - GetEffectiveTextPenWidth() );
- m_text.GetEffectiveTextPenWidth() );
SHAPE_POLY_SET polyBox; SHAPE_POLY_SET polyBox;
polyBox.NewOutline(); polyBox.NewOutline();
@ -648,7 +633,7 @@ void PCB_DIM_ALIGNED::updateGeometry()
polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y ); polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y );
polyBox.Append( textBox.GetEnd() ); polyBox.Append( textBox.GetEnd() );
polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y ); polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y );
polyBox.Rotate( m_text.GetTextAngle(), textBox.GetCenter() ); polyBox.Rotate( GetTextAngle(), textBox.GetCenter() );
// The ideal crossbar, if the text doesn't collide // The ideal crossbar, if the text doesn't collide
SEG crossbar( m_crossBarStart, m_crossBarEnd ); SEG crossbar( m_crossBarStart, m_crossBarEnd );
@ -688,7 +673,7 @@ void PCB_DIM_ALIGNED::updateText()
if( m_textPosition == DIM_TEXT_POSITION::OUTSIDE ) if( m_textPosition == DIM_TEXT_POSITION::OUTSIDE )
{ {
int textOffsetDistance = m_text.GetEffectiveTextPenWidth() + m_text.GetTextHeight(); int textOffsetDistance = GetEffectiveTextPenWidth() + GetTextHeight();
EDA_ANGLE rotation; EDA_ANGLE rotation;
if( crossbarCenter.x == 0 ) if( crossbarCenter.x == 0 )
@ -702,11 +687,11 @@ void PCB_DIM_ALIGNED::updateText()
RotatePoint( textOffset, rotation ); RotatePoint( textOffset, rotation );
textOffset = crossbarCenter + textOffset.Resize( textOffsetDistance ); textOffset = crossbarCenter + textOffset.Resize( textOffsetDistance );
m_text.SetTextPos( m_crossBarStart + textOffset ); SetTextPos( m_crossBarStart + textOffset );
} }
else if( m_textPosition == DIM_TEXT_POSITION::INLINE ) else if( m_textPosition == DIM_TEXT_POSITION::INLINE )
{ {
m_text.SetTextPos( m_crossBarStart + crossbarCenter ); SetTextPos( m_crossBarStart + crossbarCenter );
} }
if( m_keepTextAligned ) if( m_keepTextAligned )
@ -717,7 +702,7 @@ void PCB_DIM_ALIGNED::updateText()
if( textAngle > ANGLE_90 && textAngle <= ANGLE_270 ) if( textAngle > ANGLE_90 && textAngle <= ANGLE_270 )
textAngle -= ANGLE_180; textAngle -= ANGLE_180;
m_text.SetTextAngle( textAngle ); SetTextAngle( textAngle );
} }
PCB_DIMENSION_BASE::updateText(); PCB_DIMENSION_BASE::updateText();
@ -822,8 +807,7 @@ void PCB_DIM_ORTHOGONAL::updateGeometry()
// Now that we have the text updated, we can determine how to draw the crossbar. // Now that we have the text updated, we can determine how to draw the crossbar.
// First we need to create an appropriate bounding polygon to collide with // First we need to create an appropriate bounding polygon to collide with
BOX2I textBox = m_text.GetTextBox().Inflate( m_text.GetTextWidth() / 2, BOX2I textBox = GetTextBox().Inflate( GetTextWidth() / 2, GetEffectiveTextPenWidth() );
m_text.GetEffectiveTextPenWidth() );
SHAPE_POLY_SET polyBox; SHAPE_POLY_SET polyBox;
polyBox.NewOutline(); polyBox.NewOutline();
@ -831,7 +815,7 @@ void PCB_DIM_ORTHOGONAL::updateGeometry()
polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y ); polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y );
polyBox.Append( textBox.GetEnd() ); polyBox.Append( textBox.GetEnd() );
polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y ); polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y );
polyBox.Rotate( m_text.GetTextAngle(), textBox.GetCenter() ); polyBox.Rotate( GetTextAngle(), textBox.GetCenter() );
// The ideal crossbar, if the text doesn't collide // The ideal crossbar, if the text doesn't collide
SEG crossbar( m_crossBarStart, m_crossBarEnd ); SEG crossbar( m_crossBarStart, m_crossBarEnd );
@ -872,7 +856,7 @@ void PCB_DIM_ORTHOGONAL::updateText()
if( m_textPosition == DIM_TEXT_POSITION::OUTSIDE ) if( m_textPosition == DIM_TEXT_POSITION::OUTSIDE )
{ {
int textOffsetDistance = m_text.GetEffectiveTextPenWidth() + m_text.GetTextHeight(); int textOffsetDistance = GetEffectiveTextPenWidth() + GetTextHeight();
VECTOR2I textOffset; VECTOR2I textOffset;
@ -883,22 +867,22 @@ void PCB_DIM_ORTHOGONAL::updateText()
textOffset += crossbarCenter; textOffset += crossbarCenter;
m_text.SetTextPos( m_crossBarStart + textOffset ); SetTextPos( m_crossBarStart + textOffset );
} }
else if( m_textPosition == DIM_TEXT_POSITION::INLINE ) else if( m_textPosition == DIM_TEXT_POSITION::INLINE )
{ {
m_text.SetTextPos( m_crossBarStart + crossbarCenter ); SetTextPos( m_crossBarStart + crossbarCenter );
} }
if( m_keepTextAligned ) if( m_keepTextAligned )
{ {
if( abs( crossbarCenter.x ) > abs( crossbarCenter.y ) ) if( abs( crossbarCenter.x ) > abs( crossbarCenter.y ) )
m_text.SetTextAngle( ANGLE_HORIZONTAL ); SetTextAngle( ANGLE_HORIZONTAL );
else else
m_text.SetTextAngle( ANGLE_VERTICAL ); SetTextAngle( ANGLE_VERTICAL );
} }
PCB_DIMENSION_BASE::updateText(); PCB_DIM_ALIGNED::updateText();
} }
@ -959,7 +943,7 @@ PCB_DIM_LEADER::PCB_DIM_LEADER( BOARD_ITEM* aParent, bool aInFP ) :
m_overrideTextEnabled = true; m_overrideTextEnabled = true;
m_keepTextAligned = false; m_keepTextAligned = false;
SetText( _( "Leader" ) ); SetOverrideText( _( "Leader" ) );
} }
@ -996,8 +980,7 @@ void PCB_DIM_LEADER::updateGeometry()
// Now that we have the text updated, we can determine how to draw the second line // Now that we have the text updated, we can determine how to draw the second line
// First we need to create an appropriate bounding polygon to collide with // First we need to create an appropriate bounding polygon to collide with
BOX2I textBox = m_text.GetTextBox().Inflate( m_text.GetTextWidth() / 2, BOX2I textBox = GetTextBox().Inflate( GetTextWidth() / 2, GetEffectiveTextPenWidth() * 2 );
m_text.GetEffectiveTextPenWidth() * 2 );
SHAPE_POLY_SET polyBox; SHAPE_POLY_SET polyBox;
polyBox.NewOutline(); polyBox.NewOutline();
@ -1005,20 +988,20 @@ void PCB_DIM_LEADER::updateGeometry()
polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y ); polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y );
polyBox.Append( textBox.GetEnd() ); polyBox.Append( textBox.GetEnd() );
polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y ); polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y );
polyBox.Rotate( m_text.GetTextAngle(), textBox.GetCenter() ); polyBox.Rotate( GetTextAngle(), textBox.GetCenter() );
VECTOR2I firstLine( m_end - m_start ); VECTOR2I firstLine( m_end - m_start );
VECTOR2I start( m_start ); VECTOR2I start( m_start );
start += firstLine.Resize( m_extensionOffset ); start += firstLine.Resize( m_extensionOffset );
SEG arrowSeg( m_start, m_end ); SEG arrowSeg( m_start, m_end );
SEG textSeg( m_end, m_text.GetPosition() ); SEG textSeg( m_end, GetTextPos() );
OPT_VECTOR2I arrowSegEnd; OPT_VECTOR2I arrowSegEnd;
OPT_VECTOR2I textSegEnd; OPT_VECTOR2I textSegEnd;
if( m_textBorder == DIM_TEXT_BORDER::CIRCLE ) if( m_textBorder == DIM_TEXT_BORDER::CIRCLE )
{ {
double penWidth = m_text.GetEffectiveTextPenWidth() / 2.0; double penWidth = GetEffectiveTextPenWidth() / 2.0;
double radius = ( textBox.GetWidth() / 2.0 ) - penWidth; double radius = ( textBox.GetWidth() / 2.0 ) - penWidth;
CIRCLE circle( textBox.GetCenter(), radius ); CIRCLE circle( textBox.GetCenter(), radius );
@ -1060,7 +1043,7 @@ void PCB_DIM_LEADER::updateGeometry()
case DIM_TEXT_BORDER::CIRCLE: case DIM_TEXT_BORDER::CIRCLE:
{ {
double penWidth = m_text.GetEffectiveTextPenWidth() / 2.0; double penWidth = GetEffectiveTextPenWidth() / 2.0;
double radius = ( textBox.GetWidth() / 2.0 ) - penWidth; double radius = ( textBox.GetWidth() / 2.0 ) - penWidth;
m_shapes.emplace_back( new SHAPE_CIRCLE( textBox.GetCenter(), radius ) ); m_shapes.emplace_back( new SHAPE_CIRCLE( textBox.GetCenter(), radius ) );
@ -1077,9 +1060,26 @@ void PCB_DIM_LEADER::updateGeometry()
} }
void PCB_DIM_LEADER::ClearRenderCache()
{
PCB_DIMENSION_BASE::ClearRenderCache();
// We use EDA_TEXT::ClearRenderCache() as a signal that the properties of the EDA_TEXT
// have changed and we may need to update the dimension text
if( !m_inClearRenderCache )
{
m_inClearRenderCache = true;
updateText();
updateGeometry();
m_inClearRenderCache = false;
}
}
void PCB_DIM_LEADER::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) void PCB_DIM_LEADER::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{ {
aList.emplace_back( _( "Leader" ), m_text.GetShownText() ); aList.emplace_back( _( "Leader" ), GetShownText() );
ORIGIN_TRANSFORMS originTransforms = aFrame->GetOriginTransforms(); ORIGIN_TRANSFORMS originTransforms = aFrame->GetOriginTransforms();
@ -1143,7 +1143,7 @@ void PCB_DIM_RADIAL::updateText()
{ {
if( m_keepTextAligned ) if( m_keepTextAligned )
{ {
VECTOR2I textLine( Text().GetPosition() - GetKnee() ); VECTOR2I textLine( GetTextPos() - GetKnee() );
EDA_ANGLE textAngle = FULL_CIRCLE - EDA_ANGLE( textLine ); EDA_ANGLE textAngle = FULL_CIRCLE - EDA_ANGLE( textLine );
textAngle.Normalize(); textAngle.Normalize();
@ -1154,7 +1154,7 @@ void PCB_DIM_RADIAL::updateText()
// Round to nearest degree // Round to nearest degree
textAngle = EDA_ANGLE( KiROUND( textAngle.AsDegrees() ), DEGREES_T ); textAngle = EDA_ANGLE( KiROUND( textAngle.AsDegrees() ), DEGREES_T );
m_text.SetTextAngle( textAngle ); SetTextAngle( textAngle );
} }
PCB_DIMENSION_BASE::updateText(); PCB_DIMENSION_BASE::updateText();
@ -1185,8 +1185,7 @@ void PCB_DIM_RADIAL::updateGeometry()
// Now that we have the text updated, we can determine how to draw the second line // Now that we have the text updated, we can determine how to draw the second line
// First we need to create an appropriate bounding polygon to collide with // First we need to create an appropriate bounding polygon to collide with
BOX2I textBox = m_text.GetTextBox().Inflate( m_text.GetTextWidth() / 2, BOX2I textBox = GetTextBox().Inflate( GetTextWidth() / 2, GetEffectiveTextPenWidth() );
m_text.GetEffectiveTextPenWidth() );
SHAPE_POLY_SET polyBox; SHAPE_POLY_SET polyBox;
polyBox.NewOutline(); polyBox.NewOutline();
@ -1194,13 +1193,13 @@ void PCB_DIM_RADIAL::updateGeometry()
polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y ); polyBox.Append( textBox.GetOrigin().x, textBox.GetEnd().y );
polyBox.Append( textBox.GetEnd() ); polyBox.Append( textBox.GetEnd() );
polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y ); polyBox.Append( textBox.GetEnd().x, textBox.GetOrigin().y );
polyBox.Rotate( m_text.GetTextAngle(), textBox.GetCenter() ); polyBox.Rotate( GetTextAngle(), textBox.GetCenter() );
VECTOR2I radial( m_end - m_start ); VECTOR2I radial( m_end - m_start );
radial = radial.Resize( m_leaderLength ); radial = radial.Resize( m_leaderLength );
SEG arrowSeg( m_end, m_end + radial ); SEG arrowSeg( m_end, m_end + radial );
SEG textSeg( arrowSeg.B, m_text.GetPosition() ); SEG textSeg( arrowSeg.B, GetTextPos() );
OPT_VECTOR2I arrowSegEnd = segPolyIntersection( polyBox, arrowSeg ); OPT_VECTOR2I arrowSegEnd = segPolyIntersection( polyBox, arrowSeg );
OPT_VECTOR2I textSegEnd = segPolyIntersection( polyBox, textSeg ); OPT_VECTOR2I textSegEnd = segPolyIntersection( polyBox, textSeg );
@ -1297,14 +1296,228 @@ static struct DIMENSION_DESC
{ {
DIMENSION_DESC() DIMENSION_DESC()
{ {
ENUM_MAP<DIM_UNITS_FORMAT>::Instance()
.Map( DIM_UNITS_FORMAT::NO_SUFFIX, _HKI( "1234.0" ) )
.Map( DIM_UNITS_FORMAT::BARE_SUFFIX, _HKI( "1234.0 mm" ) )
.Map( DIM_UNITS_FORMAT::PAREN_SUFFIX, _HKI( "1234.0 (mm)" ) );
ENUM_MAP<DIM_UNITS_MODE>::Instance()
.Map( DIM_UNITS_MODE::INCHES, _HKI( "Inches" ) )
.Map( DIM_UNITS_MODE::MILS, _HKI( "Mils" ) )
.Map( DIM_UNITS_MODE::MILLIMETRES, _HKI( "Millimeters" ) )
.Map( DIM_UNITS_MODE::AUTOMATIC, _HKI( "Automatic" ) );
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance(); PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIMENSION_BASE ); REGISTER_TYPE( PCB_DIMENSION_BASE );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIMENSION_BASE, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIMENSION_BASE, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIMENSION_BASE, EDA_TEXT> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIMENSION_BASE ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIMENSION_BASE ), TYPE_HASH( BOARD_ITEM ) ); propMgr.InheritsAfter( TYPE_HASH( PCB_DIMENSION_BASE ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIMENSION_BASE ), TYPE_HASH( EDA_TEXT ) );
const wxString groupDimension = _HKI( "Dimension Properties" ); const wxString groupDimension = _HKI( "Dimension Properties" );
propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, wxString>( _HKI( "Prefix" ),
&PCB_DIMENSION_BASE::ChangePrefix, &PCB_DIMENSION_BASE::GetPrefix ),
groupDimension );
propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, wxString>( _HKI( "Suffix" ),
&PCB_DIMENSION_BASE::ChangeSuffix, &PCB_DIMENSION_BASE::GetSuffix ),
groupDimension );
propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, wxString>( _HKI( "Override Text" ), propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, wxString>( _HKI( "Override Text" ),
&PCB_DIMENSION_BASE::SetOverrideText, &PCB_DIMENSION_BASE::GetOverrideText ), &PCB_DIMENSION_BASE::ChangeOverrideText, &PCB_DIMENSION_BASE::GetOverrideText ),
groupDimension );
propMgr.AddProperty( new PROPERTY_ENUM<PCB_DIMENSION_BASE, DIM_UNITS_MODE>( _HKI( "Units" ),
&PCB_DIMENSION_BASE::ChangeUnitsMode, &PCB_DIMENSION_BASE::GetUnitsMode ),
groupDimension );
propMgr.AddProperty( new PROPERTY_ENUM<PCB_DIMENSION_BASE, DIM_UNITS_FORMAT>( _HKI( "Units Format" ),
&PCB_DIMENSION_BASE::ChangeUnitsFormat, &PCB_DIMENSION_BASE::GetUnitsFormat ),
groupDimension );
propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, int>( _HKI( "Precision" ),
&PCB_DIMENSION_BASE::ChangePrecision, &PCB_DIMENSION_BASE::GetPrecision ),
groupDimension );
propMgr.AddProperty( new PROPERTY<PCB_DIMENSION_BASE, bool>( _HKI( "Suppress Trailing Zeroes" ),
&PCB_DIMENSION_BASE::ChangeSuppressZeroes, &PCB_DIMENSION_BASE::GetSuppressZeroes ),
groupDimension ); groupDimension );
} }
} _DIMENSION_DESC; } _DIMENSION_DESC;
ENUM_TO_WXANY( DIM_UNITS_FORMAT )
ENUM_TO_WXANY( DIM_UNITS_MODE )
static struct ALIGNED_DIMENSION_DESC
{
ALIGNED_DIMENSION_DESC()
{
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIM_ALIGNED );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ALIGNED, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ALIGNED, EDA_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ALIGNED, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ALIGNED, PCB_DIMENSION_BASE> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( PCB_DIMENSION_BASE ) );
const wxString groupDimension = _HKI( "Dimension Properties" );
propMgr.AddProperty( new PROPERTY<PCB_DIM_ALIGNED, int>( _HKI( "Crossbar Height" ),
&PCB_DIM_ALIGNED::ChangeHeight, &PCB_DIM_ALIGNED::GetHeight,
PROPERTY_DISPLAY::PT_SIZE ),
groupDimension );
propMgr.AddProperty( new PROPERTY<PCB_DIM_ALIGNED, int>( _HKI( "Extension Line Overshoot" ),
&PCB_DIM_ALIGNED::ChangeExtensionHeight, &PCB_DIM_ALIGNED::GetExtensionHeight,
PROPERTY_DISPLAY::PT_SIZE ),
groupDimension );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Visible" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Knockout" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Hyperlink" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
} ALIGNED_DIMENSION_DESC;
static struct ORTHOGONAL_DIMENSION_DESC
{
ORTHOGONAL_DIMENSION_DESC()
{
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIM_ORTHOGONAL );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ORTHOGONAL, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ORTHOGONAL, EDA_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ORTHOGONAL, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ORTHOGONAL, PCB_DIMENSION_BASE> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_ORTHOGONAL, PCB_DIM_ALIGNED> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ORTHOGONAL ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ORTHOGONAL ), TYPE_HASH( EDA_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ORTHOGONAL ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ORTHOGONAL ), TYPE_HASH( PCB_DIMENSION_BASE ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_ORTHOGONAL ), TYPE_HASH( PCB_DIM_ALIGNED ) );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Visible" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Knockout" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Hyperlink" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
} ORTHOGONAL_DIMENSION_DESC;
static struct RADIAL_DIMENSION_DESC
{
RADIAL_DIMENSION_DESC()
{
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIM_RADIAL );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_RADIAL, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_RADIAL, EDA_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_RADIAL, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_RADIAL, PCB_DIMENSION_BASE> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_RADIAL ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_RADIAL ), TYPE_HASH( EDA_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_RADIAL ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_RADIAL ), TYPE_HASH( PCB_DIMENSION_BASE ) );
const wxString groupDimension = _HKI( "Dimension Properties" );
propMgr.AddProperty( new PROPERTY<PCB_DIM_RADIAL, int>( _HKI( "Leader Length" ),
&PCB_DIM_RADIAL::ChangeLeaderLength, &PCB_DIM_RADIAL::GetLeaderLength,
PROPERTY_DISPLAY::PT_SIZE ),
groupDimension );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Visible" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Knockout" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_ALIGNED ), TYPE_HASH( EDA_TEXT ),
_HKI( "Hyperlink" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
} RADIAL_DIMENSION_DESC;
static struct LEADER_DIMENSION_DESC
{
LEADER_DIMENSION_DESC()
{
ENUM_MAP<DIM_TEXT_BORDER>::Instance()
.Map( DIM_TEXT_BORDER::NONE, _HKI( "None" ) )
.Map( DIM_TEXT_BORDER::RECTANGLE, _HKI( "Rectangle" ) )
.Map( DIM_TEXT_BORDER::CIRCLE, _HKI( "Circle" ) );
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIM_LEADER );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_LEADER, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_LEADER, EDA_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_LEADER, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_LEADER, PCB_DIMENSION_BASE> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( EDA_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( PCB_DIMENSION_BASE ) );
const wxString groupDimension = _HKI( "Dimension Properties" );
propMgr.AddProperty( new PROPERTY_ENUM<PCB_DIM_LEADER, DIM_TEXT_BORDER>( _HKI( "Text Frame" ),
&PCB_DIM_LEADER::ChangeTextBorder, &PCB_DIM_LEADER::GetTextBorder ),
groupDimension );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Visible" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Knockout" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_LEADER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Hyperlink" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
} LEADER_DIMENSION_DESC;
ENUM_TO_WXANY( DIM_TEXT_BORDER )
static struct CENTER_DIMENSION_DESC
{
CENTER_DIMENSION_DESC()
{
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( PCB_DIM_CENTER );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_CENTER, BOARD_ITEM> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_CENTER, EDA_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_CENTER, PCB_TEXT> );
propMgr.AddTypeCast( new TYPE_CAST<PCB_DIM_CENTER, PCB_DIMENSION_BASE> );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( BOARD_ITEM ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( EDA_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( PCB_TEXT ) );
propMgr.InheritsAfter( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( PCB_DIMENSION_BASE ) );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Visible" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Knockout" ),
[]( INSPECTABLE* aItem ) { return false; } );
propMgr.OverrideAvailability( TYPE_HASH( PCB_DIM_CENTER ), TYPE_HASH( EDA_TEXT ),
_HKI( "Hyperlink" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
} CENTER_DIMENSION_DESC;

106
pcbnew/pcb_dimension.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com * Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
* Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -92,7 +92,7 @@ enum class DIM_TEXT_BORDER
* - "crossbar" refers to the perpendicular line (usually with arrows at each end) between feature * - "crossbar" refers to the perpendicular line (usually with arrows at each end) between feature
* lines on linear dimensions * lines on linear dimensions
*/ */
class PCB_DIMENSION_BASE : public BOARD_ITEM class PCB_DIMENSION_BASE : public PCB_TEXT
{ {
public: public:
PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIMENSION_T ); PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIMENSION_T );
@ -111,8 +111,6 @@ public:
return false; return false;
} }
void SetParent( EDA_ITEM* aParent ) override;
/** /**
* The dimension's origin is the first feature point for the dimension. Every dimension has * The dimension's origin is the first feature point for the dimension. Every dimension has
* one or more feature points, so every dimension has at least an origin. * one or more feature points, so every dimension has at least an origin.
@ -133,6 +131,13 @@ public:
wxString GetOverrideText() const { return m_valueString; } wxString GetOverrideText() const { return m_valueString; }
void SetOverrideText( const wxString& aValue ) { m_valueString = aValue; } void SetOverrideText( const wxString& aValue ) { m_valueString = aValue; }
void ChangeOverrideText( const wxString& aValue )
{
SetOverrideTextEnabled( true );
SetOverrideText( aValue );
updateText();
}
int GetMeasuredValue() const { return m_measuredValue; } int GetMeasuredValue() const { return m_measuredValue; }
// KiCad normally calculates the measured value but some importers need to set it. // KiCad normally calculates the measured value but some importers need to set it.
@ -155,26 +160,62 @@ public:
wxString GetPrefix() const { return m_prefix; } wxString GetPrefix() const { return m_prefix; }
void SetPrefix( const wxString& aPrefix ); void SetPrefix( const wxString& aPrefix );
void ChangePrefix( const wxString& aPrefix )
{
SetPrefix( aPrefix );
updateText();
}
wxString GetSuffix() const { return m_suffix; } wxString GetSuffix() const { return m_suffix; }
void SetSuffix( const wxString& aSuffix ); void SetSuffix( const wxString& aSuffix );
void ChangeSuffix( const wxString& aSuffix )
{
SetSuffix( aSuffix );
updateText();
}
EDA_UNITS GetUnits() const { return m_units; } EDA_UNITS GetUnits() const { return m_units; }
void SetUnits( EDA_UNITS aUnits ); void SetUnits( EDA_UNITS aUnits );
DIM_UNITS_MODE GetUnitsMode() const; DIM_UNITS_MODE GetUnitsMode() const;
void SetUnitsMode( DIM_UNITS_MODE aMode ); void SetUnitsMode( DIM_UNITS_MODE aMode );
void ChangeUnitsMode( DIM_UNITS_MODE aMode )
{
SetUnitsMode( aMode );
updateText();
}
void SetAutoUnits( bool aAuto = true ) { m_autoUnits = aAuto; } void SetAutoUnits( bool aAuto = true ) { m_autoUnits = aAuto; }
DIM_UNITS_FORMAT GetUnitsFormat() const { return m_unitsFormat; } DIM_UNITS_FORMAT GetUnitsFormat() const { return m_unitsFormat; }
void SetUnitsFormat( const DIM_UNITS_FORMAT aFormat ) { m_unitsFormat = aFormat; } void SetUnitsFormat( const DIM_UNITS_FORMAT aFormat ) { m_unitsFormat = aFormat; }
void ChangeUnitsFormat( const DIM_UNITS_FORMAT aFormat )
{
SetUnitsFormat( aFormat );
updateText();
}
int GetPrecision() const { return m_precision; } int GetPrecision() const { return m_precision; }
void SetPrecision( int aPrecision ) { m_precision = aPrecision; } void SetPrecision( int aPrecision ) { m_precision = aPrecision; }
void ChangePrecision( int aPrecision )
{
SetPrecision( aPrecision );
updateText();
}
bool GetSuppressZeroes() const { return m_suppressZeroes; } bool GetSuppressZeroes() const { return m_suppressZeroes; }
void SetSuppressZeroes( bool aSuppress ) { m_suppressZeroes = aSuppress; } void SetSuppressZeroes( bool aSuppress ) { m_suppressZeroes = aSuppress; }
void ChangeSuppressZeroes( bool aSuppress )
{
SetSuppressZeroes( aSuppress );
updateText();
}
bool GetKeepTextAligned() const { return m_keepTextAligned; } bool GetKeepTextAligned() const { return m_keepTextAligned; }
void SetKeepTextAligned( bool aKeepAligned ) { m_keepTextAligned = aKeepAligned; } void SetKeepTextAligned( bool aKeepAligned ) { m_keepTextAligned = aKeepAligned; }
@ -190,30 +231,6 @@ public:
int GetLineThickness() const { return m_lineThickness; } int GetLineThickness() const { return m_lineThickness; }
void SetLineThickness( int aWidth ) { m_lineThickness = aWidth; } void SetLineThickness( int aWidth ) { m_lineThickness = aWidth; }
void SetLayer( PCB_LAYER_ID aLayer ) override;
void SetTextSize( const wxSize& aTextSize )
{
m_text.SetTextSize( aTextSize );
}
/**
* Set the override text - has no effect if m_overrideValue == false.
*
* @param aNewText is the text to use as the value.
*/
void SetText( const wxString& aNewText );
/**
* Retrieve the value text or override text, not including prefix or suffix.
*
* @return the value portion of the dimension text (either overridden or not).
*/
const wxString GetText() const;
PCB_TEXT& Text() { return m_text; }
const PCB_TEXT& Text() const { return m_text; }
/** /**
* @return a list of line segments that make up this dimension (for drawing, plotting, etc). * @return a list of line segments that make up this dimension (for drawing, plotting, etc).
*/ */
@ -249,6 +266,8 @@ public:
const BOX2I ViewBBox() const override; const BOX2I ViewBBox() const override;
void ClearRenderCache() override;
void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance, void TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
int aError, ERROR_LOC aErrorLoc, int aError, ERROR_LOC aErrorLoc,
bool aIgnoreLineWidth = false ) const override; bool aIgnoreLineWidth = false ) const override;
@ -303,13 +322,14 @@ protected:
bool m_keepTextAligned; ///< Calculate text orientation to match dimension bool m_keepTextAligned; ///< Calculate text orientation to match dimension
// Internal // Internal
PCB_TEXT m_text; ///< The actual text object
int m_measuredValue; ///< value of PCB dimensions int m_measuredValue; ///< value of PCB dimensions
VECTOR2I m_start; VECTOR2I m_start;
VECTOR2I m_end; VECTOR2I m_end;
///< Internal cache of drawn shapes ///< Internal cache of drawn shapes
std::vector<std::shared_ptr<SHAPE>> m_shapes; std::vector<std::shared_ptr<SHAPE>> m_shapes;
bool m_inClearRenderCache; ///< re-entrancy guard
}; };
@ -374,6 +394,12 @@ public:
void SetHeight( int aHeight ) { m_height = aHeight; } void SetHeight( int aHeight ) { m_height = aHeight; }
int GetHeight() const { return m_height; } int GetHeight() const { return m_height; }
void ChangeHeight( int aHeight )
{
SetHeight( aHeight );
updateGeometry();
}
/** /**
* Update the stored height basing on points coordinates. * Update the stored height basing on points coordinates.
* *
@ -384,6 +410,12 @@ public:
void SetExtensionHeight( int aHeight ) { m_extensionHeight = aHeight; } void SetExtensionHeight( int aHeight ) { m_extensionHeight = aHeight; }
int GetExtensionHeight() const { return m_extensionHeight; } int GetExtensionHeight() const { return m_extensionHeight; }
void ChangeExtensionHeight( int aHeight )
{
SetExtensionHeight( aHeight );
updateGeometry();
}
/** /**
* Return the angle of the crossbar. * Return the angle of the crossbar.
* *
@ -511,6 +543,12 @@ public:
void SetLeaderLength( int aLength ) { m_leaderLength = aLength; } void SetLeaderLength( int aLength ) { m_leaderLength = aLength; }
int GetLeaderLength() const { return m_leaderLength; } int GetLeaderLength() const { return m_leaderLength; }
void ChangeLeaderLength( int aLength )
{
SetLeaderLength( aLength );
updateGeometry();
}
// Returns the point (c). // Returns the point (c).
VECTOR2I GetKnee() const; VECTOR2I GetKnee() const;
@ -566,9 +604,17 @@ public:
return wxT( "PCB_DIM_LEADER" ); return wxT( "PCB_DIM_LEADER" );
} }
void SetTextBorder( DIM_TEXT_BORDER aFrame ) { m_textBorder = aFrame; } void SetTextBorder( DIM_TEXT_BORDER aBorder ) { m_textBorder = aBorder; }
DIM_TEXT_BORDER GetTextBorder() const { return m_textBorder; } DIM_TEXT_BORDER GetTextBorder() const { return m_textBorder; }
void ChangeTextBorder( DIM_TEXT_BORDER aBorder )
{
SetTextBorder( aBorder );
updateGeometry();
}
void ClearRenderCache() override;
void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override; void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;
protected: protected:

13
pcbnew/pcb_painter.cpp
View File

@ -2560,9 +2560,8 @@ void PCB_PAINTER::draw( const PCB_DIMENSION_BASE* aDimension, int aLayer )
} }
// Draw text // Draw text
const PCB_TEXT& text = aDimension->Text(); wxString resolvedText = aDimension->GetShownText();
wxString resolvedText = text.GetShownText(); TEXT_ATTRIBUTES attrs = aDimension->GetAttributes();
TEXT_ATTRIBUTES attrs = text.GetAttributes();
if( m_gal->IsFlippedX() && !( aDimension->GetLayerSet() & LSET::SideSpecificMask() ).any() ) if( m_gal->IsFlippedX() && !( aDimension->GetLayerSet() & LSET::SideSpecificMask() ).any() )
attrs.m_Mirrored = !attrs.m_Mirrored; attrs.m_Mirrored = !attrs.m_Mirrored;
@ -2570,12 +2569,12 @@ void PCB_PAINTER::draw( const PCB_DIMENSION_BASE* aDimension, int aLayer )
if( outline_mode ) if( outline_mode )
attrs.m_StrokeWidth = m_pcbSettings.m_outlineWidth; attrs.m_StrokeWidth = m_pcbSettings.m_outlineWidth;
else else
attrs.m_StrokeWidth = getLineThickness( text.GetEffectiveTextPenWidth() ); attrs.m_StrokeWidth = getLineThickness( aDimension->GetEffectiveTextPenWidth() );
std::vector<std::unique_ptr<KIFONT::GLYPH>>* cache = nullptr; std::vector<std::unique_ptr<KIFONT::GLYPH>>* cache = nullptr;
if( text.GetFont() && text.GetFont()->IsOutline() ) if( aDimension->GetFont() && aDimension->GetFont()->IsOutline() )
cache = text.GetRenderCache( text.GetFont(), resolvedText ); cache = aDimension->GetRenderCache( aDimension->GetFont(), resolvedText );
if( cache ) if( cache )
{ {
@ -2584,7 +2583,7 @@ void PCB_PAINTER::draw( const PCB_DIMENSION_BASE* aDimension, int aLayer )
} }
else else
{ {
strokeText( resolvedText, text.GetTextPos(), attrs ); strokeText( resolvedText, aDimension->GetTextPos(), attrs );
} }
} }

5
pcbnew/pcb_text.cpp
View File

@ -35,13 +35,12 @@
#include <trigo.h> #include <trigo.h>
#include <string_utils.h> #include <string_utils.h>
#include <geometry/shape_compound.h> #include <geometry/shape_compound.h>
#include <geometry/shape_rect.h>
#include <callback_gal.h> #include <callback_gal.h>
#include <convert_basic_shapes_to_polygon.h> #include <convert_basic_shapes_to_polygon.h>
PCB_TEXT::PCB_TEXT( BOARD_ITEM* parent ) : PCB_TEXT::PCB_TEXT( BOARD_ITEM* parent, KICAD_T idtype ) :
BOARD_ITEM( parent, PCB_TEXT_T ), BOARD_ITEM( parent, idtype ),
EDA_TEXT( pcbIUScale ) EDA_TEXT( pcbIUScale )
{ {
SetMultilineAllowed( true ); SetMultilineAllowed( true );

4
pcbnew/pcb_text.h
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com * Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
* Copyright (C) 1992-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -36,7 +36,7 @@ class MSG_PANEL_ITEM;
class PCB_TEXT : public BOARD_ITEM, public EDA_TEXT class PCB_TEXT : public BOARD_ITEM, public EDA_TEXT
{ {
public: public:
PCB_TEXT( BOARD_ITEM* parent ); PCB_TEXT( BOARD_ITEM* parent, KICAD_T idtype = PCB_TEXT_T );
// Do not create a copy constructor & operator=. // Do not create a copy constructor & operator=.
// The ones generated by the compiler are adequate. // The ones generated by the compiler are adequate.

2
pcbnew/plot_brditems_plotter.cpp
View File

@ -484,7 +484,7 @@ void BRDITEMS_PLOTTER::PlotDimension( const PCB_DIMENSION_BASE* aDim )
// the white items are not seen on a white paper or screen // the white items are not seen on a white paper or screen
m_plotter->SetColor( color != WHITE ? color : LIGHTGRAY); m_plotter->SetColor( color != WHITE ? color : LIGHTGRAY);
PlotPcbText( &aDim->Text(), aDim->GetLayer(), false ); PlotPcbText( aDim, aDim->GetLayer(), false );
for( const std::shared_ptr<SHAPE>& shape : aDim->GetShapes() ) for( const std::shared_ptr<SHAPE>& shape : aDim->GetShapes() )
{ {

32
pcbnew/plugins/altium/altium_pcb.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2019-2020 Thomas Pointhuber <thomas.pointhuber@gmx.at> * Copyright (C) 2019-2020 Thomas Pointhuber <thomas.pointhuber@gmx.at>
* Copyright (C) 2021-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2021-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -1315,15 +1315,15 @@ void ALTIUM_PCB::HelperParseDimensions6Linear( const ADIMENSION6& aElem )
dimension->SetUnitsFormat( aElem.textsuffix.IsEmpty() ? DIM_UNITS_FORMAT::NO_SUFFIX dimension->SetUnitsFormat( aElem.textsuffix.IsEmpty() ? DIM_UNITS_FORMAT::NO_SUFFIX
: DIM_UNITS_FORMAT::BARE_SUFFIX ); : DIM_UNITS_FORMAT::BARE_SUFFIX );
dimension->Text().SetTextThickness( aElem.textlinewidth ); dimension->SetTextThickness( aElem.textlinewidth );
dimension->Text().SetTextSize( wxSize( aElem.textheight, aElem.textheight ) ); dimension->SetTextSize( VECTOR2I( aElem.textheight, aElem.textheight ) );
dimension->Text().SetItalic( aElem.textitalic ); dimension->SetItalic( aElem.textitalic );
#if 0 // we don't currently support bold; map to thicker text #if 0 // we don't currently support bold; map to thicker text
dimension->Text().SetBold( aElem.textbold ); dimension->Text().SetBold( aElem.textbold );
#else #else
if( aElem.textbold ) if( aElem.textbold )
dimension->Text().SetTextThickness( dimension->Text().GetTextThickness() * BOLD_FACTOR ); dimension->SetTextThickness( dimension->GetTextThickness() * BOLD_FACTOR );
#endif #endif
switch( aElem.textunit ) switch( aElem.textunit )
@ -1401,26 +1401,26 @@ void ALTIUM_PCB::HelperParseDimensions6Radial(const ADIMENSION6 &aElem)
return; return;
} }
dimension->Text().SetPosition( aElem.textPoint.at( 0 ) ); dimension->SetTextPos( aElem.textPoint.at( 0 ) );
dimension->Text().SetTextThickness( aElem.textlinewidth ); dimension->SetTextThickness( aElem.textlinewidth );
dimension->Text().SetTextSize( wxSize( aElem.textheight, aElem.textheight ) ); dimension->SetTextSize( VECTOR2I( aElem.textheight, aElem.textheight ) );
dimension->Text().SetItalic( aElem.textitalic ); dimension->SetItalic( aElem.textitalic );
#if 0 // we don't currently support bold; map to thicker text #if 0 // we don't currently support bold; map to thicker text
dimension->Text().SetBold( aElem.textbold ); dimension->SetBold( aElem.textbold );
#else #else
if( aElem.textbold ) if( aElem.textbold )
dimension->Text().SetTextThickness( dimension->Text().GetTextThickness() * BOLD_FACTOR ); dimension->SetTextThickness( dimension->GetTextThickness() * BOLD_FACTOR );
#endif #endif
// It's unclear exactly how Altium figures it's text positioning, but this gets us reasonably // It's unclear exactly how Altium figures it's text positioning, but this gets us reasonably
// close. // close.
dimension->Text().SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM ); dimension->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
dimension->Text().SetHorizJustify( GR_TEXT_H_ALIGN_LEFT ); dimension->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
int yAdjust = dimension->Text().GetCenter().y - dimension->Text().GetPosition().y; int yAdjust = dimension->GetTextBox().GetCenter().y - dimension->GetTextPos().y;
dimension->Text().Move( VECTOR2I( 0, yAdjust + aElem.textgap ) ); dimension->SetTextPos( dimension->GetTextPos() + VECTOR2I( 0, yAdjust + aElem.textgap ) );
dimension->Text().SetVertJustify( GR_TEXT_V_ALIGN_CENTER ); dimension->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
} }

12
pcbnew/plugins/cadstar/cadstar_pcb_archive_loader.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2020-2021 Roberto Fernandez Bautista <roberto.fer.bau@gmail.com> * Copyright (C) 2020-2021 Roberto Fernandez Bautista <roberto.fer.bau@gmail.com>
* Copyright (C) 2020-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2020-2023 KiCad Developers, see AUTHORS.txt for contributors.
* *
* This program is free software: you can redistribute it and/or modify it * 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 * under the terms of the GNU General Public License as published by the
@ -1555,16 +1555,16 @@ void CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions()
endPoint.y ); endPoint.y );
leaderDim->SetEnd( getKiCadPoint( endPoint ) ); leaderDim->SetEnd( getKiCadPoint( endPoint ) );
leaderDim->Text().SetTextPos( getKiCadPoint( txtPoint ) ); leaderDim->SetTextPos( getKiCadPoint( txtPoint ) );
leaderDim->SetText( ParseTextFields( csDim.Text.Text, &m_context ) ); leaderDim->SetOverrideText( ParseTextFields( csDim.Text.Text, &m_context ) );
leaderDim->SetPrefix( wxEmptyString ); leaderDim->SetPrefix( wxEmptyString );
leaderDim->SetSuffix( wxEmptyString ); leaderDim->SetSuffix( wxEmptyString );
leaderDim->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX ); leaderDim->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
if( orientX == 1 ) if( orientX == 1 )
leaderDim->Text().SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT ); leaderDim->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
else else
leaderDim->Text().SetHorizJustify( GR_TEXT_H_ALIGN_LEFT ); leaderDim->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
leaderDim->SetExtensionOffset( 0 ); leaderDim->SetExtensionOffset( 0 );
} }
@ -3635,7 +3635,7 @@ void CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings( const DIMENSION& aCads
aKiCadDim->SetExtensionOffset( getKiCadLength( aCadstarDim.ExtensionLineParams.Offset ) ); aKiCadDim->SetExtensionOffset( getKiCadLength( aCadstarDim.ExtensionLineParams.Offset ) );
aKiCadDim->SetLineThickness( getKiCadLength( linecode.Width ) ); aKiCadDim->SetLineThickness( getKiCadLength( linecode.Width ) );
applyTextCode( &aKiCadDim->Text(), aCadstarDim.Text.TextCodeID ); applyTextCode( aKiCadDim, aCadstarDim.Text.TextCodeID );
// Find prefix and suffix: // Find prefix and suffix:
wxString prefix = wxEmptyString; wxString prefix = wxEmptyString;

18
pcbnew/plugins/eagle/eagle_plugin.cpp
View File

@ -957,9 +957,9 @@ void EAGLE_PLUGIN::loadPlain( wxXmlNode* aGraphics )
dimension->SetStart( pt1 ); dimension->SetStart( pt1 );
dimension->SetEnd( pt2 ); dimension->SetEnd( pt2 );
dimension->Text().SetPosition( pt3 ); dimension->SetTextPos( pt3 );
dimension->Text().SetTextSize( textSize ); dimension->SetTextSize( textSize );
dimension->Text().SetTextThickness( textThickness ); dimension->SetTextThickness( textThickness );
dimension->SetLineThickness( designSettings.GetLineThickness( layer ) ); dimension->SetLineThickness( designSettings.GetLineThickness( layer ) );
dimension->SetUnits( EDA_UNITS::MILLIMETRES ); dimension->SetUnits( EDA_UNITS::MILLIMETRES );
} }
@ -973,10 +973,10 @@ void EAGLE_PLUGIN::loadPlain( wxXmlNode* aGraphics )
leader->SetStart( pt1 ); leader->SetStart( pt1 );
leader->SetEnd( pt2 ); leader->SetEnd( pt2 );
leader->Text().SetPosition( pt3 ); leader->SetTextPos( pt3 );
leader->Text().SetTextSize( textSize ); leader->SetTextSize( textSize );
leader->Text().SetTextThickness( textThickness ); leader->SetTextThickness( textThickness );
leader->SetText( wxEmptyString ); leader->SetOverrideText( wxEmptyString );
leader->SetLineThickness( designSettings.GetLineThickness( layer ) ); leader->SetLineThickness( designSettings.GetLineThickness( layer ) );
} }
else // horizontal, vertical, <default>, diameter else // horizontal, vertical, <default>, diameter
@ -1009,8 +1009,8 @@ void EAGLE_PLUGIN::loadPlain( wxXmlNode* aGraphics )
// The origin and end are assumed to always be in this order from eagle // The origin and end are assumed to always be in this order from eagle
dimension->SetStart( pt1 ); dimension->SetStart( pt1 );
dimension->SetEnd( pt2 ); dimension->SetEnd( pt2 );
dimension->Text().SetTextSize( textSize ); dimension->SetTextSize( textSize );
dimension->Text().SetTextThickness( textThickness ); dimension->SetTextThickness( textThickness );
dimension->SetLineThickness( designSettings.GetLineThickness( layer ) ); dimension->SetLineThickness( designSettings.GetLineThickness( layer ) );
dimension->SetUnits( EDA_UNITS::MILLIMETRES ); dimension->SetUnits( EDA_UNITS::MILLIMETRES );

6
pcbnew/plugins/kicad/pcb_parser.cpp
View File

@ -3216,13 +3216,11 @@ PCB_DIMENSION_BASE* PCB_PARSER::parseDIMENSION( BOARD_ITEM* aParent, bool aInFP
case T_gr_text: case T_gr_text:
{ {
PCB_TEXT* text = parsePCB_TEXT(); PCB_TEXT* text = parsePCB_TEXT();
dim->Text() = *text;
// The text is part of the dim and shares its uuid dim->EDA_TEXT::operator=( *text );
const_cast<KIID&>( dim->Text().m_Uuid ) = dim->m_Uuid;
// Fetch other dim properties out of the text item // Fetch other dim properties out of the text item
dim->Text().SetTextPos( text->GetTextPos() ); dim->SetTextPos( text->GetTextPos() );
if( isLegacyDimension ) if( isLegacyDimension )
{ {

2
pcbnew/plugins/kicad/pcb_plugin.cpp
View File

@ -810,7 +810,7 @@ void PCB_PLUGIN::format( const PCB_DIMENSION_BASE* aDimension, int aNestLevel )
if( !center ) if( !center )
{ {
Format( &aDimension->Text(), aNestLevel + 1 ); format( static_cast<const PCB_TEXT*>( aDimension ), aNestLevel + 1 );
m_out->Print( aNestLevel + 1, "(format (prefix %s) (suffix %s) (units %d) (units_format %d) (precision %d)", m_out->Print( aNestLevel + 1, "(format (prefix %s) (suffix %s) (units %d) (units_format %d) (precision %d)",
m_out->Quotew( aDimension->GetPrefix() ).c_str(), m_out->Quotew( aDimension->GetPrefix() ).c_str(),

10
pcbnew/plugins/legacy/legacy_plugin.cpp
View File

@ -2674,11 +2674,11 @@ void LEGACY_PLUGIN::loadDIMENSION()
EDA_ANGLE orient = degParse( data, &data ); EDA_ANGLE orient = degParse( data, &data );
char* mirror = strtok_r( (char*) data, delims, (char**) &data ); char* mirror = strtok_r( (char*) data, delims, (char**) &data );
dim->Text().SetTextPos( VECTOR2I( pos_x, pos_y ) ); dim->SetTextPos( VECTOR2I( pos_x, pos_y ) );
dim->Text().SetTextSize( wxSize( width, height ) ); dim->SetTextSize( VECTOR2I( width, height ) );
dim->Text().SetMirrored( mirror && *mirror == '0' ); dim->SetMirrored( mirror && *mirror == '0' );
dim->Text().SetTextThickness( thickn ); dim->SetTextThickness( thickn );
dim->Text().SetTextAngle( orient ); dim->SetTextAngle( orient );
} }
else if( TESTLINE( "Sb" ) ) else if( TESTLINE( "Sb" ) )
{ {

18
pcbnew/tools/drawing_tool.cpp
View File

@ -1247,7 +1247,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
else if( originalEvent.IsAction( &PCB_ACTIONS::drawLeader ) ) else if( originalEvent.IsAction( &PCB_ACTIONS::drawLeader ) )
{ {
dimension = new PCB_DIM_LEADER( m_frame->GetModel(), m_isFootprintEditor ); dimension = new PCB_DIM_LEADER( m_frame->GetModel(), m_isFootprintEditor );
dimension->Text().SetPosition( cursorPos ); dimension->SetTextPos( cursorPos );
} }
else else
{ {
@ -1257,9 +1257,9 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
t = dimension->Type(); t = dimension->Type();
dimension->SetLayer( layer ); dimension->SetLayer( layer );
dimension->Text().SetTextSize( boardSettings.GetTextSize( layer ) ); dimension->SetTextSize( boardSettings.GetTextSize( layer ) );
dimension->Text().SetTextThickness( boardSettings.GetTextThickness( layer ) ); dimension->SetTextThickness( boardSettings.GetTextThickness( layer ) );
dimension->Text().SetItalic( boardSettings.GetTextItalic( layer ) ); dimension->SetItalic( boardSettings.GetTextItalic( layer ) );
dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) ); dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) );
dimension->SetArrowLength( boardSettings.m_DimensionArrowLength ); dimension->SetArrowLength( boardSettings.m_DimensionArrowLength );
dimension->SetExtensionOffset( boardSettings.m_DimensionExtensionOffset ); dimension->SetExtensionOffset( boardSettings.m_DimensionExtensionOffset );
@ -1364,7 +1364,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
if( radialDim->GetEnd().x < radialDim->GetStart().x ) if( radialDim->GetEnd().x < radialDim->GetStart().x )
textOffset = -textOffset; textOffset = -textOffset;
radialDim->Text().SetPosition( radialDim->GetKnee() + textOffset ); radialDim->SetTextPos( radialDim->GetKnee() + textOffset );
} }
else if( t == PCB_DIM_LEADER_T || t == PCB_FP_DIM_LEADER_T ) else if( t == PCB_DIM_LEADER_T || t == PCB_FP_DIM_LEADER_T )
{ {
@ -1373,7 +1373,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
if( dimension->GetEnd().x < dimension->GetStart().x ) if( dimension->GetEnd().x < dimension->GetStart().x )
textOffset = -textOffset; textOffset = -textOffset;
dimension->Text().SetPosition( dimension->GetEnd() + textOffset ); dimension->SetTextPos( dimension->GetEnd() + textOffset );
} }
dimension->Update(); dimension->Update();
@ -1447,9 +1447,9 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
} }
dimension->SetLayer( layer ); dimension->SetLayer( layer );
dimension->Text().SetTextSize( boardSettings.GetTextSize( layer ) ); dimension->SetTextSize( boardSettings.GetTextSize( layer ) );
dimension->Text().SetTextThickness( boardSettings.GetTextThickness( layer ) ); dimension->SetTextThickness( boardSettings.GetTextThickness( layer ) );
dimension->Text().SetItalic( boardSettings.GetTextItalic( layer ) ); dimension->SetItalic( boardSettings.GetTextItalic( layer ) );
dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) ); dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) );
dimension->Update(); dimension->Update();

6
pcbnew/tools/pcb_grid_helper.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2014 CERN * Copyright (C) 2014 CERN
* Copyright (C) 2018-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2018-2023 KiCad Developers, see AUTHORS.txt for contributors.
* @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch> * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
@ -845,7 +845,7 @@ void PCB_GRID_HELPER::computeAnchors( BOARD_ITEM* aItem, const VECTOR2I& aRefPos
addAnchor( radialDim->GetStart(), CORNER | SNAPPABLE, aItem ); addAnchor( radialDim->GetStart(), CORNER | SNAPPABLE, aItem );
addAnchor( radialDim->GetEnd(), CORNER | SNAPPABLE, aItem ); addAnchor( radialDim->GetEnd(), CORNER | SNAPPABLE, aItem );
addAnchor( radialDim->GetKnee(), CORNER | SNAPPABLE, aItem ); addAnchor( radialDim->GetKnee(), CORNER | SNAPPABLE, aItem );
addAnchor( radialDim->Text().GetPosition(), CORNER | SNAPPABLE, aItem ); addAnchor( radialDim->GetTextPos(), CORNER | SNAPPABLE, aItem );
break; break;
} }
@ -858,7 +858,7 @@ void PCB_GRID_HELPER::computeAnchors( BOARD_ITEM* aItem, const VECTOR2I& aRefPos
const PCB_DIM_LEADER* leader = static_cast<const PCB_DIM_LEADER*>( aItem ); const PCB_DIM_LEADER* leader = static_cast<const PCB_DIM_LEADER*>( aItem );
addAnchor( leader->GetStart(), CORNER | SNAPPABLE, aItem ); addAnchor( leader->GetStart(), CORNER | SNAPPABLE, aItem );
addAnchor( leader->GetEnd(), CORNER | SNAPPABLE, aItem ); addAnchor( leader->GetEnd(), CORNER | SNAPPABLE, aItem );
addAnchor( leader->Text().GetPosition(), CORNER | SNAPPABLE, aItem ); addAnchor( leader->GetTextPos(), CORNER | SNAPPABLE, aItem );
break; break;
} }

28
pcbnew/tools/pcb_point_editor.cpp
View File

@ -2,7 +2,7 @@
* This program source code file is part of KiCad, a free EDA CAD application. * This program source code file is part of KiCad, a free EDA CAD application.
* *
* Copyright (C) 2013-2021 CERN * Copyright (C) 2013-2021 CERN
* Copyright (C) 2018-2022 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 2018-2023 KiCad Developers, see AUTHORS.txt for contributors.
* @author Maciej Suminski <maciej.suminski@cern.ch> * @author Maciej Suminski <maciej.suminski@cern.ch>
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
@ -326,7 +326,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
points->AddPoint( dimension->Text().GetPosition() ); points->AddPoint( dimension->GetTextPos() );
points->AddPoint( dimension->GetCrossbarStart() ); points->AddPoint( dimension->GetCrossbarStart() );
points->AddPoint( dimension->GetCrossbarEnd() ); points->AddPoint( dimension->GetCrossbarEnd() );
@ -371,7 +371,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
points->AddPoint( dimension->Text().GetPosition() ); points->AddPoint( dimension->GetTextPos() );
points->AddPoint( dimension->GetKnee() ); points->AddPoint( dimension->GetKnee() );
points->Point( DIM_START ).SetSnapConstraint( ALL_LAYERS ); points->Point( DIM_START ).SetSnapConstraint( ALL_LAYERS );
@ -395,7 +395,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
points->AddPoint( dimension->Text().GetPosition() ); points->AddPoint( dimension->GetTextPos() );
points->Point( DIM_START ).SetSnapConstraint( ALL_LAYERS ); points->Point( DIM_START ).SetSnapConstraint( ALL_LAYERS );
points->Point( DIM_END ).SetSnapConstraint( ALL_LAYERS ); points->Point( DIM_END ).SetSnapConstraint( ALL_LAYERS );
@ -1492,7 +1492,7 @@ void PCB_POINT_EDITOR::updateItem() const
{ {
// Force manual mode if we weren't already in it // Force manual mode if we weren't already in it
dimension->SetTextPositionMode( DIM_TEXT_POSITION::MANUAL ); dimension->SetTextPositionMode( DIM_TEXT_POSITION::MANUAL );
dimension->Text().SetPosition( m_editedPoint->GetPosition() ); dimension->SetTextPos( m_editedPoint->GetPosition() );
dimension->Update(); dimension->Update();
} }
@ -1557,7 +1557,7 @@ void PCB_POINT_EDITOR::updateItem() const
{ {
// Force manual mode if we weren't already in it // Force manual mode if we weren't already in it
dimension->SetTextPositionMode( DIM_TEXT_POSITION::MANUAL ); dimension->SetTextPositionMode( DIM_TEXT_POSITION::MANUAL );
dimension->Text().SetPosition( VECTOR2I( m_editedPoint->GetPosition() ) ); dimension->SetTextPos( VECTOR2I( m_editedPoint->GetPosition() ) );
} }
dimension->Update(); dimension->Update();
@ -1601,7 +1601,7 @@ void PCB_POINT_EDITOR::updateItem() const
dimension->Update(); dimension->Update();
VECTOR2I kneeDelta = dimension->GetKnee() - oldKnee; VECTOR2I kneeDelta = dimension->GetKnee() - oldKnee;
dimension->Text().SetPosition( dimension->Text().GetPosition() + kneeDelta ); dimension->SetTextPos( dimension->GetTextPos() + kneeDelta );
dimension->Update(); dimension->Update();
m_editPoints->Point( DIM_KNEE ).SetConstraint( new EC_LINE( m_editPoints->Point( DIM_START ), m_editPoints->Point( DIM_KNEE ).SetConstraint( new EC_LINE( m_editPoints->Point( DIM_START ),
@ -1617,12 +1617,12 @@ void PCB_POINT_EDITOR::updateItem() const
dimension->Update(); dimension->Update();
VECTOR2I kneeDelta = dimension->GetKnee() - oldKnee; VECTOR2I kneeDelta = dimension->GetKnee() - oldKnee;
dimension->Text().SetPosition( dimension->Text().GetPosition() + kneeDelta ); dimension->SetTextPos( dimension->GetTextPos() + kneeDelta );
dimension->Update(); dimension->Update();
} }
else if( isModified( m_editPoints->Point( DIM_TEXT ) ) ) else if( isModified( m_editPoints->Point( DIM_TEXT ) ) )
{ {
dimension->Text().SetPosition( m_editedPoint->GetPosition() ); dimension->SetTextPos( m_editedPoint->GetPosition() );
dimension->Update(); dimension->Update();
} }
@ -1644,11 +1644,11 @@ void PCB_POINT_EDITOR::updateItem() const
VECTOR2I delta = newPoint - dimension->GetEnd(); VECTOR2I delta = newPoint - dimension->GetEnd();
dimension->SetEnd( newPoint ); dimension->SetEnd( newPoint );
dimension->Text().SetPosition( dimension->Text().GetPosition() + delta ); dimension->SetTextPos( dimension->GetTextPos() + delta );
} }
else if( isModified( m_editPoints->Point( DIM_TEXT ) ) ) else if( isModified( m_editPoints->Point( DIM_TEXT ) ) )
{ {
dimension->Text().SetPosition( (VECTOR2I) m_editedPoint->GetPosition() ); dimension->SetTextPos( (VECTOR2I) m_editedPoint->GetPosition() );
} }
dimension->Update(); dimension->Update();
@ -1915,7 +1915,7 @@ void PCB_POINT_EDITOR::updatePoints()
m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() ); m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() );
m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() ); m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() );
m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->Text().GetPosition() ); m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->GetTextPos() );
m_editPoints->Point( DIM_CROSSBARSTART ).SetPosition( dimension->GetCrossbarStart() ); m_editPoints->Point( DIM_CROSSBARSTART ).SetPosition( dimension->GetCrossbarStart() );
m_editPoints->Point( DIM_CROSSBAREND ).SetPosition( dimension->GetCrossbarEnd() ); m_editPoints->Point( DIM_CROSSBAREND ).SetPosition( dimension->GetCrossbarEnd() );
break; break;
@ -1938,7 +1938,7 @@ void PCB_POINT_EDITOR::updatePoints()
m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() ); m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() );
m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() ); m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() );
m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->Text().GetPosition() ); m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->GetTextPos() );
m_editPoints->Point( DIM_KNEE ).SetPosition( dimension->GetKnee() ); m_editPoints->Point( DIM_KNEE ).SetPosition( dimension->GetKnee() );
break; break;
} }
@ -1950,7 +1950,7 @@ void PCB_POINT_EDITOR::updatePoints()
m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() ); m_editPoints->Point( DIM_START ).SetPosition( dimension->GetStart() );
m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() ); m_editPoints->Point( DIM_END ).SetPosition( dimension->GetEnd() );
m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->Text().GetPosition() ); m_editPoints->Point( DIM_TEXT ).SetPosition( dimension->GetTextPos() );
break; break;
} }