KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_bus_entry.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2004 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <sch_draw_panel.h>
26#include <bitmaps.h>
27#include <core/mirror.h>
28#include <schematic.h>
31#include <sch_bus_entry.h>
32#include <sch_edit_frame.h>
33#include <sch_junction.h>
34#include <sch_line.h>
38#include <netclass.h>
39#include <trigo.h>
40#include <board_item.h>
41#include <connection_graph.h>
42#include "sch_painter.h"
43#include "plotters/plotter.h"
44
45
46SCH_BUS_ENTRY_BASE::SCH_BUS_ENTRY_BASE( KICAD_T aType, const VECTOR2I& pos, bool aFlipY ) :
47 SCH_ITEM( nullptr, aType )
48{
49 m_pos = pos;
52
53 m_stroke.SetWidth( 0 );
54 m_stroke.SetLineStyle( LINE_STYLE::DEFAULT );
56
57 if( aFlipY )
58 m_size.y *= -1;
59
61
65}
66
67
78
79
82{
83 switch( aQuadrant )
84 {
85 case 1: m_size.x *= 1; m_size.y *= -1; break;
86 case 2: m_size.x *= 1; m_size.y *= 1; break;
87 case 3: m_size.x *= -1; m_size.y *= 1; break;
88 case 4: m_size.x *= -1; m_size.y *= -1; break;
89 default: wxFAIL_MSG( wxS( "SCH_BUS_WIRE_ENTRY ctor: unexpected quadrant" ) );
90 }
91
93 m_connected_bus_item = nullptr;
94
98}
99
100
112
113
115{
116 return new SCH_BUS_WIRE_ENTRY( *this );
117}
118
119
121{
122 return new SCH_BUS_BUS_ENTRY( *this );
123}
124
125
126bool SCH_BUS_ENTRY_BASE::doIsConnected( const VECTOR2I& aPosition ) const
127{
128 return ( m_pos == aPosition || GetEnd() == aPosition );
129}
130
131
133{
134 return VECTOR2I( m_pos.x + m_size.x, m_pos.y + m_size.y );
135}
136
137
139{
140 SCH_BUS_ENTRY_BASE* item = dynamic_cast<SCH_BUS_ENTRY_BASE*>( aItem );
141 wxCHECK_RET( item, wxT( "Cannot swap bus entry data with invalid item." ) );
142
143 std::swap( m_pos, item->m_pos );
144 std::swap( m_size, item->m_size );
145 std::swap( m_stroke, item->m_stroke );
146
147 std::swap( m_lastResolvedWidth, item->m_lastResolvedWidth );
149 std::swap( m_lastResolvedColor, item->m_lastResolvedColor );
150}
151
152
160
161
163{
164 BOX2I bbox( m_pos );
165 bbox.SetEnd( GetEnd() );
166
167 bbox.Normalize();
168 bbox.Inflate( ( GetPenWidth() / 2 ) + 1 );
169
170 return bbox;
171}
172
173
183
184
186{
187 m_stroke.SetWidth( aWidth );
188 m_lastResolvedWidth = aWidth;
189}
190
191
193{
194 return m_lastResolvedWidth;
195}
196
197
199{
200 m_stroke.SetColor( aColor );
201 m_lastResolvedColor = aColor;
202}
203
204
214
215
217{
218 m_stroke.SetLineStyle( aStyle );
220}
221
222
224{
225 if( m_stroke.GetWidth() > 0 )
226 m_lastResolvedWidth = m_stroke.GetWidth();
227 else if( IsConnectable() && !IsConnectivityDirty() )
229
230 return m_lastResolvedWidth;
231}
232
233
235{
236 if( m_stroke.GetWidth() > 0 )
237 m_lastResolvedWidth = m_stroke.GetWidth();
238 else if( IsConnectable() && !IsConnectivityDirty() )
240
241 return m_lastResolvedWidth;
242}
243
244
245void SCH_BUS_WIRE_ENTRY::GetEndPoints( std::vector< DANGLING_END_ITEM >& aItemList )
246{
248 aItemList.push_back( item );
249
250 DANGLING_END_ITEM item1( WIRE_ENTRY_END, this, GetEnd() );
251 aItemList.push_back( item1 );
252}
253
254
255void SCH_BUS_BUS_ENTRY::GetEndPoints( std::vector< DANGLING_END_ITEM >& aItemList )
256{
258 aItemList.push_back( item );
259
260 DANGLING_END_ITEM item1( BUS_ENTRY_END, this, GetEnd() );
261 aItemList.push_back( item1 );
262}
263
264
266{
267 MIRROR( m_pos.y, aCenter );
268 m_size.y = -m_size.y;
269}
270
271
273{
274 MIRROR( m_pos.x, aCenter );
275 m_size.x = -m_size.x;
276}
277
278
279void SCH_BUS_ENTRY_BASE::Rotate( const VECTOR2I& aCenter, bool aRotateCCW )
280{
281 RotatePoint( m_pos, aCenter, aRotateCCW ? ANGLE_90 : ANGLE_270 );
282 RotatePoint( &m_size.x, &m_size.y, aRotateCCW ? ANGLE_90 : ANGLE_270 );
283}
284
285
286bool SCH_BUS_WIRE_ENTRY::UpdateDanglingState( std::vector<DANGLING_END_ITEM>& aItemListByType,
287 std::vector<DANGLING_END_ITEM>& aItemListByPos,
288 const SCH_SHEET_PATH* aPath )
289{
290 bool previousStateStart = m_isStartDangling;
291 bool previousStateEnd = m_isEndDangling;
292
294
295 // Store the connection type and state for the start (0) and end (1)
296 bool has_wire[2] = { false };
297 bool has_bus[2] = { false };
298
299 for( unsigned ii = 0; ii < aItemListByType.size(); ii++ )
300 {
301 DANGLING_END_ITEM& item = aItemListByType[ii];
302
303 if( item.GetItem() == this )
304 continue;
305
306 switch( item.GetType() )
307 {
308 case WIRE_END:
309 if( m_pos == item.GetPosition() )
310 has_wire[0] = true;
311 else if( GetEnd() == item.GetPosition() )
312 has_wire[1] = true;
313
314 break;
315
316 case BUS_END:
317 {
318 // The bus has created 2 DANGLING_END_ITEMs, one per end.
319 DANGLING_END_ITEM& nextItem = aItemListByType[++ii];
320
321 if( IsPointOnSegment( item.GetPosition(), nextItem.GetPosition(), m_pos ) )
322 has_bus[0] = true;
323 else if( IsPointOnSegment( item.GetPosition(), nextItem.GetPosition(), GetEnd() ) )
324 has_bus[1] = true;
325 }
326 break;
327
328 default:
329 break;
330 }
331 }
332
333 // A bus-wire entry is connected at both ends if it has a bus and a wire on its
334 // ends. Otherwise, we connect only one end (in the case of a wire-wire or bus-bus)
335 if( ( has_wire[0] && has_bus[1] ) || ( has_wire[1] && has_bus[0] ) )
337 else if( has_wire[0] || has_bus[0] )
338 m_isStartDangling = false;
339 else if( has_wire[1] || has_bus[1] )
340 m_isEndDangling = false;
341
342 return (previousStateStart != m_isStartDangling) || (previousStateEnd != m_isEndDangling);
343}
344
345
346bool SCH_BUS_BUS_ENTRY::UpdateDanglingState( std::vector<DANGLING_END_ITEM>& aItemListByType,
347 std::vector<DANGLING_END_ITEM>& aItemListByPos,
348 const SCH_SHEET_PATH* aPath )
349{
350 bool previousStateStart = m_isStartDangling;
351 bool previousStateEnd = m_isEndDangling;
352
354
355 // TODO: filter using get_lower as we only use one item type
356 for( unsigned ii = 0; ii < aItemListByType.size(); ii++ )
357 {
358 DANGLING_END_ITEM& item = aItemListByType[ii];
359
360 if( item.GetItem() == this )
361 continue;
362
363 switch( item.GetType() )
364 {
365 case BUS_END:
366 {
367 // The bus has created 2 DANGLING_END_ITEMs, one per end.
368 DANGLING_END_ITEM& nextItem = aItemListByType[++ii];
369
370 if( IsPointOnSegment( item.GetPosition(), nextItem.GetPosition(), m_pos ) )
371 m_isStartDangling = false;
372
373 if( IsPointOnSegment( item.GetPosition(), nextItem.GetPosition(), GetEnd() ) )
374 m_isEndDangling = false;
375 }
376 break;
377
378 default:
379 break;
380 }
381 }
382
383 return (previousStateStart != m_isStartDangling) || (previousStateEnd != m_isEndDangling);
384}
385
386
391
392
393std::vector<VECTOR2I> SCH_BUS_ENTRY_BASE::GetConnectionPoints() const
394{
395 return { m_pos, GetEnd() };
396}
397
398
400 const SCH_SHEET_PATH* aInstance ) const
401{
402 // Do not compare to ourselves.
403 if( aItem == this )
404 return false;
405
406 const SCH_BUS_ENTRY_BASE* busEntry = dynamic_cast<const SCH_BUS_ENTRY_BASE*>( aItem );
407
408 // Don't compare against a different SCH_ITEM.
409 wxCHECK( busEntry, false );
410
411 if( GetPosition() != busEntry->GetPosition() )
412 return true;
413
414 return GetEnd() != busEntry->GetEnd();
415}
416
417
418wxString SCH_BUS_WIRE_ENTRY::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
419{
420 return wxString( _( "Bus to wire entry" ) );
421}
422
423
424wxString SCH_BUS_BUS_ENTRY::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
425{
426 return wxString( _( "Bus to bus entry" ) );
427}
428
429
434
435
440
441
442bool SCH_BUS_ENTRY_BASE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
443{
444 // Insure minimum accuracy
445 if( aAccuracy == 0 )
446 aAccuracy = ( GetPenWidth() / 2 ) + 4;
447
448 return TestSegmentHit( aPosition, m_pos, GetEnd(), aAccuracy );
449}
450
451
452bool SCH_BUS_ENTRY_BASE::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
453{
454 BOX2I rect = aRect;
455
456 rect.Inflate( aAccuracy );
457
458 if( aContained )
459 return rect.Contains( GetBoundingBox() );
460
461 return rect.Intersects( GetBoundingBox() );
462}
463
464
465bool SCH_BUS_ENTRY_BASE::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
466{
468 return KIGEOM::ShapeHitTest( aPoly, line, aContained );
469}
470
471
472void SCH_BUS_ENTRY_BASE::Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
473 int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed )
474{
475 if( aBackground )
476 return;
477
478 SCH_RENDER_SETTINGS* renderSettings = getRenderSettings( aPlotter );
479
481 ? renderSettings->GetLayerColor( m_layer ) : GetBusEntryColor();
482
483 int penWidth = ( GetPenWidth() == 0 ) ? renderSettings->GetDefaultPenWidth() : GetPenWidth();
484
485 penWidth = std::max( penWidth, renderSettings->GetMinPenWidth() );
486
487 aPlotter->SetCurrentLineWidth( penWidth );
488 aPlotter->SetColor( color );
489 aPlotter->SetDash( penWidth, GetEffectiveLineStyle() );
490 aPlotter->MoveTo( m_pos );
491 aPlotter->FinishTo( GetEnd() );
492
493 aPlotter->SetDash( penWidth, LINE_STYLE::SOLID );
494}
495
496
498 std::vector<MSG_PANEL_ITEM>& aList )
499{
500 wxString msg;
501
502 switch( GetLayer() )
503 {
504 default:
505 case LAYER_WIRE: msg = _( "Wire" ); break;
506 case LAYER_BUS: msg = _( "Bus" ); break;
507 }
508
509 aList.emplace_back( _( "Bus Entry Type" ), msg );
510
511 SCH_CONNECTION* conn = nullptr;
512
513 if( !IsConnectivityDirty() && dynamic_cast<SCH_EDIT_FRAME*>( aFrame ) )
514 conn = Connection();
515
516 if( conn )
517 {
518 conn->AppendInfoToMsgPanel( aList );
519
520 if( !conn->IsBus() )
521 aList.emplace_back( _( "Resolved Netclass" ),
522 GetEffectiveNetClass()->GetHumanReadableName() );
523 }
524}
525
526
527bool SCH_BUS_ENTRY_BASE::operator <( const SCH_ITEM& aItem ) const
528{
529 if( Type() != aItem.Type() )
530 return Type() < aItem.Type();
531
532 auto symbol = static_cast<const SCH_BUS_ENTRY_BASE*>( &aItem );
533
534 if( GetLayer() != symbol->GetLayer() )
535 return GetLayer() < symbol->GetLayer();
536
537 if( GetPosition().x != symbol->GetPosition().x )
538 return GetPosition().x < symbol->GetPosition().x;
539
540 if( GetPosition().y != symbol->GetPosition().y )
541 return GetPosition().y < symbol->GetPosition().y;
542
543 if( GetEnd().x != symbol->GetEnd().x )
544 return GetEnd().x < symbol->GetEnd().x;
545
546 return GetEnd().y < symbol->GetEnd().y;
547}
548
549
551{
552 // Don't generate connections between bus entries and buses, since there is
553 // a connectivity change at that point (e.g. A[7..0] to A7)
554 if( ( aItem->Type() == SCH_LINE_T ) &&
555 ( static_cast<const SCH_LINE*>( aItem )->GetLayer() == LAYER_BUS ) )
556 {
557 return false;
558 }
559
560 // Same for bus junctions
561 if( ( aItem->Type() == SCH_JUNCTION_T ) &&
562 ( static_cast<const SCH_JUNCTION*>( aItem )->GetLayer() == LAYER_BUS_JUNCTION ) )
563 {
564 return false;
565 }
566
567 // Don't generate connections between bus entries and bus labels that happen
568 // to land at the same point on the bus wire as this bus entry
569 if( ( aItem->Type() == SCH_LABEL_T ) &&
570 SCH_CONNECTION::IsBusLabel( static_cast<const SCH_LABEL*>( aItem )->GetText() ) )
571 {
572 return false;
573 }
574
575 // Don't generate connections between two bus-wire entries
576 if( aItem->Type() == SCH_BUS_WIRE_ENTRY_T )
577 return false;
578
579 return true;
580}
581
582bool SCH_BUS_ENTRY_BASE::operator==( const SCH_ITEM& aItem ) const
583{
584 if( Type() != aItem.Type() )
585 return false;
586
587 const SCH_BUS_ENTRY_BASE* symbol = static_cast<const SCH_BUS_ENTRY_BASE*>( &aItem );
588
589 if( GetLayer() != symbol->GetLayer() )
590 return false;
591
592 if( GetPosition() != symbol->GetPosition() )
593 return false;
594
595 if( GetEnd() != symbol->GetEnd() )
596 return false;
597
598 return true;
599}
600
601
602double SCH_BUS_ENTRY_BASE::Similarity( const SCH_ITEM& aItem ) const
603{
604 if( aItem.Type() != Type() )
605 return 0.0;
606
607 if( m_Uuid == aItem.m_Uuid )
608 return 1.0;
609
610 const SCH_BUS_ENTRY_BASE& other = static_cast<const SCH_BUS_ENTRY_BASE&>( aItem );
611
612 if( GetLayer() != other.GetLayer() )
613 return 0.0;
614
615 if( GetPosition() != other.GetPosition() )
616 return 0.0;
617
618 return 1.0;
619}
620
621
623{
625 {
633
635
636 if( wireLineStyleEnum.Choices().GetCount() == 0 )
637 {
638 wireLineStyleEnum.Map( WIRE_STYLE::DEFAULT, _HKI( "Default" ) )
639 .Map( WIRE_STYLE::SOLID, _HKI( "Solid" ) )
640 .Map( WIRE_STYLE::DASH, _HKI( "Dashed" ) )
641 .Map( WIRE_STYLE::DOT, _HKI( "Dotted" ) )
642 .Map( WIRE_STYLE::DASHDOT, _HKI( "Dash-Dot" ) )
643 .Map( WIRE_STYLE::DASHDOTDOT, _HKI( "Dash-Dot-Dot" ) );
644 }
645
648
649 propMgr.AddProperty( new PROPERTY<SCH_BUS_ENTRY_BASE, int>( _HKI( "Line Width" ),
652
655 }
int color
constexpr EDA_IU_SCALE schIUScale
Definition base_units.h:114
BITMAPS
A list of all bitmap identifiers.
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition box2.h:558
constexpr BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
Definition box2.h:146
constexpr bool Contains(const Vec &aPoint) const
Definition box2.h:168
constexpr void SetEnd(coord_type x, coord_type y)
Definition box2.h:297
constexpr bool Intersects(const BOX2< Vec > &aRect) const
Definition box2.h:311
static const COLOR4D UNSPECIFIED
For legacy support; used as a value to indicate color hasn't been set yet.
Definition color4d.h:398
Helper class used to store the state of schematic items that can be connected to other schematic item...
Definition sch_item.h:96
DANGLING_END_T GetType() const
Definition sch_item.h:132
EDA_ITEM * GetItem() const
Definition sch_item.h:130
VECTOR2I GetPosition() const
Definition sch_item.h:129
The base class for create windows for drawing purpose.
const KIID m_Uuid
Definition eda_item.h:516
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
EDA_ITEM(EDA_ITEM *parent, KICAD_T idType, bool isSCH_ITEM=false, bool isBOARD_ITEM=false)
Definition eda_item.cpp:39
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition eda_text.h:97
ENUM_MAP & Map(T aValue, const wxString &aName)
Definition property.h:705
static ENUM_MAP< T > & Instance()
Definition property.h:699
wxPGChoices & Choices()
Definition property.h:748
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
int GetLineStyle() const
Definition netclass.h:234
int GetWireWidth() const
Definition netclass.h:204
COLOR4D GetSchematicColor(bool aIsForSave=false) const
Definition netclass.h:219
int GetBusWidth() const
Definition netclass.h:212
Base plotter engine class.
Definition plotter.h:121
void MoveTo(const VECTOR2I &pos)
Definition plotter.h:262
virtual void SetDash(int aLineWidth, LINE_STYLE aLineStyle)=0
void FinishTo(const VECTOR2I &pos)
Definition plotter.h:272
virtual void SetCurrentLineWidth(int width, void *aData=nullptr)=0
Set the line width for the next drawing.
virtual void SetColor(const COLOR4D &color)=0
Provide class metadata.Helper macro to map type hashes to names.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
Class for a bus to bus entry.
int GetPenWidth() const override
void GetEndPoints(std::vector< DANGLING_END_ITEM > &aItemList) override
Add the schematic item end points to aItemList if the item has end points.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
SCH_BUS_BUS_ENTRY(const VECTOR2I &pos=VECTOR2I(0, 0), bool aFlipY=false)
bool UpdateDanglingState(std::vector< DANGLING_END_ITEM > &aItemListByType, std::vector< DANGLING_END_ITEM > &aItemListByPos, const SCH_SHEET_PATH *aPath=nullptr) override
Test the schematic item to aItemList to check if it's dangling state has changed.
SCH_ITEM * m_connected_bus_items[2]
Pointer to the bus items (usually bus wires) connected to this bus-bus entry (either or both may be n...
Base class for a bus or wire entry.
bool HasConnectivityChanges(const SCH_ITEM *aItem, const SCH_SHEET_PATH *aInstance=nullptr) const override
Check if aItem has connectivity changes against this object.
double Similarity(const SCH_ITEM &aItem) const override
Return a measure of how likely the other object is to represent the same object.
VECTOR2I m_pos
LINE_STYLE m_lastResolvedLineStyle
COLOR4D GetBusEntryColor() const
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
void SetBusEntryColor(const COLOR4D &aColor)
std::vector< int > ViewGetLayers() const override
Return the all the layers within the VIEW the object is painted on.
VECTOR2I GetPosition() const override
bool m_isEndDangling
void SetPenWidth(int aWidth)
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
void SetWireStyle(WIRE_STYLE aStyle)
void swapData(SCH_ITEM *aItem) override
Swap the internal data structures aItem with the schematic item.
void MirrorHorizontally(int aCenter) override
Mirror item horizontally about aCenter.
bool operator==(const SCH_ITEM &aItem) const override
int m_lastResolvedWidth
std::vector< VECTOR2I > GetConnectionPoints() const override
Add all the connection points for this item to aPoints.
void SetLineStyle(LINE_STYLE aStyle)
bool IsConnectable() const override
int GetPenWidth() const override
WIRE_STYLE GetWireStyle() const
void Plot(PLOTTER *aPlotter, bool aBackground, const SCH_PLOT_OPTS &aPlotOpts, int aUnit, int aBodyStyle, const VECTOR2I &aOffset, bool aDimmed) override
Plot the item to aPlotter.
VECTOR2I GetEnd() const
bool IsDangling() const override
COLOR4D m_lastResolvedColor
STROKE_PARAMS m_stroke
void MirrorVertically(int aCenter) override
Mirror item vertically about aCenter.
VECTOR2I m_size
SCH_BUS_ENTRY_BASE(KICAD_T aType, const VECTOR2I &pos=VECTOR2I(0, 0), bool aFlipY=false)
LINE_STYLE GetEffectiveLineStyle() const
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
void Rotate(const VECTOR2I &aCenter, bool aRotateCCW) override
Rotate the item around aCenter 90 degrees in the clockwise direction.
bool m_isStartDangling
bool operator<(const SCH_ITEM &aItem) const override
bool doIsConnected(const VECTOR2I &aPosition) const override
Provide the object specific test to see if it is connected to aPosition.
Class for a wire to bus entry.
SCH_BUS_WIRE_ENTRY(const VECTOR2I &pos=VECTOR2I(0, 0), bool aFlipY=false)
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
int GetPenWidth() const override
bool UpdateDanglingState(std::vector< DANGLING_END_ITEM > &aItemListByType, std::vector< DANGLING_END_ITEM > &aItemListByPos, const SCH_SHEET_PATH *aPath=nullptr) override
Test the schematic item to aItemList to check if it's dangling state has changed.
void GetEndPoints(std::vector< DANGLING_END_ITEM > &aItemList) override
Add the schematic item end points to aItemList if the item has end points.
virtual bool ConnectionPropagatesTo(const EDA_ITEM *aItem) const override
Return true if this item should propagate connection info to aItem.
SCH_ITEM * m_connected_bus_item
Pointer to the bus item (usually a bus wire) connected to this bus-wire entry, if it is connected to ...
Each graphical item can have a SCH_CONNECTION describing its logical connection (to a bus or net).
bool IsBus() const
void AppendInfoToMsgPanel(std::vector< MSG_PANEL_ITEM > &aList) const
Adds information about the connection object to aList.
static bool IsBusLabel(const wxString &aLabel)
Test if aLabel has a bus notation.
Schematic editor (Eeschema) main window.
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition sch_item.h:167
SCH_RENDER_SETTINGS * getRenderSettings(PLOTTER *aPlotter) const
Definition sch_item.h:688
std::shared_ptr< NETCLASS > GetEffectiveNetClass(const SCH_SHEET_PATH *aSheet=nullptr) const
Definition sch_item.cpp:352
SCH_LAYER_ID GetLayer() const
Return the layer this item is on.
Definition sch_item.h:309
bool IsConnectivityDirty() const
Definition sch_item.h:554
SCH_ITEM(EDA_ITEM *aParent, KICAD_T aType, int aUnit=0, int aBodyStyle=0)
Definition sch_item.cpp:51
SCH_CONNECTION * Connection(const SCH_SHEET_PATH *aSheet=nullptr) const
Retrieve the connection associated with this object in the given sheet.
Definition sch_item.cpp:323
SCH_LAYER_ID m_layer
Definition sch_item.h:739
Segment description base class to describe items which have 2 end points (track, wire,...
Definition sch_line.h:42
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
#define DEFAULT_SCH_ENTRY_SIZE
The default text size in mils. (can be changed in preference menu)
#define DEFAULT_WIRE_WIDTH_MILS
The default bus width in mils. (can be changed in preference menu)
#define _(s)
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
static constexpr EDA_ANGLE ANGLE_270
Definition eda_angle.h:416
a few functions useful in geometry calculations.
@ LAYER_WIRE
Definition layer_ids.h:451
@ LAYER_NET_COLOR_HIGHLIGHT
Definition layer_ids.h:492
@ LAYER_BUS
Definition layer_ids.h:452
@ LAYER_SELECTION_SHADOWS
Definition layer_ids.h:493
@ LAYER_BUS_JUNCTION
Definition layer_ids.h:496
constexpr void MIRROR(T &aPoint, const T &aMirrorRef)
Updates aPoint with the mirror of aPoint relative to the aMirrorRef.
Definition mirror.h:45
bool ShapeHitTest(const SHAPE_LINE_CHAIN &aHitter, const SHAPE &aHittee, bool aHitteeContained)
Perform a shape-to-shape hit test.
#define _HKI(x)
Definition page_info.cpp:44
#define TYPE_HASH(x)
Definition property.h:73
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:62
#define REGISTER_TYPE(x)
static struct SCH_BUS_ENTRY_DESC _SCH_BUS_ENTRY_DESC
@ BUS_END
Definition sch_item.h:80
@ BUS_ENTRY_END
Definition sch_item.h:84
@ WIRE_END
Definition sch_item.h:79
@ WIRE_ENTRY_END
Definition sch_item.h:85
LINE_STYLE
Dashed line types.
SCH_BUS_ENTRY_DESC()
bool TestSegmentHit(const VECTOR2I &aRefPoint, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aDist)
Test if aRefPoint is with aDistance on the line defined by aStart and aEnd.
Definition trigo.cpp:175
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
Definition trigo.cpp:229
bool IsPointOnSegment(const VECTOR2I &aSegStart, const VECTOR2I &aSegEnd, const VECTOR2I &aTestPoint)
Test if aTestPoint is on line defined by aSegStart and aSegEnd.
Definition trigo.cpp:89
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:78
@ SCH_LINE_T
Definition typeinfo.h:165
@ SCH_LABEL_T
Definition typeinfo.h:169
@ SCH_BUS_BUS_ENTRY_T
Definition typeinfo.h:164
@ SCH_BUS_WIRE_ENTRY_T
Definition typeinfo.h:163
@ SCH_JUNCTION_T
Definition typeinfo.h:161
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695