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

Prefix DIMENSION types.

This commit is contained in:
Jeff Young 2021-06-11 17:59:28 +01:00
parent 6ab995d6a4
commit 16b0147af8
44 changed files with 291 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
3d-viewer/3d_canvas/board_adapter.h
View File

@ -42,7 +42,7 @@
#include <pcb_base_frame.h> #include <pcb_base_frame.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <zone.h> #include <zone.h>
#include <footprint.h> #include <footprint.h>
#include <reporter.h> #include <reporter.h>
@ -586,8 +586,9 @@ private:
void addShapeWithClearance( const PCB_SHAPE* aShape, CONTAINER_2D_BASE* aDstContainer, void addShapeWithClearance( const PCB_SHAPE* aShape, CONTAINER_2D_BASE* aDstContainer,
PCB_LAYER_ID aLayerId, int aClearanceValue ); PCB_LAYER_ID aLayerId, int aClearanceValue );
void addShapeWithClearance( const DIMENSION_BASE* aDimension, CONTAINER_2D_BASE* aDstContainer, void addShapeWithClearance( const PCB_DIMENSION_BASE* aDimension,
PCB_LAYER_ID aLayerId, int aClearanceValue ); CONTAINER_2D_BASE* aDstContainer, PCB_LAYER_ID aLayerId,
int aClearanceValue );
void addSolidAreasShapes( const ZONE* aZoneContainer, CONTAINER_2D_BASE* aDstContainer, void addSolidAreasShapes( const ZONE* aZoneContainer, CONTAINER_2D_BASE* aDstContainer,
PCB_LAYER_ID aLayerId ); PCB_LAYER_ID aLayerId );

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

@ -110,7 +110,7 @@ void BOARD_ADAPTER::addShapeWithClearance( const PCB_TEXT* aText, CONTAINER_2D_B
} }
void BOARD_ADAPTER::addShapeWithClearance( const DIMENSION_BASE* aDimension, void BOARD_ADAPTER::addShapeWithClearance( const PCB_DIMENSION_BASE* aDimension,
CONTAINER_2D_BASE* aDstContainer, CONTAINER_2D_BASE* aDstContainer,
PCB_LAYER_ID aLayerId, int aClearanceValue ) PCB_LAYER_ID aLayerId, int aClearanceValue )
{ {

4
3d-viewer/3d_canvas/create_layer_items.cpp
View File

@ -625,7 +625,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
addShapeWithClearance( static_cast<DIMENSION_BASE*>( item ), addShapeWithClearance( static_cast<PCB_DIMENSION_BASE*>( item ),
layerContainer, curr_layer_id, 0 ); layerContainer, curr_layer_id, 0 );
break; break;
@ -919,7 +919,7 @@ void BOARD_ADAPTER::createLayers( REPORTER* aStatusReporter )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
addShapeWithClearance( static_cast<DIMENSION_BASE*>( item ), layerContainer, addShapeWithClearance( static_cast<PCB_DIMENSION_BASE*>( item ), layerContainer,
curr_layer_id, 0 ); curr_layer_id, 0 );
break; break;

2
common/CMakeLists.txt
View File

@ -516,7 +516,7 @@ set( PCB_COMMON_SRCS
${CMAKE_SOURCE_DIR}/pcbnew/board_items_to_polygon_shape_transform.cpp ${CMAKE_SOURCE_DIR}/pcbnew/board_items_to_polygon_shape_transform.cpp
${CMAKE_SOURCE_DIR}/pcbnew/board.cpp ${CMAKE_SOURCE_DIR}/pcbnew/board.cpp
${CMAKE_SOURCE_DIR}/pcbnew/board_item.cpp ${CMAKE_SOURCE_DIR}/pcbnew/board_item.cpp
${CMAKE_SOURCE_DIR}/pcbnew/dimension.cpp ${CMAKE_SOURCE_DIR}/pcbnew/pcb_dimension.cpp
${CMAKE_SOURCE_DIR}/pcbnew/pcb_shape.cpp ${CMAKE_SOURCE_DIR}/pcbnew/pcb_shape.cpp
${CMAKE_SOURCE_DIR}/pcbnew/fp_shape.cpp ${CMAKE_SOURCE_DIR}/pcbnew/fp_shape.cpp
${CMAKE_SOURCE_DIR}/pcbnew/pcb_group.cpp ${CMAKE_SOURCE_DIR}/pcbnew/pcb_group.cpp

10
include/core/typeinfo.h
View File

@ -96,11 +96,11 @@ enum KICAD_T
PCB_VIA_T, ///< class VIA, a via (like a track segment on a copper layer) PCB_VIA_T, ///< class VIA, a via (like a track segment on a copper layer)
PCB_ARC_T, ///< class ARC, an arc track segment on a copper layer PCB_ARC_T, ///< class ARC, an arc track segment on a copper layer
PCB_MARKER_T, ///< class MARKER_PCB, a marker used to show something PCB_MARKER_T, ///< class MARKER_PCB, a marker used to show something
PCB_DIMENSION_T, ///< class DIMENSION_BASE: abstract dimension meta-type PCB_DIMENSION_T, ///< class PCB_DIMENSION_BASE: abstract dimension meta-type
PCB_DIM_ALIGNED_T, ///< class ALIGNED_DIMENSION, a linear dimension (graphic item) PCB_DIM_ALIGNED_T, ///< class PCB_DIM_ALIGNED, a linear dimension (graphic item)
PCB_DIM_LEADER_T, ///< class LEADER, a leader dimension (graphic item) PCB_DIM_LEADER_T, ///< class PCB_DIM_LEADER, a leader dimension (graphic item)
PCB_DIM_CENTER_T, ///< class CENTER_DIMENSION, a center point marking (graphic item) PCB_DIM_CENTER_T, ///< class PCB_DIM_CENTER, a center point marking (graphic item)
PCB_DIM_ORTHOGONAL_T, ///< class ORTHOGONAL_DIMENSION, a linear dimension constrained to x/y PCB_DIM_ORTHOGONAL_T, ///< class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
PCB_TARGET_T, ///< class PCB_TARGET, a target (graphic item) PCB_TARGET_T, ///< class PCB_TARGET, a target (graphic item)
PCB_ZONE_T, ///< class ZONE, a copper pour area PCB_ZONE_T, ///< class ZONE, a copper pour area
PCB_ITEM_LIST_T, ///< class BOARD_ITEM_LIST, a list of board items PCB_ITEM_LIST_T, ///< class BOARD_ITEM_LIST, a list of board items

4
pcbnew/CMakeLists.txt
View File

@ -452,10 +452,10 @@ add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/pcbnew_wrap.cxx
DEPENDS python/swig/board_item.i DEPENDS python/swig/board_item.i
DEPENDS python/swig/board_item_container.i DEPENDS python/swig/board_item_container.i
DEPENDS python/swig/connectivity.i DEPENDS python/swig/connectivity.i
DEPENDS python/swig/dimension.i DEPENDS python/swig/pcb_dimension.i
DEPENDS python/swig/pcb_shape.i DEPENDS python/swig/pcb_shape.i
DEPENDS python/swig/fp_shape.i DEPENDS python/swig/fp_shape.i
DEPENDS python/swig/marker_pcb.i DEPENDS python/swig/pcb_marker.i
DEPENDS python/swig/pcb_target.i DEPENDS python/swig/pcb_target.i
DEPENDS python/swig/pcb_plot_params.i DEPENDS python/swig/pcb_plot_params.i
DEPENDS python/swig/footprint.i DEPENDS python/swig/footprint.i

2
pcbnew/board_design_settings.cpp
View File

@ -21,7 +21,7 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
#include <dimension.h> #include <pcb_dimension.h>
#include <track.h> #include <track.h>
#include <layers_id_colors_and_visibility.h> #include <layers_id_colors_and_visibility.h>
#include <kiface_i.h> #include <kiface_i.h>

6
pcbnew/board_items_to_polygon_shape_transform.cpp
View File

@ -28,7 +28,7 @@
#include <trigo.h> #include <trigo.h>
#include <board.h> #include <board.h>
#include <pad.h> #include <pad.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <track.h> #include <track.h>
#include <kicad_string.h> #include <kicad_string.h>
#include <pcb_shape.h> #include <pcb_shape.h>
@ -774,7 +774,7 @@ void ZONE::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
} }
void DIMENSION_BASE::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer, void PCB_DIMENSION_BASE::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
PCB_LAYER_ID aLayer, int aClearance, PCB_LAYER_ID aLayer, int aClearance,
int aError, ERROR_LOC aErrorLoc, int aError, ERROR_LOC aErrorLoc,
bool aIgnoreLineWidth ) const bool aIgnoreLineWidth ) const
@ -800,7 +800,7 @@ void DIMENSION_BASE::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCorn
} }
else else
{ {
wxFAIL_MSG( "DIMENSION::TransformShapeWithClearanceToPolygon unexpected shape type." ); wxFAIL_MSG( "PCB_DIMENSION_BASE::TransformShapeWithClearanceToPolygon unexpected shape type." );
} }
} }
} }

6
pcbnew/collectors.cpp
View File

@ -30,7 +30,7 @@
#include <pad.h> #include <pad.h>
#include <track.h> #include <track.h>
#include <pcb_marker.h> #include <pcb_marker.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <zone.h> #include <zone.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <pcb_group.h> #include <pcb_group.h>
@ -165,7 +165,7 @@ SEARCH_RESULT GENERAL_COLLECTOR::Inspect( EDA_ITEM* testItem, void* testData )
PCB_MARKER* marker = nullptr; PCB_MARKER* marker = nullptr;
ZONE* zone = nullptr; ZONE* zone = nullptr;
PCB_SHAPE* shape = nullptr; PCB_SHAPE* shape = nullptr;
DIMENSION_BASE* dimension = nullptr; PCB_DIMENSION_BASE* dimension = nullptr;
#if 0 // debugging #if 0 // debugging
static int breakhere = 0; static int breakhere = 0;
@ -288,7 +288,7 @@ SEARCH_RESULT GENERAL_COLLECTOR::Inspect( EDA_ITEM* testItem, void* testData )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
dimension = static_cast<DIMENSION_BASE*>( item ); dimension = static_cast<PCB_DIMENSION_BASE*>( item );
break; break;
case PCB_TARGET_T: case PCB_TARGET_T:

12
pcbnew/dialogs/dialog_dimension_properties.cpp
View File

@ -20,7 +20,7 @@
#include <board.h> #include <board.h>
#include <board_commit.h> #include <board_commit.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_base_edit_frame.h> #include <pcb_base_edit_frame.h>
#include <pcb_layer_box_selector.h> #include <pcb_layer_box_selector.h>
#include <widgets/unit_binder.h> #include <widgets/unit_binder.h>
@ -47,8 +47,8 @@ DIALOG_DIMENSION_PROPERTIES::DIALOG_DIMENSION_PROPERTIES( PCB_BASE_EDIT_FRAME* a
m_extensionOffset( aParent, m_lblExtensionOffset, m_txtExtensionOffset, m_lblExtensionOffsetUnits ) m_extensionOffset( aParent, m_lblExtensionOffset, m_txtExtensionOffset, m_lblExtensionOffsetUnits )
{ {
wxASSERT( BaseType( aItem->Type() ) == PCB_DIMENSION_T ); wxASSERT( BaseType( aItem->Type() ) == PCB_DIMENSION_T );
m_dimension = static_cast<DIMENSION_BASE*>( aItem ); m_dimension = static_cast<PCB_DIMENSION_BASE*>( aItem );
m_previewDimension = static_cast<DIMENSION_BASE*>( m_dimension->Clone() ); m_previewDimension = static_cast<PCB_DIMENSION_BASE*>( m_dimension->Clone() );
m_previewDimension->SetParent( m_frame->GetBoard() ); m_previewDimension->SetParent( m_frame->GetBoard() );
switch( m_dimension->Type() ) switch( m_dimension->Type() )
@ -247,7 +247,7 @@ bool DIALOG_DIMENSION_PROPERTIES::TransferDataToWindow()
if( m_dimension->Type() == PCB_DIM_LEADER_T ) if( m_dimension->Type() == PCB_DIM_LEADER_T )
{ {
LEADER* leader = static_cast<LEADER*>( m_dimension ); PCB_DIM_LEADER* leader = static_cast<PCB_DIM_LEADER*>( m_dimension );
m_cbTextFrame->SetSelection( static_cast<int>( leader->GetTextFrame() ) ); m_cbTextFrame->SetSelection( static_cast<int>( leader->GetTextFrame() ) );
} }
@ -283,7 +283,7 @@ bool DIALOG_DIMENSION_PROPERTIES::TransferDataFromWindow()
} }
void DIALOG_DIMENSION_PROPERTIES::updateDimensionFromDialog( DIMENSION_BASE* aTarget ) void DIALOG_DIMENSION_PROPERTIES::updateDimensionFromDialog( PCB_DIMENSION_BASE* aTarget )
{ {
BOARD* board = m_frame->GetBoard(); BOARD* board = m_frame->GetBoard();
@ -353,7 +353,7 @@ void DIALOG_DIMENSION_PROPERTIES::updateDimensionFromDialog( DIMENSION_BASE* aTa
if( aTarget->Type() == PCB_DIM_LEADER_T ) if( aTarget->Type() == PCB_DIM_LEADER_T )
{ {
LEADER* leader = static_cast<LEADER*>( aTarget ); PCB_DIM_LEADER* leader = static_cast<PCB_DIM_LEADER*>( aTarget );
leader->SetTextFrame( static_cast<DIM_TEXT_FRAME>( m_cbTextFrame->GetSelection() ) ); leader->SetTextFrame( static_cast<DIM_TEXT_FRAME>( m_cbTextFrame->GetSelection() ) );
} }

8
pcbnew/dialogs/dialog_dimension_properties.h
View File

@ -28,7 +28,7 @@
class BOARD_ITEM; class BOARD_ITEM;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class PCB_BASE_EDIT_FRAME; class PCB_BASE_EDIT_FRAME;
@ -48,8 +48,8 @@ private:
PCB_BASE_EDIT_FRAME* m_frame; PCB_BASE_EDIT_FRAME* m_frame;
DIMENSION_BASE* m_dimension; PCB_DIMENSION_BASE* m_dimension;
DIMENSION_BASE* m_previewDimension; PCB_DIMENSION_BASE* m_previewDimension;
PCB_LAYER_BOX_SELECTOR* m_cbLayerActual; // The active layer box control PCB_LAYER_BOX_SELECTOR* m_cbLayerActual; // The active layer box control
wxTextCtrl* m_txtValueActual; // The active value control wxTextCtrl* m_txtValueActual; // The active value control
@ -67,7 +67,7 @@ private:
UNIT_BINDER m_arrowLength; UNIT_BINDER m_arrowLength;
UNIT_BINDER m_extensionOffset; UNIT_BINDER m_extensionOffset;
void updateDimensionFromDialog( DIMENSION_BASE* aTarget ); void updateDimensionFromDialog( PCB_DIMENSION_BASE* aTarget );
void updatePreviewText(); void updatePreviewText();
}; };

4
pcbnew/dialogs/dialog_global_edit_text_and_graphics.cpp
View File

@ -30,7 +30,7 @@
#include <board.h> #include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <footprint.h> #include <footprint.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <widgets/unit_binder.h> #include <widgets/unit_binder.h>
@ -290,7 +290,7 @@ void DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS::processItem( BOARD_COMMIT& aCommit, B
EDA_TEXT* textItem = dynamic_cast<EDA_TEXT*>( aItem ); EDA_TEXT* textItem = dynamic_cast<EDA_TEXT*>( aItem );
FP_TEXT* fpTextItem = dynamic_cast<FP_TEXT*>( aItem ); FP_TEXT* fpTextItem = dynamic_cast<FP_TEXT*>( aItem );
PCB_SHAPE* drawItem = dynamic_cast<PCB_SHAPE*>( aItem ); PCB_SHAPE* drawItem = dynamic_cast<PCB_SHAPE*>( aItem );
DIMENSION_BASE* dimension = dynamic_cast<DIMENSION_BASE*>( aItem ); PCB_DIMENSION_BASE* dimension = dynamic_cast<PCB_DIMENSION_BASE*>( aItem );
if( dimension ) if( dimension )
textItem = &dimension->Text(); textItem = &dimension->Text();

2
pcbnew/drc/drc_test_provider_copper_clearance.cpp
View File

@ -40,7 +40,7 @@
#include <drc/drc_item.h> #include <drc/drc_item.h>
#include <drc/drc_rule.h> #include <drc/drc_rule.h>
#include <drc/drc_test_provider_clearance_base.h> #include <drc/drc_test_provider_clearance_base.h>
#include <dimension.h> #include <pcb_dimension.h>
/* /*
Copper clearance test. Checks all copper items (pads, vias, tracks, drawings, zones) for their electrical clearance. Copper clearance test. Checks all copper items (pads, vias, tracks, drawings, zones) for their electrical clearance.

6
pcbnew/edit.cpp
View File

@ -35,7 +35,7 @@
#include <track.h> #include <track.h>
#include <zone.h> #include <zone.h>
#include <pcb_target.h> #include <pcb_target.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_layer_box_selector.h> #include <pcb_layer_box_selector.h>
#include <dialog_drc.h> #include <dialog_drc.h>
#include <connectivity/connectivity_data.h> #include <connectivity/connectivity_data.h>
@ -139,7 +139,7 @@ void PCB_EDIT_FRAME::OnEditItemRequest( BOARD_ITEM* aItem )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
ShowDimensionPropertiesDialog( static_cast<DIMENSION_BASE*>( aItem ) ); ShowDimensionPropertiesDialog( static_cast<PCB_DIMENSION_BASE*>( aItem ) );
break; break;
case PCB_FP_TEXT_T: case PCB_FP_TEXT_T:
@ -164,7 +164,7 @@ void PCB_EDIT_FRAME::OnEditItemRequest( BOARD_ITEM* aItem )
} }
void PCB_EDIT_FRAME::ShowDimensionPropertiesDialog( DIMENSION_BASE* aDimension ) void PCB_EDIT_FRAME::ShowDimensionPropertiesDialog( PCB_DIMENSION_BASE* aDimension )
{ {
if( aDimension == nullptr ) if( aDimension == nullptr )
return; return;

4
pcbnew/pcb_base_edit_frame.cpp
View File

@ -32,7 +32,7 @@
#include <pgm_base.h> #include <pgm_base.h>
#include <board.h> #include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <footprint_info_impl.h> #include <footprint_info_impl.h>
#include <project.h> #include <project.h>
#include <settings/color_settings.h> #include <settings/color_settings.h>
@ -187,7 +187,7 @@ void PCB_BASE_EDIT_FRAME::unitsChangeRefresh()
INSPECTOR_FUNC inspector = INSPECTOR_FUNC inspector =
[units, view]( EDA_ITEM* aItem, void* aTestData ) [units, view]( EDA_ITEM* aItem, void* aTestData )
{ {
DIMENSION_BASE* dimension = static_cast<DIMENSION_BASE*>( aItem ); PCB_DIMENSION_BASE* dimension = static_cast<PCB_DIMENSION_BASE*>( aItem );
if( dimension->GetUnitsMode() == DIM_UNITS_MODE::AUTOMATIC ) if( dimension->GetUnitsMode() == DIM_UNITS_MODE::AUTOMATIC )
{ {

155
pcbnew/dimension.cpp → pcbnew/pcb_dimension.cpp
View File

@ -28,7 +28,7 @@
#include <pcb_edit_frame.h> #include <pcb_edit_frame.h>
#include <base_units.h> #include <base_units.h>
#include <board.h> #include <board.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <geometry/shape_compound.h> #include <geometry/shape_compound.h>
#include <geometry/shape_circle.h> #include <geometry/shape_circle.h>
@ -39,7 +39,7 @@
#include <i18n_utility.h> #include <i18n_utility.h>
DIMENSION_BASE::DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) : PCB_DIMENSION_BASE::PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) :
BOARD_ITEM( aParent, aType ), BOARD_ITEM( aParent, aType ),
m_overrideTextEnabled( false ), m_overrideTextEnabled( false ),
m_units( EDA_UNITS::INCHES ), m_units( EDA_UNITS::INCHES ),
@ -59,14 +59,14 @@ DIMENSION_BASE::DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType ) :
} }
void DIMENSION_BASE::SetParent( EDA_ITEM* aParent ) void PCB_DIMENSION_BASE::SetParent( EDA_ITEM* aParent )
{ {
BOARD_ITEM::SetParent( aParent ); BOARD_ITEM::SetParent( aParent );
m_text.SetParent( aParent ); m_text.SetParent( aParent );
} }
void DIMENSION_BASE::updateText() void PCB_DIMENSION_BASE::updateText()
{ {
wxString text = m_overrideTextEnabled ? m_valueString : GetValueText(); wxString text = m_overrideTextEnabled ? m_valueString : GetValueText();
@ -95,13 +95,13 @@ void DIMENSION_BASE::updateText()
template<typename ShapeType> template<typename ShapeType>
void DIMENSION_BASE::addShape( const ShapeType& aShape ) void PCB_DIMENSION_BASE::addShape( const ShapeType& aShape )
{ {
m_shapes.push_back( std::make_shared<ShapeType>( aShape ) ); m_shapes.push_back( std::make_shared<ShapeType>( aShape ) );
} }
wxString DIMENSION_BASE::GetValueText() const wxString PCB_DIMENSION_BASE::GetValueText() const
{ {
struct lconv* lc = localeconv(); struct lconv* lc = localeconv();
wxChar sep = lc->decimal_point[0]; wxChar sep = lc->decimal_point[0];
@ -130,25 +130,25 @@ wxString DIMENSION_BASE::GetValueText() const
} }
void DIMENSION_BASE::SetPrefix( const wxString& aPrefix ) void PCB_DIMENSION_BASE::SetPrefix( const wxString& aPrefix )
{ {
m_prefix = aPrefix; m_prefix = aPrefix;
} }
void DIMENSION_BASE::SetSuffix( const wxString& aSuffix ) void PCB_DIMENSION_BASE::SetSuffix( const wxString& aSuffix )
{ {
m_suffix = aSuffix; m_suffix = aSuffix;
} }
void DIMENSION_BASE::SetUnits( EDA_UNITS aUnits ) void PCB_DIMENSION_BASE::SetUnits( EDA_UNITS aUnits )
{ {
m_units = aUnits; m_units = aUnits;
} }
DIM_UNITS_MODE DIMENSION_BASE::GetUnitsMode() const DIM_UNITS_MODE PCB_DIMENSION_BASE::GetUnitsMode() const
{ {
if( m_autoUnits ) if( m_autoUnits )
{ {
@ -172,7 +172,7 @@ DIM_UNITS_MODE DIMENSION_BASE::GetUnitsMode() const
} }
void DIMENSION_BASE::SetUnitsMode( DIM_UNITS_MODE aMode ) void PCB_DIMENSION_BASE::SetUnitsMode( DIM_UNITS_MODE aMode )
{ {
m_autoUnits = false; m_autoUnits = false;
@ -197,27 +197,27 @@ void DIMENSION_BASE::SetUnitsMode( DIM_UNITS_MODE aMode )
} }
void DIMENSION_BASE::SetText( const wxString& aNewText ) void PCB_DIMENSION_BASE::SetText( const wxString& aNewText )
{ {
m_valueString = aNewText; m_valueString = aNewText;
updateText(); updateText();
} }
const wxString DIMENSION_BASE::GetText() const const wxString PCB_DIMENSION_BASE::GetText() const
{ {
return m_text.GetText(); return m_text.GetText();
} }
void DIMENSION_BASE::SetLayer( PCB_LAYER_ID aLayer ) void PCB_DIMENSION_BASE::SetLayer( PCB_LAYER_ID aLayer )
{ {
m_layer = aLayer; m_layer = aLayer;
m_text.SetLayer( aLayer ); m_text.SetLayer( aLayer );
} }
void DIMENSION_BASE::Move( const wxPoint& offset ) void PCB_DIMENSION_BASE::Move( const wxPoint& offset )
{ {
m_text.Offset( offset ); m_text.Offset( offset );
@ -228,7 +228,7 @@ void DIMENSION_BASE::Move( const wxPoint& offset )
} }
void DIMENSION_BASE::Rotate( const wxPoint& aRotCentre, double aAngle ) void PCB_DIMENSION_BASE::Rotate( const wxPoint& aRotCentre, double aAngle )
{ {
double newAngle = m_text.GetTextAngle() + aAngle; double newAngle = m_text.GetTextAngle() + aAngle;
@ -248,7 +248,7 @@ void DIMENSION_BASE::Rotate( const wxPoint& aRotCentre, double aAngle )
} }
void DIMENSION_BASE::Flip( const wxPoint& aCentre, bool aFlipLeftRight ) void PCB_DIMENSION_BASE::Flip( const wxPoint& aCentre, bool aFlipLeftRight )
{ {
Mirror( aCentre ); Mirror( aCentre );
@ -256,7 +256,7 @@ void DIMENSION_BASE::Flip( const wxPoint& aCentre, bool aFlipLeftRight )
} }
void DIMENSION_BASE::Mirror( const wxPoint& axis_pos, bool aMirrorLeftRight ) void PCB_DIMENSION_BASE::Mirror( const wxPoint& axis_pos, bool aMirrorLeftRight )
{ {
int axis = aMirrorLeftRight ? axis_pos.x : axis_pos.y; int axis = aMirrorLeftRight ? axis_pos.x : axis_pos.y;
wxPoint newPos = m_text.GetTextPos(); wxPoint newPos = m_text.GetTextPos();
@ -289,7 +289,7 @@ void DIMENSION_BASE::Mirror( const wxPoint& axis_pos, bool aMirrorLeftRight )
} }
void DIMENSION_BASE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) void PCB_DIMENSION_BASE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{ {
// for now, display only the text within the DIMENSION using class PCB_TEXT. // for now, display only the text within the DIMENSION using class PCB_TEXT.
wxString msg; wxString msg;
@ -352,7 +352,7 @@ void DIMENSION_BASE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PA
} }
std::shared_ptr<SHAPE> DIMENSION_BASE::GetEffectiveShape( PCB_LAYER_ID aLayer ) const std::shared_ptr<SHAPE> PCB_DIMENSION_BASE::GetEffectiveShape( PCB_LAYER_ID aLayer ) const
{ {
std::shared_ptr<SHAPE_COMPOUND> effectiveShape = std::make_shared<SHAPE_COMPOUND>(); std::shared_ptr<SHAPE_COMPOUND> effectiveShape = std::make_shared<SHAPE_COMPOUND>();
@ -365,7 +365,7 @@ std::shared_ptr<SHAPE> DIMENSION_BASE::GetEffectiveShape( PCB_LAYER_ID aLayer )
} }
bool DIMENSION_BASE::HitTest( const wxPoint& aPosition, int aAccuracy ) const bool PCB_DIMENSION_BASE::HitTest( const wxPoint& aPosition, int aAccuracy ) const
{ {
if( m_text.TextHitTest( aPosition ) ) if( m_text.TextHitTest( aPosition ) )
return true; return true;
@ -384,7 +384,7 @@ bool DIMENSION_BASE::HitTest( const wxPoint& aPosition, int aAccuracy ) const
} }
bool DIMENSION_BASE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const bool PCB_DIMENSION_BASE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
{ {
EDA_RECT arect = aRect; EDA_RECT arect = aRect;
arect.Inflate( aAccuracy ); arect.Inflate( aAccuracy );
@ -401,7 +401,7 @@ bool DIMENSION_BASE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccur
} }
const EDA_RECT DIMENSION_BASE::GetBoundingBox() const const EDA_RECT PCB_DIMENSION_BASE::GetBoundingBox() const
{ {
EDA_RECT bBox; EDA_RECT bBox;
int xmin, xmax, ymin, ymax; int xmin, xmax, ymin, ymax;
@ -434,7 +434,7 @@ const EDA_RECT DIMENSION_BASE::GetBoundingBox() const
} }
wxString DIMENSION_BASE::GetSelectMenuText( EDA_UNITS aUnits ) const wxString PCB_DIMENSION_BASE::GetSelectMenuText( EDA_UNITS aUnits ) const
{ {
return wxString::Format( _( "Dimension '%s' on %s" ), return wxString::Format( _( "Dimension '%s' on %s" ),
GetText(), GetText(),
@ -443,7 +443,7 @@ wxString DIMENSION_BASE::GetSelectMenuText( EDA_UNITS aUnits ) const
const BOX2I DIMENSION_BASE::ViewBBox() const 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() ) );
@ -453,7 +453,8 @@ const BOX2I DIMENSION_BASE::ViewBBox() const
} }
OPT_VECTOR2I DIMENSION_BASE::segPolyIntersection( const SHAPE_POLY_SET& aPoly, const SEG& aSeg, bool aStart ) OPT_VECTOR2I PCB_DIMENSION_BASE::segPolyIntersection( const SHAPE_POLY_SET& aPoly, const SEG& aSeg,
bool aStart )
{ {
VECTOR2I start( aStart ? aSeg.A : aSeg.B ); VECTOR2I start( aStart ? aSeg.A : aSeg.B );
VECTOR2I endpoint( aStart ? aSeg.B : aSeg.A ); VECTOR2I endpoint( aStart ? aSeg.B : aSeg.A );
@ -477,7 +478,7 @@ OPT_VECTOR2I DIMENSION_BASE::segPolyIntersection( const SHAPE_POLY_SET& aPoly, c
} }
OPT_VECTOR2I DIMENSION_BASE::segCircleIntersection( CIRCLE& aCircle, SEG& aSeg, bool aStart ) OPT_VECTOR2I PCB_DIMENSION_BASE::segCircleIntersection( CIRCLE& aCircle, SEG& aSeg, bool aStart )
{ {
VECTOR2I start( aStart ? aSeg.A : aSeg.B ); VECTOR2I start( aStart ? aSeg.A : aSeg.B );
VECTOR2I endpoint( aStart ? aSeg.B : aSeg.A ); VECTOR2I endpoint( aStart ? aSeg.B : aSeg.A );
@ -501,8 +502,8 @@ OPT_VECTOR2I DIMENSION_BASE::segCircleIntersection( CIRCLE& aCircle, SEG& aSeg,
} }
ALIGNED_DIMENSION::ALIGNED_DIMENSION( BOARD_ITEM* aParent, KICAD_T aType ) : PCB_DIM_ALIGNED::PCB_DIM_ALIGNED( BOARD_ITEM* aParent, KICAD_T aType ) :
DIMENSION_BASE( aParent, aType ), PCB_DIMENSION_BASE( aParent, aType ),
m_height( 0 ) m_height( 0 )
{ {
// To preserve look of old dimensions, initialize extension height based on default arrow length // To preserve look of old dimensions, initialize extension height based on default arrow length
@ -510,32 +511,31 @@ ALIGNED_DIMENSION::ALIGNED_DIMENSION( BOARD_ITEM* aParent, KICAD_T aType ) :
} }
EDA_ITEM* ALIGNED_DIMENSION::Clone() const EDA_ITEM* PCB_DIM_ALIGNED::Clone() const
{ {
return new ALIGNED_DIMENSION( *this ); return new PCB_DIM_ALIGNED( *this );
} }
void ALIGNED_DIMENSION::SwapData( BOARD_ITEM* aImage ) void PCB_DIM_ALIGNED::SwapData( BOARD_ITEM* aImage )
{ {
assert( aImage->Type() == PCB_DIM_ALIGNED_T ); assert( aImage->Type() == PCB_DIM_ALIGNED_T );
m_shapes.clear(); m_shapes.clear();
static_cast<ALIGNED_DIMENSION*>( aImage )->m_shapes.clear(); static_cast<PCB_DIM_ALIGNED*>( aImage )->m_shapes.clear();
std::swap( *static_cast<ALIGNED_DIMENSION*>( this ), std::swap( *static_cast<PCB_DIM_ALIGNED*>( this ), *static_cast<PCB_DIM_ALIGNED*>( aImage ) );
*static_cast<ALIGNED_DIMENSION*>( aImage ) );
Update(); Update();
} }
BITMAPS ALIGNED_DIMENSION::GetMenuImage() const BITMAPS PCB_DIM_ALIGNED::GetMenuImage() const
{ {
return BITMAPS::add_aligned_dimension; return BITMAPS::add_aligned_dimension;
} }
void ALIGNED_DIMENSION::UpdateHeight( const wxPoint& aCrossbarStart, const wxPoint& aCrossbarEnd ) void PCB_DIM_ALIGNED::UpdateHeight( const wxPoint& aCrossbarStart, const wxPoint& aCrossbarEnd )
{ {
VECTOR2D height( aCrossbarStart - GetStart() ); VECTOR2D height( aCrossbarStart - GetStart() );
VECTOR2D crossBar( aCrossbarEnd - aCrossbarStart ); VECTOR2D crossBar( aCrossbarEnd - aCrossbarStart );
@ -549,7 +549,7 @@ void ALIGNED_DIMENSION::UpdateHeight( const wxPoint& aCrossbarStart, const wxPoi
} }
void ALIGNED_DIMENSION::updateGeometry() void PCB_DIM_ALIGNED::updateGeometry()
{ {
m_shapes.clear(); m_shapes.clear();
@ -637,7 +637,7 @@ void ALIGNED_DIMENSION::updateGeometry()
} }
void ALIGNED_DIMENSION::updateText() void PCB_DIM_ALIGNED::updateText()
{ {
VECTOR2I crossbarCenter( ( m_crossBarEnd - m_crossBarStart ) / 2 ); VECTOR2I crossbarCenter( ( m_crossBarEnd - m_crossBarStart ) / 2 );
@ -673,21 +673,20 @@ void ALIGNED_DIMENSION::updateText()
m_text.SetTextAngle( textAngle ); m_text.SetTextAngle( textAngle );
} }
DIMENSION_BASE::updateText(); PCB_DIMENSION_BASE::updateText();
} }
void ALIGNED_DIMENSION::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, void PCB_DIM_ALIGNED::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
std::vector<MSG_PANEL_ITEM>& aList )
{ {
DIMENSION_BASE::GetMsgPanelInfo( aFrame, aList ); PCB_DIMENSION_BASE::GetMsgPanelInfo( aFrame, aList );
aList.emplace_back( _( "Height" ), MessageTextFromValue( aFrame->GetUserUnits(), m_height ) ); aList.emplace_back( _( "Height" ), MessageTextFromValue( aFrame->GetUserUnits(), m_height ) );
} }
ORTHOGONAL_DIMENSION::ORTHOGONAL_DIMENSION( BOARD_ITEM* aParent ) : PCB_DIM_ORTHOGONAL::PCB_DIM_ORTHOGONAL( BOARD_ITEM* aParent ) :
ALIGNED_DIMENSION( aParent, PCB_DIM_ORTHOGONAL_T ) PCB_DIM_ALIGNED( aParent, PCB_DIM_ORTHOGONAL_T )
{ {
// To preserve look of old dimensions, initialize extension height based on default arrow length // To preserve look of old dimensions, initialize extension height based on default arrow length
m_extensionHeight = static_cast<int>( m_arrowLength * std::sin( DEG2RAD( s_arrowAngle ) ) ); m_extensionHeight = static_cast<int>( m_arrowLength * std::sin( DEG2RAD( s_arrowAngle ) ) );
@ -695,33 +694,33 @@ ORTHOGONAL_DIMENSION::ORTHOGONAL_DIMENSION( BOARD_ITEM* aParent ) :
} }
EDA_ITEM* ORTHOGONAL_DIMENSION::Clone() const EDA_ITEM* PCB_DIM_ORTHOGONAL::Clone() const
{ {
return new ORTHOGONAL_DIMENSION( *this ); return new PCB_DIM_ORTHOGONAL( *this );
} }
void ORTHOGONAL_DIMENSION::SwapData( BOARD_ITEM* aImage ) void PCB_DIM_ORTHOGONAL::SwapData( BOARD_ITEM* aImage )
{ {
assert( aImage->Type() == PCB_DIM_ORTHOGONAL_T ); assert( aImage->Type() == PCB_DIM_ORTHOGONAL_T );
m_shapes.clear(); m_shapes.clear();
static_cast<ORTHOGONAL_DIMENSION*>( aImage )->m_shapes.clear(); static_cast<PCB_DIM_ORTHOGONAL*>( aImage )->m_shapes.clear();
std::swap( *static_cast<ORTHOGONAL_DIMENSION*>( this ), std::swap( *static_cast<PCB_DIM_ORTHOGONAL*>( this ),
*static_cast<ORTHOGONAL_DIMENSION*>( aImage ) ); *static_cast<PCB_DIM_ORTHOGONAL*>( aImage ) );
Update(); Update();
} }
BITMAPS ORTHOGONAL_DIMENSION::GetMenuImage() const BITMAPS PCB_DIM_ORTHOGONAL::GetMenuImage() const
{ {
return BITMAPS::add_orthogonal_dimension; return BITMAPS::add_orthogonal_dimension;
} }
void ORTHOGONAL_DIMENSION::updateGeometry() void PCB_DIM_ORTHOGONAL::updateGeometry()
{ {
m_shapes.clear(); m_shapes.clear();
@ -822,7 +821,7 @@ void ORTHOGONAL_DIMENSION::updateGeometry()
} }
void ORTHOGONAL_DIMENSION::updateText() void PCB_DIM_ORTHOGONAL::updateText()
{ {
VECTOR2I crossbarCenter( ( m_crossBarEnd - m_crossBarStart ) / 2 ); VECTOR2I crossbarCenter( ( m_crossBarEnd - m_crossBarStart ) / 2 );
@ -856,11 +855,11 @@ void ORTHOGONAL_DIMENSION::updateText()
m_text.SetTextAngle( textAngle ); m_text.SetTextAngle( textAngle );
} }
DIMENSION_BASE::updateText(); PCB_DIMENSION_BASE::updateText();
} }
void ORTHOGONAL_DIMENSION::Rotate( const wxPoint& aRotCentre, double aAngle ) void PCB_DIM_ORTHOGONAL::Rotate( const wxPoint& aRotCentre, double aAngle )
{ {
// restrict angle to -179.9 to 180.0 degrees // restrict angle to -179.9 to 180.0 degrees
if( aAngle > 1800 ) if( aAngle > 1800 )
@ -910,12 +909,12 @@ void ORTHOGONAL_DIMENSION::Rotate( const wxPoint& aRotCentre, double aAngle )
} }
// this will update m_crossBarStart and m_crossbarEnd // this will update m_crossBarStart and m_crossbarEnd
DIMENSION_BASE::Rotate( aRotCentre, aAngle ); PCB_DIMENSION_BASE::Rotate( aRotCentre, aAngle );
} }
LEADER::LEADER( BOARD_ITEM* aParent ) : PCB_DIM_LEADER::PCB_DIM_LEADER( BOARD_ITEM* aParent ) :
DIMENSION_BASE( aParent, PCB_DIM_LEADER_T ), PCB_DIMENSION_BASE( aParent, PCB_DIM_LEADER_T ),
m_textFrame( DIM_TEXT_FRAME::NONE ) m_textFrame( DIM_TEXT_FRAME::NONE )
{ {
m_unitsFormat = DIM_UNITS_FORMAT::NO_SUFFIX; m_unitsFormat = DIM_UNITS_FORMAT::NO_SUFFIX;
@ -924,27 +923,27 @@ LEADER::LEADER( BOARD_ITEM* aParent ) :
} }
EDA_ITEM* LEADER::Clone() const EDA_ITEM* PCB_DIM_LEADER::Clone() const
{ {
return new LEADER( *this ); return new PCB_DIM_LEADER( *this );
} }
void LEADER::SwapData( BOARD_ITEM* aImage ) void PCB_DIM_LEADER::SwapData( BOARD_ITEM* aImage )
{ {
assert( aImage->Type() == PCB_DIM_LEADER_T ); assert( aImage->Type() == PCB_DIM_LEADER_T );
std::swap( *static_cast<LEADER*>( this ), *static_cast<LEADER*>( aImage ) ); std::swap( *static_cast<PCB_DIM_LEADER*>( this ), *static_cast<PCB_DIM_LEADER*>( aImage ) );
} }
BITMAPS LEADER::GetMenuImage() const BITMAPS PCB_DIM_LEADER::GetMenuImage() const
{ {
return BITMAPS::add_leader; return BITMAPS::add_leader;
} }
void LEADER::updateGeometry() void PCB_DIM_LEADER::updateGeometry()
{ {
m_shapes.clear(); m_shapes.clear();
@ -1035,7 +1034,7 @@ void LEADER::updateGeometry()
} }
void 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 )
{ {
wxString msg; wxString msg;
@ -1055,35 +1054,35 @@ void LEADER::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM
} }
CENTER_DIMENSION::CENTER_DIMENSION( BOARD_ITEM* aParent ) : PCB_DIM_CENTER::PCB_DIM_CENTER( BOARD_ITEM* aParent ) :
DIMENSION_BASE( aParent, PCB_DIM_CENTER_T ) PCB_DIMENSION_BASE( aParent, PCB_DIM_CENTER_T )
{ {
m_unitsFormat = DIM_UNITS_FORMAT::NO_SUFFIX; m_unitsFormat = DIM_UNITS_FORMAT::NO_SUFFIX;
m_overrideTextEnabled = true; m_overrideTextEnabled = true;
} }
EDA_ITEM* CENTER_DIMENSION::Clone() const EDA_ITEM* PCB_DIM_CENTER::Clone() const
{ {
return new CENTER_DIMENSION( *this ); return new PCB_DIM_CENTER( *this );
} }
void CENTER_DIMENSION::SwapData( BOARD_ITEM* aImage ) void PCB_DIM_CENTER::SwapData( BOARD_ITEM* aImage )
{ {
assert( aImage->Type() == PCB_DIM_CENTER_T ); assert( aImage->Type() == PCB_DIM_CENTER_T );
std::swap( *static_cast<CENTER_DIMENSION*>( this ), *static_cast<CENTER_DIMENSION*>( aImage ) ); std::swap( *static_cast<PCB_DIM_CENTER*>( this ), *static_cast<PCB_DIM_CENTER*>( aImage ) );
} }
BITMAPS CENTER_DIMENSION::GetMenuImage() const BITMAPS PCB_DIM_CENTER::GetMenuImage() const
{ {
return BITMAPS::add_center_dimension; return BITMAPS::add_center_dimension;
} }
const EDA_RECT CENTER_DIMENSION::GetBoundingBox() const const EDA_RECT PCB_DIM_CENTER::GetBoundingBox() const
{ {
int halfWidth = VECTOR2I( m_end - m_start ).x + ( m_lineThickness / 2.0 ); int halfWidth = VECTOR2I( m_end - m_start ).x + ( m_lineThickness / 2.0 );
@ -1100,14 +1099,14 @@ const EDA_RECT CENTER_DIMENSION::GetBoundingBox() const
} }
const BOX2I CENTER_DIMENSION::ViewBBox() const const BOX2I PCB_DIM_CENTER::ViewBBox() const
{ {
return BOX2I( VECTOR2I( GetBoundingBox().GetPosition() ), return BOX2I( VECTOR2I( GetBoundingBox().GetPosition() ),
VECTOR2I( GetBoundingBox().GetSize() ) ); VECTOR2I( GetBoundingBox().GetSize() ) );
} }
void CENTER_DIMENSION::updateGeometry() void PCB_DIM_CENTER::updateGeometry()
{ {
m_shapes.clear(); m_shapes.clear();
@ -1127,8 +1126,8 @@ static struct DIMENSION_DESC
DIMENSION_DESC() DIMENSION_DESC()
{ {
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance(); PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
REGISTER_TYPE( DIMENSION_BASE ); REGISTER_TYPE( PCB_DIMENSION_BASE );
propMgr.InheritsAfter( TYPE_HASH( DIMENSION_BASE ), TYPE_HASH( BOARD_ITEM ) ); propMgr.InheritsAfter( TYPE_HASH( PCB_DIMENSION_BASE ), TYPE_HASH( BOARD_ITEM ) );
// TODO: add dimension properties: // TODO: add dimension properties:
//propMgr.AddProperty( new PROPERTY<DIMENSION, int>( _HKI( "Height" ), //propMgr.AddProperty( new PROPERTY<DIMENSION, int>( _HKI( "Height" ),
//&DIMENSION::SetHeight, &DIMENSION::GetHeight, PROPERTY_DISPLAY::DISTANCE ) ); //&DIMENSION::SetHeight, &DIMENSION::GetHeight, PROPERTY_DISPLAY::DISTANCE ) );

36
pcbnew/dimension.h → pcbnew/pcb_dimension.h
View File

@ -22,8 +22,8 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
#ifndef DIMENSION_H #ifndef PCB_DIMENSION_H
#define DIMENSION_H #define PCB_DIMENSION_H
#include <board_item.h> #include <board_item.h>
@ -92,10 +92,10 @@ enum class DIM_TEXT_FRAME
* - "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 DIMENSION_BASE : public BOARD_ITEM class PCB_DIMENSION_BASE : public BOARD_ITEM
{ {
public: public:
DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIMENSION_T ); PCB_DIMENSION_BASE( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIMENSION_T );
bool IsType( const KICAD_T aScanTypes[] ) const override bool IsType( const KICAD_T aScanTypes[] ) const override
{ {
@ -338,15 +338,15 @@ protected:
* The height (distance from features to crossbar) can be set directly, or set by manipulating the * The height (distance from features to crossbar) can be set directly, or set by manipulating the
* crossbar start or end point (with the point editor). * crossbar start or end point (with the point editor).
*/ */
class ALIGNED_DIMENSION : public DIMENSION_BASE class PCB_DIM_ALIGNED : public PCB_DIMENSION_BASE
{ {
public: public:
ALIGNED_DIMENSION( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIM_ALIGNED_T ); PCB_DIM_ALIGNED( BOARD_ITEM* aParent, KICAD_T aType = PCB_DIM_ALIGNED_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.
~ALIGNED_DIMENSION() = default; ~PCB_DIM_ALIGNED() = default;
static inline bool ClassOf( const EDA_ITEM* aItem ) static inline bool ClassOf( const EDA_ITEM* aItem )
{ {
@ -395,7 +395,7 @@ public:
wxString GetClass() const override wxString GetClass() const override
{ {
return wxT( "ALIGNED_DIMENSION" ); return wxT( "PCB_DIM_ALIGNED" );
} }
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;
@ -419,7 +419,7 @@ protected:
* An orthogonal dimension is like an aligned dimension, but the extension lines are locked to the * An orthogonal dimension is like an aligned dimension, but the extension lines are locked to the
* X or Y axes, and the measurement is only taken in the X or Y direction. * X or Y axes, and the measurement is only taken in the X or Y direction.
*/ */
class ORTHOGONAL_DIMENSION : public ALIGNED_DIMENSION class PCB_DIM_ORTHOGONAL : public PCB_DIM_ALIGNED
{ {
public: public:
enum class DIR enum class DIR
@ -428,9 +428,9 @@ public:
VERTICAL // Aligned with y-axis VERTICAL // Aligned with y-axis
}; };
ORTHOGONAL_DIMENSION( BOARD_ITEM* aParent ); PCB_DIM_ORTHOGONAL( BOARD_ITEM* aParent );
~ORTHOGONAL_DIMENSION() = default; ~PCB_DIM_ORTHOGONAL() = default;
static inline bool ClassOf( const EDA_ITEM* aItem ) static inline bool ClassOf( const EDA_ITEM* aItem )
{ {
@ -453,7 +453,7 @@ public:
wxString GetClass() const override wxString GetClass() const override
{ {
return wxT( "ORTHOGONAL_DIMENSION" ); return wxT( "PCB_DIM_ORTHOGONAL" );
} }
void Rotate( const wxPoint& aRotCentre, double aAngle ) override; void Rotate( const wxPoint& aRotCentre, double aAngle ) override;
@ -483,10 +483,10 @@ private:
* Point (a) is m_start, point (b) is m_end, point (c) is the end of the "text line" * Point (a) is m_start, point (b) is m_end, point (c) is the end of the "text line"
* The b-c line is drawn from b to the text center, and clipped on the text bounding box. * The b-c line is drawn from b to the text center, and clipped on the text bounding box.
*/ */
class LEADER : public DIMENSION_BASE class PCB_DIM_LEADER : public PCB_DIMENSION_BASE
{ {
public: public:
LEADER( BOARD_ITEM* aParent ); PCB_DIM_LEADER( BOARD_ITEM* aParent );
static inline bool ClassOf( const EDA_ITEM* aItem ) static inline bool ClassOf( const EDA_ITEM* aItem )
{ {
@ -501,7 +501,7 @@ public:
wxString GetClass() const override wxString GetClass() const override
{ {
return wxT( "LEADER" ); return wxT( "PCB_DIM_LEADER" );
} }
void SetTextFrame( DIM_TEXT_FRAME aFrame ) { m_textFrame = aFrame; } void SetTextFrame( DIM_TEXT_FRAME aFrame ) { m_textFrame = aFrame; }
@ -523,10 +523,10 @@ private:
* The size and orientation of the cross is adjustable. * The size and orientation of the cross is adjustable.
* m_start always marks the center being measured; m_end marks the end of one leg of the cross. * m_start always marks the center being measured; m_end marks the end of one leg of the cross.
*/ */
class CENTER_DIMENSION : public DIMENSION_BASE class PCB_DIM_CENTER : public PCB_DIMENSION_BASE
{ {
public: public:
CENTER_DIMENSION( BOARD_ITEM* aParent ); PCB_DIM_CENTER( BOARD_ITEM* aParent );
static inline bool ClassOf( const EDA_ITEM* aItem ) static inline bool ClassOf( const EDA_ITEM* aItem )
{ {
@ -541,7 +541,7 @@ public:
wxString GetClass() const override wxString GetClass() const override
{ {
return wxT( "CENTER_DIMENSION" ); return wxT( "PCB_DIM_CENTER" );
} }
const EDA_RECT GetBoundingBox() const override; const EDA_RECT GetBoundingBox() const override;

4
pcbnew/pcb_edit_frame.h
View File

@ -38,7 +38,7 @@ class VIA;
class PAD; class PAD;
class PCB_TARGET; class PCB_TARGET;
class PCB_GROUP; class PCB_GROUP;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class DRC; class DRC;
class DIALOG_PLOT; class DIALOG_PLOT;
class ZONE; class ZONE;
@ -555,7 +555,7 @@ public:
// Properties dialogs // Properties dialogs
void ShowTargetOptionsDialog( PCB_TARGET* aTarget ); void ShowTargetOptionsDialog( PCB_TARGET* aTarget );
void ShowDimensionPropertiesDialog( DIMENSION_BASE* aDimension ); void ShowDimensionPropertiesDialog( PCB_DIMENSION_BASE* aDimension );
void InstallNetlistFrame(); void InstallNetlistFrame();
/** /**

6
pcbnew/pcb_painter.cpp
View File

@ -34,7 +34,7 @@
#include <zone.h> #include <zone.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <pcb_marker.h> #include <pcb_marker.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_target.h> #include <pcb_target.h>
#include <advanced_config.h> #include <advanced_config.h>
#include <core/arraydim.h> #include <core/arraydim.h>
@ -522,7 +522,7 @@ bool PCB_PAINTER::Draw( const VIEW_ITEM* aItem, int aLayer )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
draw( static_cast<const DIMENSION_BASE*>( item ), aLayer ); draw( static_cast<const PCB_DIMENSION_BASE*>( item ), aLayer );
break; break;
case PCB_TARGET_T: case PCB_TARGET_T:
@ -1686,7 +1686,7 @@ void PCB_PAINTER::draw( const ZONE* aZone, int aLayer )
} }
void PCB_PAINTER::draw( const DIMENSION_BASE* aDimension, int aLayer ) void PCB_PAINTER::draw( const PCB_DIMENSION_BASE* aDimension, int aLayer )
{ {
const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer ); const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );

4
pcbnew/pcb_painter.h
View File

@ -48,7 +48,7 @@ class FOOTPRINT;
class ZONE; class ZONE;
class PCB_TEXT; class PCB_TEXT;
class FP_TEXT; class FP_TEXT;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class PCB_TARGET; class PCB_TARGET;
class PCB_MARKER; class PCB_MARKER;
class NET_SETTINGS; class NET_SETTINGS;
@ -264,7 +264,7 @@ protected:
void draw( const FOOTPRINT* aFootprint, int aLayer ); void draw( const FOOTPRINT* aFootprint, int aLayer );
void draw( const PCB_GROUP* aGroup, int aLayer ); void draw( const PCB_GROUP* aGroup, int aLayer );
void draw( const ZONE* aZone, int aLayer ); void draw( const ZONE* aZone, int aLayer );
void draw( const DIMENSION_BASE* aDimension, int aLayer ); void draw( const PCB_DIMENSION_BASE* aDimension, int aLayer );
void draw( const PCB_TARGET* aTarget ); void draw( const PCB_TARGET* aTarget );
void draw( const PCB_MARKER* aMarker, int aLayer ); void draw( const PCB_MARKER* aMarker, int aLayer );

4
pcbnew/pcbplot.h
View File

@ -39,7 +39,7 @@ class PLOTTER;
class PCB_TEXT; class PCB_TEXT;
class PAD; class PAD;
class PCB_SHAPE; class PCB_SHAPE;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class FOOTPRINT; class FOOTPRINT;
class FP_SHAPE; class FP_SHAPE;
class PCB_TARGET; class PCB_TARGET;
@ -92,7 +92,7 @@ public:
*/ */
void PlotFootprintTextItems( const FOOTPRINT* aFootprint ); void PlotFootprintTextItems( const FOOTPRINT* aFootprint );
void PlotDimension( const DIMENSION_BASE* aDim ); void PlotDimension( const PCB_DIMENSION_BASE* aDim );
void PlotPcbTarget( const PCB_TARGET* aMire ); void PlotPcbTarget( const PCB_TARGET* aMire );
void PlotFilledAreas( const ZONE* aZone, const SHAPE_POLY_SET& aPolysList ); void PlotFilledAreas( const ZONE* aZone, const SHAPE_POLY_SET& aPolysList );
void PlotPcbText( const PCB_TEXT* aText ); void PlotPcbText( const PCB_TEXT* aText );

2
pcbnew/plot_board_layers.cpp
View File

@ -46,7 +46,7 @@
#include <zone.h> #include <zone.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <pcb_target.h> #include <pcb_target.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcbplot.h> #include <pcbplot.h>
#include <plotters_specific.h> #include <plotters_specific.h>

6
pcbnew/plot_brditems_plotter.cpp
View File

@ -54,7 +54,7 @@
#include <board.h> #include <board.h>
#include <board_item.h> // for BOARD_ITEM, S_CIRCLE #include <board_item.h> // for BOARD_ITEM, S_CIRCLE
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <footprint.h> #include <footprint.h>
@ -355,7 +355,7 @@ void BRDITEMS_PLOTTER::PlotBoardGraphicItems()
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
PlotDimension( (DIMENSION_BASE*) item ); PlotDimension( (PCB_DIMENSION_BASE*) item );
break; break;
case PCB_TARGET_T: case PCB_TARGET_T:
@ -407,7 +407,7 @@ void BRDITEMS_PLOTTER::PlotFootprintTextItem( const FP_TEXT* aTextMod, COLOR4D a
} }
void BRDITEMS_PLOTTER::PlotDimension( const DIMENSION_BASE* aDim ) void BRDITEMS_PLOTTER::PlotDimension( const PCB_DIMENSION_BASE* aDim )
{ {
if( !m_layerMask[aDim->GetLayer()] ) if( !m_layerMask[aDim->GetLayer()] )
return; return;

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

@ -28,7 +28,7 @@
#include <board.h> #include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pad.h> #include <pad.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <pcb_text.h> #include <pcb_text.h>
@ -924,7 +924,7 @@ void ALTIUM_PCB::HelperParseDimensions6Linear( const ADIMENSION6& aElem )
wxPoint referencePoint0 = aElem.referencePoint.at( 0 ); wxPoint referencePoint0 = aElem.referencePoint.at( 0 );
wxPoint referencePoint1 = aElem.referencePoint.at( 1 ); wxPoint referencePoint1 = aElem.referencePoint.at( 1 );
ALIGNED_DIMENSION* dimension = new ALIGNED_DIMENSION( m_board ); PCB_DIM_ALIGNED* dimension = new PCB_DIM_ALIGNED( m_board );
m_board->Add( dimension, ADD_MODE::APPEND ); m_board->Add( dimension, ADD_MODE::APPEND );
dimension->SetPrecision( aElem.textprecision ); dimension->SetPrecision( aElem.textprecision );
@ -1102,7 +1102,7 @@ void ALTIUM_PCB::HelperParseDimensions6Center( const ADIMENSION6& aElem )
wxPoint vec = wxPoint( 0, aElem.height / 2 ); wxPoint vec = wxPoint( 0, aElem.height / 2 );
RotatePoint( &vec, aElem.angle * 10. ); RotatePoint( &vec, aElem.angle * 10. );
CENTER_DIMENSION* dimension = new CENTER_DIMENSION( m_board ); PCB_DIM_CENTER* dimension = new PCB_DIM_CENTER( m_board );
m_board->Add( dimension, ADD_MODE::APPEND ); m_board->Add( dimension, ADD_MODE::APPEND );
dimension->SetLayer( klayer ); dimension->SetLayer( klayer );
dimension->SetLineThickness( aElem.linewidth ); dimension->SetLineThickness( aElem.linewidth );

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

@ -29,7 +29,7 @@
#include <board_stackup_manager/stackup_predefined_prms.h> // KEY_COPPER, KEY_CORE, KEY_PREPREG #include <board_stackup_manager/stackup_predefined_prms.h> // KEY_COPPER, KEY_CORE, KEY_PREPREG
#include <board.h> #include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <footprint.h> #include <footprint.h>
@ -1311,21 +1311,21 @@ void CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions()
csDim.ID ) ); csDim.ID ) );
} }
ALIGNED_DIMENSION* dimension = nullptr; PCB_DIM_ALIGNED* dimension = nullptr;
if( csDim.Subtype == DIMENSION::SUBTYPE::ORTHOGONAL ) if( csDim.Subtype == DIMENSION::SUBTYPE::ORTHOGONAL )
{ {
dimension = new ORTHOGONAL_DIMENSION( m_board ); dimension = new PCB_DIM_ORTHOGONAL( m_board );
ORTHOGONAL_DIMENSION* orDim = static_cast<ORTHOGONAL_DIMENSION*>( dimension ); PCB_DIM_ORTHOGONAL* orDim = static_cast<PCB_DIM_ORTHOGONAL*>( dimension );
if( csDim.ExtensionLineParams.Start.x == csDim.Line.Start.x ) if( csDim.ExtensionLineParams.Start.x == csDim.Line.Start.x )
orDim->SetOrientation( ORTHOGONAL_DIMENSION::DIR::HORIZONTAL ); orDim->SetOrientation( PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
else else
orDim->SetOrientation( ORTHOGONAL_DIMENSION::DIR::VERTICAL ); orDim->SetOrientation( PCB_DIM_ORTHOGONAL::DIR::VERTICAL );
} }
else else
{ {
dimension = new ALIGNED_DIMENSION( m_board ); dimension = new PCB_DIM_ALIGNED( m_board );
} }
m_board->Add( dimension, ADD_MODE::APPEND ); m_board->Add( dimension, ADD_MODE::APPEND );
@ -1374,7 +1374,7 @@ void CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions()
if( csDim.Line.Style == DIMENSION::LINE::STYLE::INTERNAL ) if( csDim.Line.Style == DIMENSION::LINE::STYLE::INTERNAL )
{ {
// "internal" is a simple double sided arrow from start to end (no extension lines) // "internal" is a simple double sided arrow from start to end (no extension lines)
ALIGNED_DIMENSION* dimension = new ALIGNED_DIMENSION( m_board ); PCB_DIM_ALIGNED* dimension = new PCB_DIM_ALIGNED( m_board );
m_board->Add( dimension, ADD_MODE::APPEND ); m_board->Add( dimension, ADD_MODE::APPEND );
applyDimensionSettings( csDim, dimension ); applyDimensionSettings( csDim, dimension );
@ -1390,7 +1390,7 @@ void CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions()
else else
{ {
// "external" is a "leader" style dimension // "external" is a "leader" style dimension
LEADER* leaderDim = new LEADER( m_board ); PCB_DIM_LEADER* leaderDim = new PCB_DIM_LEADER( m_board );
m_board->Add( leaderDim, ADD_MODE::APPEND ); m_board->Add( leaderDim, ADD_MODE::APPEND );
applyDimensionSettings( csDim, leaderDim ); applyDimensionSettings( csDim, leaderDim );
@ -3475,7 +3475,7 @@ void CADSTAR_PCB_ARCHIVE_LOADER::checkAndLogHatchCode( const HATCHCODE_ID& aCads
void CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings( const DIMENSION& aCadstarDim, void CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings( const DIMENSION& aCadstarDim,
DIMENSION_BASE* aKiCadDim ) PCB_DIMENSION_BASE* aKiCadDim )
{ {
UNITS dimensionUnits = aCadstarDim.LinearUnits; UNITS dimensionUnits = aCadstarDim.LinearUnits;
TEXTCODE txtCode = getTextCode( aCadstarDim.Text.TextCodeID ); TEXTCODE txtCode = getTextCode( aCadstarDim.Text.TextCodeID );

4
pcbnew/plugins/cadstar/cadstar_pcb_archive_loader.h
View File

@ -34,7 +34,7 @@
class BOARD; class BOARD;
class BOARD_STACKUP_ITEM; class BOARD_STACKUP_ITEM;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class CADSTAR_PCB_ARCHIVE_LOADER : public CADSTAR_PCB_ARCHIVE_PARSER class CADSTAR_PCB_ARCHIVE_LOADER : public CADSTAR_PCB_ARCHIVE_PARSER
{ {
@ -169,7 +169,7 @@ private:
/// Load via and return via size /// Load via and return via size
int loadNetVia( const NET_ID& aCadstarNetID, const NET_PCB::VIA& aCadstarVia ); int loadNetVia( const NET_ID& aCadstarNetID, const NET_PCB::VIA& aCadstarVia );
void checkAndLogHatchCode( const HATCHCODE_ID& aCadstarHatchcodeID ); void checkAndLogHatchCode( const HATCHCODE_ID& aCadstarHatchcodeID );
void applyDimensionSettings( const DIMENSION& aCadstarDim, DIMENSION_BASE* aKiCadDim ); void applyDimensionSettings( const DIMENSION& aCadstarDim, PCB_DIMENSION_BASE* aKiCadDim );
/** /**

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

@ -77,7 +77,7 @@ Load() TODO's
#include <zone.h> #include <zone.h>
#include <pad_shapes.h> #include <pad_shapes.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <plugins/eagle/eagle_plugin.h> #include <plugins/eagle/eagle_plugin.h>
@ -874,7 +874,7 @@ void EAGLE_PLUGIN::loadPlain( wxXmlNode* aGraphics )
if( layer != UNDEFINED_LAYER ) if( layer != UNDEFINED_LAYER )
{ {
const BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings(); const BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
ALIGNED_DIMENSION* dimension = new ALIGNED_DIMENSION( m_board ); PCB_DIM_ALIGNED* dimension = new PCB_DIM_ALIGNED( m_board );
m_board->Add( dimension, ADD_MODE::APPEND ); m_board->Add( dimension, ADD_MODE::APPEND );
if( d.dimensionType ) if( d.dimensionType )

14
pcbnew/plugins/kicad/kicad_plugin.cpp
View File

@ -30,7 +30,7 @@
#include <confirm.h> #include <confirm.h>
#include <convert_basic_shapes_to_polygon.h> // for enum RECT_CHAMFER_POSITIONS definition #include <convert_basic_shapes_to_polygon.h> // for enum RECT_CHAMFER_POSITIONS definition
#include <core/arraydim.h> #include <core/arraydim.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <footprint.h> #include <footprint.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <kicad_string.h> #include <kicad_string.h>
@ -406,7 +406,7 @@ void PCB_IO::Format( const BOARD_ITEM* aItem, int aNestLevel ) const
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
format( static_cast<const DIMENSION_BASE*>( aItem ), aNestLevel ); format( static_cast<const PCB_DIMENSION_BASE*>( aItem ), aNestLevel );
break; break;
case PCB_SHAPE_T: case PCB_SHAPE_T:
@ -691,12 +691,12 @@ void PCB_IO::format( const BOARD* aBoard, int aNestLevel ) const
} }
void PCB_IO::format( const DIMENSION_BASE* aDimension, int aNestLevel ) const void PCB_IO::format( const PCB_DIMENSION_BASE* aDimension, int aNestLevel ) const
{ {
const ALIGNED_DIMENSION* aligned = dynamic_cast<const ALIGNED_DIMENSION*>( aDimension ); const PCB_DIM_ALIGNED* aligned = dynamic_cast<const PCB_DIM_ALIGNED*>( aDimension );
const ORTHOGONAL_DIMENSION* ortho = dynamic_cast<const ORTHOGONAL_DIMENSION*>( aDimension ); const PCB_DIM_ORTHOGONAL* ortho = dynamic_cast<const PCB_DIM_ORTHOGONAL*>( aDimension );
const CENTER_DIMENSION* center = dynamic_cast<const CENTER_DIMENSION*>( aDimension ); const PCB_DIM_CENTER* center = dynamic_cast<const PCB_DIM_CENTER*>( aDimension );
const LEADER* leader = dynamic_cast<const LEADER*>( aDimension ); const PCB_DIM_LEADER* leader = dynamic_cast<const PCB_DIM_LEADER*>( aDimension );
m_out->Print( aNestLevel, "(dimension" ); m_out->Print( aNestLevel, "(dimension" );

4
pcbnew/plugins/kicad/kicad_plugin.h
View File

@ -35,7 +35,7 @@ class FP_CACHE;
class PCB_PARSER; class PCB_PARSER;
class NETINFO_MAPPING; class NETINFO_MAPPING;
class BOARD_DESIGN_SETTINGS; class BOARD_DESIGN_SETTINGS;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class FP_SHAPE; class FP_SHAPE;
class PCB_SHAPE; class PCB_SHAPE;
class PCB_TARGET; class PCB_TARGET;
@ -242,7 +242,7 @@ protected:
private: private:
void format( const BOARD* aBoard, int aNestLevel = 0 ) const; void format( const BOARD* aBoard, int aNestLevel = 0 ) const;
void format( const DIMENSION_BASE* aDimension, int aNestLevel = 0 ) const; void format( const PCB_DIMENSION_BASE* aDimension, int aNestLevel = 0 ) const;
void format( const FP_SHAPE* aFPShape, int aNestLevel = 0 ) const; void format( const FP_SHAPE* aFPShape, int aNestLevel = 0 ) const;

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

@ -37,7 +37,7 @@
#include <advanced_config.h> #include <advanced_config.h>
#include <board.h> #include <board.h>
#include <board_design_settings.h> #include <board_design_settings.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <pcb_group.h> #include <pcb_group.h>
@ -2566,14 +2566,14 @@ PCB_TEXT* PCB_PARSER::parsePCB_TEXT()
} }
DIMENSION_BASE* PCB_PARSER::parseDIMENSION() PCB_DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
{ {
wxCHECK_MSG( CurTok() == T_dimension, NULL, wxCHECK_MSG( CurTok() == T_dimension, NULL,
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as DIMENSION." ) ); wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as DIMENSION." ) );
T token; T token;
bool locked = false; bool locked = false;
std::unique_ptr<DIMENSION_BASE> dimension; std::unique_ptr<PCB_DIMENSION_BASE> dimension;
token = NextTok(); token = NextTok();
@ -2595,7 +2595,7 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
if( token == T_width ) if( token == T_width )
{ {
isLegacyDimension = true; isLegacyDimension = true;
dimension = std::make_unique<ALIGNED_DIMENSION>( nullptr ); dimension = std::make_unique<PCB_DIM_ALIGNED>( nullptr );
dimension->SetLineThickness( parseBoardUnits( "dimension width value" ) ); dimension->SetLineThickness( parseBoardUnits( "dimension width value" ) );
NeedRIGHT(); NeedRIGHT();
} }
@ -2607,19 +2607,19 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
switch( NextTok() ) switch( NextTok() )
{ {
case T_aligned: case T_aligned:
dimension = std::make_unique<ALIGNED_DIMENSION>( nullptr ); dimension = std::make_unique<PCB_DIM_ALIGNED>( nullptr );
break; break;
case T_orthogonal: case T_orthogonal:
dimension = std::make_unique<ORTHOGONAL_DIMENSION>( nullptr ); dimension = std::make_unique<PCB_DIM_ORTHOGONAL>( nullptr );
break; break;
case T_leader: case T_leader:
dimension = std::make_unique<LEADER>( nullptr ); dimension = std::make_unique<PCB_DIM_LEADER>( nullptr );
break; break;
case T_center: case T_center:
dimension = std::make_unique<CENTER_DIMENSION>( nullptr ); dimension = std::make_unique<PCB_DIM_CENTER>( nullptr );
break; break;
default: default:
@ -2691,7 +2691,7 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
wxCHECK_MSG( dimension->Type() == PCB_DIM_ALIGNED_T || wxCHECK_MSG( dimension->Type() == PCB_DIM_ALIGNED_T ||
dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr, dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr,
wxT( "Invalid height token" ) ); wxT( "Invalid height token" ) );
ALIGNED_DIMENSION* aligned = static_cast<ALIGNED_DIMENSION*>( dimension.get() ); PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( dimension.get() );
aligned->SetHeight( parseBoardUnits( "dimension height value" ) ); aligned->SetHeight( parseBoardUnits( "dimension height value" ) );
NeedRIGHT(); NeedRIGHT();
break; break;
@ -2701,11 +2701,11 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
{ {
wxCHECK_MSG( dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr, wxCHECK_MSG( dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr,
wxT( "Invalid orientation token" ) ); wxT( "Invalid orientation token" ) );
ORTHOGONAL_DIMENSION* ortho = static_cast<ORTHOGONAL_DIMENSION*>( dimension.get() ); PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension.get() );
int orientation = parseInt( "orthogonal dimension orientation" ); int orientation = parseInt( "orthogonal dimension orientation" );
orientation = std::max( 0, std::min( 1, orientation ) ); orientation = std::max( 0, std::min( 1, orientation ) );
ortho->SetOrientation( static_cast<ORTHOGONAL_DIMENSION::DIR>( orientation ) ); ortho->SetOrientation( static_cast<PCB_DIM_ORTHOGONAL::DIR>( orientation ) );
NeedRIGHT(); NeedRIGHT();
break; break;
} }
@ -2806,7 +2806,7 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
case T_extension_height: case T_extension_height:
{ {
ALIGNED_DIMENSION* aligned = dynamic_cast<ALIGNED_DIMENSION*>( dimension.get() ); PCB_DIM_ALIGNED* aligned = dynamic_cast<PCB_DIM_ALIGNED*>( dimension.get() );
wxCHECK_MSG( aligned, nullptr, wxT( "Invalid extension_height token" ) ); wxCHECK_MSG( aligned, nullptr, wxT( "Invalid extension_height token" ) );
aligned->SetExtensionHeight( parseBoardUnits( "extension height" ) ); aligned->SetExtensionHeight( parseBoardUnits( "extension height" ) );
NeedRIGHT(); NeedRIGHT();
@ -2826,7 +2826,7 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
{ {
wxCHECK_MSG( dimension->Type() == PCB_DIM_LEADER_T, nullptr, wxCHECK_MSG( dimension->Type() == PCB_DIM_LEADER_T, nullptr,
wxT( "Invalid text_frame token" ) ); wxT( "Invalid text_frame token" ) );
LEADER* leader = static_cast<LEADER*>( dimension.get() ); PCB_DIM_LEADER* leader = static_cast<PCB_DIM_LEADER*>( dimension.get() );
int textFrame = parseInt( "dimension text frame mode" ); int textFrame = parseInt( "dimension text frame mode" );
textFrame = std::max( 0, std::min( 3, textFrame ) ); textFrame = std::max( 0, std::min( 3, textFrame ) );
@ -2893,7 +2893,7 @@ DIMENSION_BASE* PCB_PARSER::parseDIMENSION()
if( token == T_pts ) if( token == T_pts )
{ {
// If we have a crossbar, we know we're an old aligned dimension // If we have a crossbar, we know we're an old aligned dimension
ALIGNED_DIMENSION* aligned = static_cast<ALIGNED_DIMENSION*>( dimension.get() ); PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( dimension.get() );
// Old style: calculate height from crossbar // Old style: calculate height from crossbar
wxPoint point1, point2; wxPoint point1, point2;

4
pcbnew/plugins/kicad/pcb_parser.h
View File

@ -46,7 +46,7 @@ class BOARD_ITEM;
class BOARD_ITEM_CONTAINER; class BOARD_ITEM_CONTAINER;
class PAD; class PAD;
class BOARD_DESIGN_SETTINGS; class BOARD_DESIGN_SETTINGS;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class PCB_SHAPE; class PCB_SHAPE;
class EDA_TEXT; class EDA_TEXT;
class FP_SHAPE; class FP_SHAPE;
@ -187,7 +187,7 @@ private:
PCB_SHAPE* parsePCB_SHAPE(); PCB_SHAPE* parsePCB_SHAPE();
PCB_TEXT* parsePCB_TEXT(); PCB_TEXT* parsePCB_TEXT();
DIMENSION_BASE* parseDIMENSION(); PCB_DIMENSION_BASE* parseDIMENSION();
// Parse a footprint, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically. // Parse a footprint, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
FOOTPRINT* parseFOOTPRINT_unchecked( wxArrayString* aInitialComments = nullptr ); FOOTPRINT* parseFOOTPRINT_unchecked( wxArrayString* aInitialComments = nullptr );

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

@ -78,7 +78,7 @@
#include <track.h> #include <track.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <zone.h> #include <zone.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pcb_shape.h> #include <pcb_shape.h>
#include <pcb_target.h> #include <pcb_target.h>
#include <fp_shape.h> #include <fp_shape.h>
@ -2720,7 +2720,7 @@ void LEGACY_PLUGIN::loadZONE_CONTAINER()
void LEGACY_PLUGIN::loadDIMENSION() void LEGACY_PLUGIN::loadDIMENSION()
{ {
std::unique_ptr<ALIGNED_DIMENSION> dim = std::make_unique<ALIGNED_DIMENSION>( m_board ); std::unique_ptr<PCB_DIM_ALIGNED> dim = std::make_unique<PCB_DIM_ALIGNED>( m_board );
char* line; char* line;

2
pcbnew/plugins/legacy/legacy_plugin.h
View File

@ -44,7 +44,7 @@ class TRACK;
class NETCLASS; class NETCLASS;
class NETCLASSES; class NETCLASSES;
class ZONE; class ZONE;
class DIMENSION_BASE; class PCB_DIMENSION_BASE;
class NETINFO_ITEM; class NETINFO_ITEM;
class FP_TEXT; class FP_TEXT;
class TRACK; class TRACK;

4
pcbnew/python/swig/board.i
View File

@ -54,9 +54,9 @@ HANDLE_EXCEPTIONS(BOARD::TracksInNetBetweenPoints)
%include zone.i %include zone.i
%include zone_settings.i %include zone_settings.i
%include pcb_text.i %include pcb_text.i
%include dimension.i %include pcb_dimension.i
%include pcb_shape.i %include pcb_shape.i
%include marker_pcb.i %include pcb_marker.i
%include pcb_target.i %include pcb_target.i
%include fp_shape.i %include fp_shape.i
%include fp_text.i %include fp_text.i

44
pcbnew/python/swig/board_item.i
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) 2012 Miguel Angel Ajo <miguelangel@nbee.es> * Copyright (C) 2012 Miguel Angel Ajo <miguelangel@nbee.es>
* Copyright (C) 1992-2012 KiCad Developers, see AUTHORS.txt for contributors. * Copyright (C) 1992-2021 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
@ -62,10 +62,10 @@ const int S_CURVE = (const int)PCB_SHAPE_TYPE::CURVE;
%{ %{
class PCB_TEXT; class PCB_TEXT;
class ALIGNED_DIMENSION; class PCB_DIM_ALIGNED;
class ORTHOGONAL_DIMENSION; class PCB_DIM_ORTHOGONAL;
class LEADER; class PCB_DIM_LEADER;
class CENTER_DIMENSION; class PCB_DIM_CENTER;
class FOOTPRINT; class FOOTPRINT;
class PCB_GROUP; class PCB_GROUP;
class FP_TEXT; class FP_TEXT;
@ -88,10 +88,10 @@ extern "C" {
#endif #endif
static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* ); static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* );
static ALIGNED_DIMENSION* Cast_to_ALIGNED_DIMENSION( BOARD_ITEM* ); static PCB_DIM_ALIGNED* Cast_to_PCB_DIM_ALIGNED( BOARD_ITEM* );
static ORTHOGONAL_DIMENSION* Cast_to_ORTHOGONAL_DIMENSION( BOARD_ITEM* ); static PCB_DIM_ORTHOGONAL* Cast_to_PCB_DIM_ORTHOGONAL( BOARD_ITEM* );
static LEADER* Cast_to_LEADER( BOARD_ITEM* ); static PCB_DIM_LEADER* Cast_to_PCB_DIM_LEADER( BOARD_ITEM* );
static CENTER_DIMENSION* Cast_to_CENTER_DIMENSION( BOARD_ITEM* ); static PCB_DIM_CENTER* Cast_to_PCB_DIM_CENTER( BOARD_ITEM* );
static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* ); static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* );
static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* ); static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* );
static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* ); static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* );
@ -114,10 +114,10 @@ static PCB_TARGET* Cast_to_PCB_TARGET( BOARD_ITEM* );
static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* ); static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* );
static ALIGNED_DIMENSION* Cast_to_ALIGNED_DIMENSION( BOARD_ITEM* ); static PCB_DIM_ALIGNED* Cast_to_PCB_DIM_ALIGNED( BOARD_ITEM* );
static ORTHOGONAL_DIMENSION* Cast_to_ORTHOGONAL_DIMENSION( BOARD_ITEM* ); static PCB_DIM_ORTHOGONAL* Cast_to_PCB_DIM_ORTHOGONAL( BOARD_ITEM* );
static LEADER* Cast_to_LEADER( BOARD_ITEM* ); static PCB_DIM_LEADER* Cast_to_PCB_DIM_LEADER( BOARD_ITEM* );
static CENTER_DIMENSION* Cast_to_CENTER_DIMENSION( BOARD_ITEM* ); static PCB_DIM_CENTER* Cast_to_PCB_DIM_CENTER( BOARD_ITEM* );
static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* ); static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* );
static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* ); static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* );
static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* ); static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* );
@ -147,19 +147,19 @@ static PCB_TARGET* Cast_to_PCB_TARGET( BOARD_ITEM* );
elif ct=="BOARD": elif ct=="BOARD":
return Cast_to_BOARD(self) return Cast_to_BOARD(self)
elif ct=="ALIGNED_DIMENSION": elif ct=="ALIGNED_DIMENSION":
return Cast_to_ALIGNED_DIMENSION(self) return Cast_to_PCB_DIM_ALIGNED(self)
elif ct=="LEADER": elif ct=="LEADER":
return Cast_to_LEADER(self) return Cast_to_PCB_DIM_LEADER(self)
elif ct=="CENTER_DIMENSION": elif ct=="CENTER_DIMENSION":
return Cast_to_CENTER_DIMENSION(self) return Cast_to_PCB_DIM_CENTER(self)
elif ct=="ORTHOGONAL_DIMENSION": elif ct=="ORTHOGONAL_DIMENSION":
return Cast_to_ORTHOGONAL_DIMENSION(self) return Cast_to_PCB_DIM_ORTHOGONAL(self)
elif ct=="PCB_SHAPE": elif ct=="PCB_SHAPE":
return Cast_to_PCB_SHAPE(self) return Cast_to_PCB_SHAPE(self)
elif ct=="MGRAPHIC": elif ct=="MGRAPHIC":
return Cast_to_FP_SHAPE(self) return Cast_to_FP_SHAPE(self)
elif ct=="MODULE": elif ct=="MODULE":
return Cast_to_MODULE(self) return Cast_to_FOOTPRINT(self)
elif ct=="PCB_GROUP": elif ct=="PCB_GROUP":
return Cast_to_PCB_GROUP(self) return Cast_to_PCB_GROUP(self)
elif ct=="PAD": elif ct=="PAD":
@ -205,10 +205,10 @@ static PCB_TARGET* Cast_to_PCB_TARGET( BOARD_ITEM* );
// the %header section. See section 5.6.2 of SWIG 3.0 documentation. // the %header section. See section 5.6.2 of SWIG 3.0 documentation.
%wrapper %{ %wrapper %{
static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* self ) { return dynamic_cast<PCB_TEXT*>(self); } static PCB_TEXT* Cast_to_PCB_TEXT( BOARD_ITEM* self ) { return dynamic_cast<PCB_TEXT*>(self); }
static ALIGNED_DIMENSION* Cast_to_ALIGNED_DIMENSION( BOARD_ITEM* self ) { return dynamic_cast<ALIGNED_DIMENSION*>(self); } static PCB_DIM_ALIGNED* Cast_to_PCB_DIM_ALIGNED( BOARD_ITEM* self ) { return dynamic_cast<PCB_DIM_ALIGNED *>(self); }
static ORTHOGONAL_DIMENSION* Cast_to_ORTHOGONAL_DIMENSION( BOARD_ITEM* self ) { return dynamic_cast<ORTHOGONAL_DIMENSION*>(self); } static PCB_DIM_ORTHOGONAL* Cast_to_PCB_DIM_ORTHOGONAL( BOARD_ITEM* self ) { return dynamic_cast<PCB_DIM_ORTHOGONAL *>(self); }
static LEADER* Cast_to_LEADER( BOARD_ITEM* self ) { return dynamic_cast<LEADER*>(self); } static PCB_DIM_LEADER* Cast_to_PCB_DIM_LEADER( BOARD_ITEM* self ) { return dynamic_cast<PCB_DIM_LEADER *>(self); }
static CENTER_DIMENSION* Cast_to_CENTER_DIMENSION( BOARD_ITEM* self ) { return dynamic_cast<CENTER_DIMENSION*>(self); } static PCB_DIM_CENTER* Cast_to_PCB_DIM_CENTER( BOARD_ITEM* self ) { return dynamic_cast<PCB_DIM_CENTER *>(self); }
static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* self ) { return dynamic_cast<FOOTPRINT*>(self); } static FOOTPRINT* Cast_to_FOOTPRINT( BOARD_ITEM* self ) { return dynamic_cast<FOOTPRINT*>(self); }
static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* self ) { return dynamic_cast<PCB_GROUP*>(self); } static PCB_GROUP* Cast_to_PCB_GROUP( BOARD_ITEM* self ) { return dynamic_cast<PCB_GROUP*>(self); }
static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* self ) { return dynamic_cast<FP_TEXT*>(self); } static FP_TEXT* Cast_to_FP_TEXT( BOARD_ITEM* self ) { return dynamic_cast<FP_TEXT*>(self); }

6
pcbnew/python/swig/dimension.i
View File

@ -1,6 +0,0 @@
%include dimension.h
%{
#include <dimension.h>
%}

6
pcbnew/python/swig/pcb_dimension.i Normal file
View File

@ -0,0 +1,6 @@
%include pcb_dimension.h
%{
#include <pcb_dimension.h>
%}

0
pcbnew/python/swig/marker_pcb.i → pcbnew/python/swig/pcb_marker.i
View File

32
pcbnew/tools/drawing_tool.cpp
View File

@ -49,7 +49,7 @@
#include <fp_shape.h> #include <fp_shape.h>
#include <pcb_group.h> #include <pcb_group.h>
#include <pcb_text.h> #include <pcb_text.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <zone.h> #include <zone.h>
#include <footprint.h> #include <footprint.h>
#include <preview_items/two_point_assistant.h> #include <preview_items/two_point_assistant.h>
@ -643,7 +643,7 @@ int DRAWING_TOOL::PlaceText( const TOOL_EVENT& aEvent )
} }
void DRAWING_TOOL::constrainDimension( DIMENSION_BASE* aDim ) void DRAWING_TOOL::constrainDimension( PCB_DIMENSION_BASE* aDim )
{ {
const VECTOR2I lineVector{ aDim->GetEnd() - aDim->GetStart() }; const VECTOR2I lineVector{ aDim->GetEnd() - aDim->GetStart() };
@ -666,7 +666,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
}; };
TOOL_EVENT originalEvent = aEvent; TOOL_EVENT originalEvent = aEvent;
DIMENSION_BASE* dimension = nullptr; PCB_DIMENSION_BASE* dimension = nullptr;
BOARD_COMMIT commit( m_frame ); BOARD_COMMIT commit( m_frame );
PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() ); PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
BOARD_DESIGN_SETTINGS& boardSettings = m_board->GetDesignSettings(); BOARD_DESIGN_SETTINGS& boardSettings = m_board->GetDesignSettings();
@ -795,7 +795,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
// Init the new item attributes // Init the new item attributes
auto setMeasurementAttributes = auto setMeasurementAttributes =
[&]( DIMENSION_BASE* aDim ) [&]( PCB_DIMENSION_BASE* aDim )
{ {
aDim->SetUnitsMode( boardSettings.m_DimensionUnitsMode ); aDim->SetUnitsMode( boardSettings.m_DimensionUnitsMode );
aDim->SetUnitsFormat( boardSettings.m_DimensionUnitsFormat ); aDim->SetUnitsFormat( boardSettings.m_DimensionUnitsFormat );
@ -810,21 +810,21 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
if( originalEvent.IsAction( &PCB_ACTIONS::drawAlignedDimension ) ) if( originalEvent.IsAction( &PCB_ACTIONS::drawAlignedDimension ) )
{ {
dimension = new ALIGNED_DIMENSION( m_board ); dimension = new PCB_DIM_ALIGNED( m_board );
setMeasurementAttributes( dimension ); setMeasurementAttributes( dimension );
} }
else if( originalEvent.IsAction( &PCB_ACTIONS::drawOrthogonalDimension ) ) else if( originalEvent.IsAction( &PCB_ACTIONS::drawOrthogonalDimension ) )
{ {
dimension = new ORTHOGONAL_DIMENSION( m_board ); dimension = new PCB_DIM_ORTHOGONAL( m_board );
setMeasurementAttributes( dimension ); setMeasurementAttributes( dimension );
} }
else if( originalEvent.IsAction( &PCB_ACTIONS::drawCenterDimension ) ) else if( originalEvent.IsAction( &PCB_ACTIONS::drawCenterDimension ) )
{ {
dimension = new CENTER_DIMENSION( m_board ); dimension = new PCB_DIM_CENTER( m_board );
} }
else if( originalEvent.IsAction( &PCB_ACTIONS::drawLeader ) ) else if( originalEvent.IsAction( &PCB_ACTIONS::drawLeader ) )
{ {
dimension = new LEADER( m_board ); dimension = new PCB_DIM_LEADER( m_board );
dimension->Text().SetPosition( wxPoint( cursorPos ) ); dimension->Text().SetPosition( wxPoint( cursorPos ) );
} }
else else
@ -929,7 +929,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
if( dimension->Type() == PCB_DIM_ORTHOGONAL_T ) if( dimension->Type() == PCB_DIM_ORTHOGONAL_T )
{ {
ORTHOGONAL_DIMENSION* ortho = static_cast<ORTHOGONAL_DIMENSION*>( dimension ); PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension );
BOX2I bounds( dimension->GetStart(), BOX2I bounds( dimension->GetStart(),
dimension->GetEnd() - dimension->GetStart() ); dimension->GetEnd() - dimension->GetStart() );
@ -937,8 +937,8 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
// Create a nice preview by measuring the longer dimension // Create a nice preview by measuring the longer dimension
bool vert = bounds.GetWidth() < bounds.GetHeight(); bool vert = bounds.GetWidth() < bounds.GetHeight();
ortho->SetOrientation( vert ? ORTHOGONAL_DIMENSION::DIR::VERTICAL ortho->SetOrientation( vert ? PCB_DIM_ORTHOGONAL::DIR::VERTICAL
: ORTHOGONAL_DIMENSION::DIR::HORIZONTAL ); : PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
} }
dimension->Update(); dimension->Update();
@ -952,7 +952,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
{ {
if( dimension->Type() == PCB_DIM_ALIGNED_T ) if( dimension->Type() == PCB_DIM_ALIGNED_T )
{ {
ALIGNED_DIMENSION* aligned = static_cast<ALIGNED_DIMENSION*>( dimension ); PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( dimension );
// Calculating the direction of travel perpendicular to the selected axis // Calculating the direction of travel perpendicular to the selected axis
double angle = aligned->GetAngle() + ( M_PI / 2 ); double angle = aligned->GetAngle() + ( M_PI / 2 );
@ -964,7 +964,7 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
} }
else if( dimension->Type() == PCB_DIM_ORTHOGONAL_T ) else if( dimension->Type() == PCB_DIM_ORTHOGONAL_T )
{ {
ORTHOGONAL_DIMENSION* ortho = static_cast<ORTHOGONAL_DIMENSION*>( dimension ); PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension );
BOX2I bounds( dimension->GetStart(), BOX2I bounds( dimension->GetStart(),
dimension->GetEnd() - dimension->GetStart() ); dimension->GetEnd() - dimension->GetStart() );
@ -996,12 +996,12 @@ int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
{ {
vert = std::abs( direction.y ) < std::abs( direction.x ); vert = std::abs( direction.y ) < std::abs( direction.x );
} }
ortho->SetOrientation( vert ? ORTHOGONAL_DIMENSION::DIR::VERTICAL ortho->SetOrientation( vert ? PCB_DIM_ORTHOGONAL::DIR::VERTICAL
: ORTHOGONAL_DIMENSION::DIR::HORIZONTAL ); : PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
} }
else else
{ {
vert = ortho->GetOrientation() == ORTHOGONAL_DIMENSION::DIR::VERTICAL; vert = ortho->GetOrientation() == PCB_DIM_ORTHOGONAL::DIR::VERTICAL;
} }
VECTOR2I heightVector( cursorPos - dimension->GetStart() ); VECTOR2I heightVector( cursorPos - dimension->GetStart() );

2
pcbnew/tools/drawing_tool.h
View File

@ -259,7 +259,7 @@ private:
* *
* @param aDimension is the dimension element currently being drawn. * @param aDimension is the dimension element currently being drawn.
*/ */
void constrainDimension( DIMENSION_BASE* aDim ); void constrainDimension( PCB_DIMENSION_BASE* aDim );
///< Return the appropriate width for a segment depending on the settings. ///< Return the appropriate width for a segment depending on the settings.
int getSegmentWidth( PCB_LAYER_ID aLayer ) const; int getSegmentWidth( PCB_LAYER_ID aLayer ) const;

4
pcbnew/tools/pcb_control.cpp
View File

@ -36,7 +36,7 @@
#include <board_design_settings.h> #include <board_design_settings.h>
#include <board_item.h> #include <board_item.h>
#include <dialogs/dialog_paste_special.h> #include <dialogs/dialog_paste_special.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <footprint.h> #include <footprint.h>
#include <pcb_group.h> #include <pcb_group.h>
#include <track.h> #include <track.h>
@ -902,7 +902,7 @@ int PCB_CONTROL::placeBoardItems( std::vector<BOARD_ITEM*>& aItems, bool aIsNew,
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
{ {
// Dimensions need to have their units updated if they are automatic // Dimensions need to have their units updated if they are automatic
DIMENSION_BASE* dim = static_cast<DIMENSION_BASE*>( item ); PCB_DIMENSION_BASE* dim = static_cast<PCB_DIMENSION_BASE*>( item );
if( dim->GetUnitsMode() == DIM_UNITS_MODE::AUTOMATIC ) if( dim->GetUnitsMode() == DIM_UNITS_MODE::AUTOMATIC )
dim->SetUnits( frame()->GetUserUnits() ); dim->SetUnits( frame()->GetUserUnits() );

8
pcbnew/tools/pcb_grid_helper.cpp
View File

@ -25,7 +25,7 @@
#include <functional> #include <functional>
#include <board.h> #include <board.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <footprint.h> #include <footprint.h>
#include <pad.h> #include <pad.h>
@ -643,7 +643,7 @@ void PCB_GRID_HELPER::computeAnchors( BOARD_ITEM* aItem, const VECTOR2I& aRefPos
case PCB_DIM_ALIGNED_T: case PCB_DIM_ALIGNED_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
{ {
const ALIGNED_DIMENSION* dim = static_cast<const ALIGNED_DIMENSION*>( aItem ); const PCB_DIM_ALIGNED* dim = static_cast<const PCB_DIM_ALIGNED*>( aItem );
addAnchor( dim->GetCrossbarStart(), CORNER | SNAPPABLE, aItem ); addAnchor( dim->GetCrossbarStart(), CORNER | SNAPPABLE, aItem );
addAnchor( dim->GetCrossbarEnd(), CORNER | SNAPPABLE, aItem ); addAnchor( dim->GetCrossbarEnd(), CORNER | SNAPPABLE, aItem );
addAnchor( dim->GetStart(), CORNER | SNAPPABLE, aItem ); addAnchor( dim->GetStart(), CORNER | SNAPPABLE, aItem );
@ -653,7 +653,7 @@ void PCB_GRID_HELPER::computeAnchors( BOARD_ITEM* aItem, const VECTOR2I& aRefPos
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
{ {
const CENTER_DIMENSION* dim = static_cast<const CENTER_DIMENSION*>( aItem ); const PCB_DIM_CENTER* dim = static_cast<const PCB_DIM_CENTER*>( aItem );
addAnchor( dim->GetStart(), CORNER | SNAPPABLE, aItem ); addAnchor( dim->GetStart(), CORNER | SNAPPABLE, aItem );
addAnchor( dim->GetEnd(), CORNER | SNAPPABLE, aItem ); addAnchor( dim->GetEnd(), CORNER | SNAPPABLE, aItem );
@ -671,7 +671,7 @@ void PCB_GRID_HELPER::computeAnchors( BOARD_ITEM* aItem, const VECTOR2I& aRefPos
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
{ {
const LEADER* leader = static_cast<const 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->Text().GetPosition(), CORNER | SNAPPABLE, aItem );

28
pcbnew/tools/pcb_point_editor.cpp
View File

@ -40,7 +40,7 @@ using namespace std::placeholders;
#include <status_popup.h> #include <status_popup.h>
#include <pcb_edit_frame.h> #include <pcb_edit_frame.h>
#include <fp_shape.h> #include <fp_shape.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <pad.h> #include <pad.h>
#include <zone.h> #include <zone.h>
#include <connectivity/connectivity_data.h> #include <connectivity/connectivity_data.h>
@ -291,7 +291,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
case PCB_DIM_ALIGNED_T: case PCB_DIM_ALIGNED_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
{ {
const ALIGNED_DIMENSION* dimension = static_cast<const ALIGNED_DIMENSION*>( aItem ); const PCB_DIM_ALIGNED* dimension = static_cast<const PCB_DIM_ALIGNED*>( aItem );
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
@ -315,7 +315,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
{ {
const CENTER_DIMENSION* dimension = static_cast<const CENTER_DIMENSION*>( aItem ); const PCB_DIM_CENTER* dimension = static_cast<const PCB_DIM_CENTER*>( aItem );
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
@ -328,7 +328,7 @@ std::shared_ptr<EDIT_POINTS> PCB_POINT_EDITOR::makePoints( EDA_ITEM* aItem )
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
{ {
const LEADER* dimension = static_cast<const LEADER*>( aItem ); const PCB_DIM_LEADER* dimension = static_cast<const PCB_DIM_LEADER*>( aItem );
points->AddPoint( dimension->GetStart() ); points->AddPoint( dimension->GetStart() );
points->AddPoint( dimension->GetEnd() ); points->AddPoint( dimension->GetEnd() );
@ -1314,7 +1314,7 @@ void PCB_POINT_EDITOR::updateItem() const
case PCB_DIM_ALIGNED_T: case PCB_DIM_ALIGNED_T:
{ {
ALIGNED_DIMENSION* dimension = static_cast<ALIGNED_DIMENSION*>( item ); PCB_DIM_ALIGNED* dimension = static_cast<PCB_DIM_ALIGNED*>( item );
// Check which point is currently modified and updated dimension's points respectively // Check which point is currently modified and updated dimension's points respectively
if( isModified( m_editPoints->Point( DIM_CROSSBARSTART ) ) ) if( isModified( m_editPoints->Point( DIM_CROSSBARSTART ) ) )
@ -1376,7 +1376,7 @@ void PCB_POINT_EDITOR::updateItem() const
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
{ {
ORTHOGONAL_DIMENSION* dimension = static_cast<ORTHOGONAL_DIMENSION*>( item ); PCB_DIM_ORTHOGONAL* dimension = static_cast<PCB_DIM_ORTHOGONAL*>( item );
if( isModified( m_editPoints->Point( DIM_CROSSBARSTART ) ) || if( isModified( m_editPoints->Point( DIM_CROSSBARSTART ) ) ||
isModified( m_editPoints->Point( DIM_CROSSBAREND ) ) ) isModified( m_editPoints->Point( DIM_CROSSBAREND ) ) )
@ -1418,12 +1418,12 @@ void PCB_POINT_EDITOR::updateItem() const
{ {
vert = std::abs( direction.y ) < std::abs( direction.x ); vert = std::abs( direction.y ) < std::abs( direction.x );
} }
dimension->SetOrientation( vert ? ORTHOGONAL_DIMENSION::DIR::VERTICAL dimension->SetOrientation( vert ? PCB_DIM_ORTHOGONAL::DIR::VERTICAL
: ORTHOGONAL_DIMENSION::DIR::HORIZONTAL ); : PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
} }
else else
{ {
vert = dimension->GetOrientation() == ORTHOGONAL_DIMENSION::DIR::VERTICAL; vert = dimension->GetOrientation() == PCB_DIM_ORTHOGONAL::DIR::VERTICAL;
} }
dimension->SetHeight( vert ? featureLine.x : featureLine.y ); dimension->SetHeight( vert ? featureLine.x : featureLine.y );
@ -1452,7 +1452,7 @@ void PCB_POINT_EDITOR::updateItem() const
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
{ {
CENTER_DIMENSION* dimension = static_cast<CENTER_DIMENSION*>( item ); PCB_DIM_CENTER* dimension = static_cast<PCB_DIM_CENTER*>( item );
if( isModified( m_editPoints->Point( DIM_START ) ) ) if( isModified( m_editPoints->Point( DIM_START ) ) )
{ {
@ -1472,7 +1472,7 @@ void PCB_POINT_EDITOR::updateItem() const
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
{ {
LEADER* dimension = static_cast<LEADER*>( item ); PCB_DIM_LEADER* dimension = static_cast<PCB_DIM_LEADER*>( item );
if( isModified( m_editPoints->Point( DIM_START ) ) ) if( isModified( m_editPoints->Point( DIM_START ) ) )
{ {
@ -1723,7 +1723,7 @@ void PCB_POINT_EDITOR::updatePoints()
case PCB_DIM_ALIGNED_T: case PCB_DIM_ALIGNED_T:
case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_ORTHOGONAL_T:
{ {
const ALIGNED_DIMENSION* dimension = static_cast<const ALIGNED_DIMENSION*>( item ); const PCB_DIM_ALIGNED* dimension = static_cast<const PCB_DIM_ALIGNED*>( item );
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() );
@ -1735,7 +1735,7 @@ void PCB_POINT_EDITOR::updatePoints()
case PCB_DIM_CENTER_T: case PCB_DIM_CENTER_T:
{ {
const CENTER_DIMENSION* dimension = static_cast<const CENTER_DIMENSION*>( item ); const PCB_DIM_CENTER* dimension = static_cast<const PCB_DIM_CENTER*>( item );
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() );
@ -1744,7 +1744,7 @@ void PCB_POINT_EDITOR::updatePoints()
case PCB_DIM_LEADER_T: case PCB_DIM_LEADER_T:
{ {
const LEADER* dimension = static_cast<const LEADER*>( item ); const PCB_DIM_LEADER* dimension = static_cast<const PCB_DIM_LEADER*>( item );
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() );

2
pcbnew/undo_redo.cpp
View File

@ -35,7 +35,7 @@ using namespace std::placeholders;
#include <pcb_target.h> #include <pcb_target.h>
#include <footprint.h> #include <footprint.h>
#include <pad.h> #include <pad.h>
#include <dimension.h> #include <pcb_dimension.h>
#include <origin_viewitem.h> #include <origin_viewitem.h>
#include <connectivity/connectivity_data.h> #include <connectivity/connectivity_data.h>
#include <pcbnew_settings.h> #include <pcbnew_settings.h>