KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcbnew/cross-probing.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 The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/old-licenses/gpl-3.0.html
19 * or you may search the http://www.gnu.org website for the version 2 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24
34#include <board.h>
36#include <footprint.h>
37#include <pad.h>
38#include <pcb_track.h>
39#include <pcb_group.h>
40#include <zone.h>
41#include <collectors.h>
42#include <eda_dde.h>
43#include <kiface_base.h>
44#include <kiway_express.h>
45#include <string_utils.h>
48#include <gal/painter.h>
49#include <pcb_edit_frame.h>
50#include <pcbnew_settings.h>
51#include <render_settings.h>
52#include <richio.h>
53#include <tool/tool_manager.h>
54#include <tools/pcb_actions.h>
58#include <wx/log.h>
59
60/* Execute a remote command sent via a socket on port KICAD_PCB_PORT_SERVICE_NUMBER
61 *
62 * Commands are:
63 *
64 * $NET: "net name" Highlight the given net
65 * $NETS: "net name 1,net name 2" Highlight all given nets
66 * $CLEAR Clear existing highlight
67 *
68 * $CONFIG Show the Manage Footprint Libraries dialog
69 * $CUSTOM_RULES Show the "Custom Rules" page of the Board Setup dialog
70 * $DRC Show the DRC dialog
71 */
72void PCB_EDIT_FRAME::ExecuteRemoteCommand( const char* cmdline )
73{
74 char line[1024];
75 char* idcmd;
76 char* text;
77 int netcode = -1;
78 bool multiHighlight = false;
79 BOARD* pcb = GetBoard();
80
82
84 KIGFX::RENDER_SETTINGS* renderSettings = view->GetPainter()->GetSettings();
85
86 strncpy( line, cmdline, sizeof(line) - 1 );
87 line[sizeof(line) - 1] = 0;
88
89 idcmd = strtok( line, " \n\r" );
90 text = strtok( nullptr, "\"\n\r" );
91
92 if( idcmd == nullptr )
93 return;
94
95 if( strcmp( idcmd, "$CONFIG" ) == 0 )
96 {
98 return;
99 }
100 else if( strcmp( idcmd, "$CUSTOM_RULES" ) == 0 )
101 {
102 ShowBoardSetupDialog( _( "Custom Rules" ) );
103 return;
104 }
105 else if( strcmp( idcmd, "$DRC" ) == 0 )
106 {
108 return;
109 }
110 else if( strcmp( idcmd, "$CLEAR" ) == 0 )
111 {
112 if( renderSettings->IsHighlightEnabled() )
113 {
114 renderSettings->SetHighlight( false );
115 view->UpdateAllLayersColor();
116 }
117
118 if( pcb->IsHighLightNetON() )
119 {
120 pcb->ResetNetHighLight();
121 SetMsgPanel( pcb );
122 }
123
124 GetCanvas()->Refresh();
125 return;
126 }
127 else if( strcmp( idcmd, "$NET:" ) == 0 )
128 {
129 if( !crossProbingSettings.auto_highlight )
130 return;
131
132 wxString net_name = From_UTF8( text );
133
134 NETINFO_ITEM* netinfo = pcb->FindNet( net_name );
135
136 if( netinfo )
137 {
138 netcode = netinfo->GetNetCode();
139
140 std::vector<MSG_PANEL_ITEM> items;
141 netinfo->GetMsgPanelInfo( this, items );
142 SetMsgPanel( items );
143 }
144
145 // fall through to highlighting section
146 }
147 else if( strcmp( idcmd, "$NETS:" ) == 0 )
148 {
149 if( !crossProbingSettings.auto_highlight )
150 return;
151
152 wxStringTokenizer netsTok = wxStringTokenizer( From_UTF8( text ), wxT( "," ) );
153 bool first = true;
154
155 while( netsTok.HasMoreTokens() )
156 {
157 NETINFO_ITEM* netinfo = pcb->FindNet( netsTok.GetNextToken() );
158
159 if( netinfo )
160 {
161 if( first )
162 {
163 // TODO: Once buses are included in netlist, show bus name
164 std::vector<MSG_PANEL_ITEM> items;
165 netinfo->GetMsgPanelInfo( this, items );
166 SetMsgPanel( items );
167 first = false;
168
169 pcb->SetHighLightNet( netinfo->GetNetCode() );
170 renderSettings->SetHighlight( true, netinfo->GetNetCode() );
171 multiHighlight = true;
172 }
173 else
174 {
175 pcb->SetHighLightNet( netinfo->GetNetCode(), true );
176 renderSettings->SetHighlight( true, netinfo->GetNetCode(), true );
177 }
178 }
179 }
180
181 netcode = -1;
182
183 // fall through to highlighting section
184 }
185
186 BOX2I bbox;
187
188 if( netcode > 0 || multiHighlight )
189 {
190 if( !multiHighlight )
191 {
192 renderSettings->SetHighlight( ( netcode >= 0 ), netcode );
193 pcb->SetHighLightNet( netcode );
194 }
195 else
196 {
197 // Just pick the first one for area calculation
198 netcode = *pcb->GetHighLightNetCodes().begin();
199 }
200
201 pcb->HighLightON();
202
203 auto merge_area =
204 [netcode, &bbox]( BOARD_CONNECTED_ITEM* aItem )
205 {
206 if( aItem->GetNetCode() == netcode )
207 bbox.Merge( aItem->GetBoundingBox() );
208 };
209
210 if( crossProbingSettings.center_on_items )
211 {
212 for( ZONE* zone : pcb->Zones() )
213 merge_area( zone );
214
215 for( PCB_TRACK* track : pcb->Tracks() )
216 merge_area( track );
217
218 for( FOOTPRINT* fp : pcb->Footprints() )
219 {
220 for( PAD* p : fp->Pads() )
221 merge_area( p );
222 }
223 }
224 }
225 else
226 {
227 renderSettings->SetHighlight( false );
228 }
229
230 if( crossProbingSettings.center_on_items && bbox.GetWidth() != 0 && bbox.GetHeight() != 0 )
231 {
232 if( crossProbingSettings.zoom_to_fit )
233 GetToolManager()->GetTool<PCB_SELECTION_TOOL>()->ZoomFitCrossProbeBBox( bbox );
234
235 FocusOnLocation( bbox.Centre() );
236 }
237
238 view->UpdateAllLayersColor();
239
240 // Ensure the display is refreshed, because in some installs the refresh is done only
241 // when the gal canvas has the focus, and that is not the case when crossprobing from
242 // Eeschema:
243 GetCanvas()->Refresh();
244}
245
246
247std::string FormatProbeItem( BOARD_ITEM* aItem )
248{
249 if( !aItem )
250 return "$CLEAR: \"HIGHLIGHTED\""; // message to clear highlight state
251
252 switch( aItem->Type() )
253 {
254 case PCB_FOOTPRINT_T:
255 {
256 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem );
257 return StrPrintf( "$PART: \"%s\"", TO_UTF8( footprint->GetReference() ) );
258 }
259
260 case PCB_PAD_T:
261 {
262 PAD* pad = static_cast<PAD*>( aItem );
263 FOOTPRINT* footprint = pad->GetParentFootprint();
264
265 return StrPrintf( "$PART: \"%s\" $PAD: \"%s\"",
266 TO_UTF8( footprint->GetReference() ),
267 TO_UTF8( pad->GetNumber() ) );
268 }
269
270 case PCB_FIELD_T:
271 {
272 PCB_FIELD* field = static_cast<PCB_FIELD*>( aItem );
273 FOOTPRINT* footprint = field->GetParentFootprint();
274 const char* text_key;
275
276 /* This can't be a switch since the break need to pull out
277 * from the outer switch! */
278 if( field->IsReference() )
279 text_key = "$REF:";
280 else if( field->IsValue() )
281 text_key = "$VAL:";
282 else
283 break;
284
285 return StrPrintf( "$PART: \"%s\" %s \"%s\"",
286 TO_UTF8( footprint->GetReference() ),
287 text_key,
288 TO_UTF8( field->GetText() ) );
289 }
290
291 default:
292 break;
293 }
294
295 return "";
296}
297
298
299template <typename ItemContainer>
300void collectItemsForSyncParts( ItemContainer& aItems, std::set<wxString>& parts )
301{
302 for( EDA_ITEM* item : aItems )
303 {
304 switch( item->Type() )
305 {
306 case PCB_GROUP_T:
307 {
308 PCB_GROUP* group = static_cast<PCB_GROUP*>( item );
309
310 collectItemsForSyncParts( group->GetItems(), parts );
311 break;
312 }
313 case PCB_FOOTPRINT_T:
314 {
315 FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );
316 wxString ref = footprint->GetReference();
317
318 parts.emplace( wxT( "F" ) + EscapeString( ref, CTX_IPC ) );
319 break;
320 }
321
322 case PCB_PAD_T:
323 {
324 PAD* pad = static_cast<PAD*>( item );
325 wxString ref = pad->GetParentFootprint()->GetReference();
326
327 parts.emplace( wxT( "P" ) + EscapeString( ref, CTX_IPC ) + wxT( "/" )
328 + EscapeString( pad->GetNumber(), CTX_IPC ) );
329 break;
330 }
331
332 default: break;
333 }
334 }
335}
336
337
338void PCB_EDIT_FRAME::SendSelectItemsToSch( const std::deque<EDA_ITEM*>& aItems,
339 EDA_ITEM* aFocusItem, bool aForce )
340{
341 std::string command = "$SELECT: ";
342
343 if( aFocusItem )
344 {
345 std::deque<EDA_ITEM*> focusItems = { aFocusItem };
346 std::set<wxString> focusParts;
347 collectItemsForSyncParts( focusItems, focusParts );
348
349 if( focusParts.size() > 0 )
350 {
351 command += "1,";
352 command += *focusParts.begin();
353 command += ",";
354 }
355 else
356 {
357 command += "0,";
358 }
359 }
360 else
361 {
362 command += "0,";
363 }
364
365 std::set<wxString> parts;
366 collectItemsForSyncParts( aItems, parts );
367
368 if( parts.empty() )
369 return;
370
371 for( wxString part : parts )
372 {
373 command += part;
374 command += ",";
375 }
376
377 command.pop_back();
378
379 if( Kiface().IsSingle() )
380 {
381 SendCommand( MSG_TO_SCH, command );
382 }
383 else
384 {
385 // Typically ExpressMail is going to be s-expression packets, but since
386 // we have existing interpreter of the selection packet on the other
387 // side in place, we use that here.
389 this );
390 }
391}
392
393
394void PCB_EDIT_FRAME::SendCrossProbeNetName( const wxString& aNetName )
395{
396 std::string packet = StrPrintf( "$NET: \"%s\"", TO_UTF8( aNetName ) );
397
398 if( !packet.empty() )
399 {
400 if( Kiface().IsSingle() )
401 {
402 SendCommand( MSG_TO_SCH, packet );
403 }
404 else
405 {
406 // Typically ExpressMail is going to be s-expression packets, but since
407 // we have existing interpreter of the cross probe packet on the other
408 // side in place, we use that here.
409 Kiway().ExpressMail( FRAME_SCH, MAIL_CROSS_PROBE, packet, this );
410 }
411 }
412}
413
414
416{
417 std::string packet = FormatProbeItem( aSyncItem );
418
419 if( !packet.empty() )
420 {
421 if( Kiface().IsSingle() )
422 {
423 SendCommand( MSG_TO_SCH, packet );
424 }
425 else
426 {
427 // Typically ExpressMail is going to be s-expression packets, but since
428 // we have existing interpreter of the cross probe packet on the other
429 // side in place, we use that here.
430 Kiway().ExpressMail( FRAME_SCH, MAIL_CROSS_PROBE, packet, this );
431 }
432 }
433}
434
435
436std::vector<BOARD_ITEM*> PCB_EDIT_FRAME::FindItemsFromSyncSelection( std::string syncStr )
437{
438 wxArrayString syncArray = wxStringTokenize( syncStr, "," );
439
440 std::vector<std::pair<int, BOARD_ITEM*>> orderPairs;
441
442 for( FOOTPRINT* footprint : GetBoard()->Footprints() )
443 {
444 if( footprint == nullptr )
445 continue;
446
447 wxString fpSheetPath = footprint->GetPath().AsString().BeforeLast( '/' );
448 wxString fpUUID = footprint->m_Uuid.AsString();
449
450 if( fpSheetPath.IsEmpty() )
451 fpSheetPath += '/';
452
453 if( fpUUID.empty() )
454 continue;
455
456 wxString fpRefEscaped = EscapeString( footprint->GetReference(), CTX_IPC );
457
458 for( unsigned index = 0; index < syncArray.size(); ++index )
459 {
460 wxString syncEntry = syncArray[index];
461
462 if( syncEntry.empty() )
463 continue;
464
465 wxString syncData = syncEntry.substr( 1 );
466
467 switch( syncEntry.GetChar( 0 ).GetValue() )
468 {
469 case 'S': // Select sheet with subsheets: S<Sheet path>
470 if( fpSheetPath.StartsWith( syncData ) )
471 {
472 orderPairs.emplace_back( index, footprint );
473 }
474 break;
475 case 'F': // Select footprint: F<Reference>
476 if( syncData == fpRefEscaped )
477 {
478 orderPairs.emplace_back( index, footprint );
479 }
480 break;
481 case 'P': // Select pad: P<Footprint reference>/<Pad number>
482 {
483 if( syncData.StartsWith( fpRefEscaped ) )
484 {
485 wxString selectPadNumberEscaped =
486 syncData.substr( fpRefEscaped.size() + 1 ); // Skips the slash
487
488 wxString selectPadNumber = UnescapeString( selectPadNumberEscaped );
489
490 for( PAD* pad : footprint->Pads() )
491 {
492 if( selectPadNumber == pad->GetNumber() )
493 {
494 orderPairs.emplace_back( index, pad );
495 }
496 }
497 }
498 break;
499 }
500 default: break;
501 }
502 }
503 }
504
505 std::sort(
506 orderPairs.begin(), orderPairs.end(),
507 []( const std::pair<int, BOARD_ITEM*>& a, const std::pair<int, BOARD_ITEM*>& b ) -> bool
508 {
509 return a.first < b.first;
510 } );
511
512 std::vector<BOARD_ITEM*> items;
513 items.reserve( orderPairs.size() );
514
515 for( const std::pair<int, BOARD_ITEM*>& pair : orderPairs )
516 items.push_back( pair.second );
517
518 return items;
519}
520
521
523{
524 std::string& payload = mail.GetPayload();
525
526 switch( mail.Command() )
527 {
529 {
532
533 for( FOOTPRINT* footprint : GetBoard()->Footprints() )
534 {
535 if( footprint->GetAttributes() & FP_BOARD_ONLY )
536 continue; // Don't add board-only footprints to the netlist
537
538 COMPONENT* component = new COMPONENT( footprint->GetFPID(), footprint->GetReference(),
539 footprint->GetValue(), footprint->GetPath(), {} );
540
541 for( PAD* pad : footprint->Pads() )
542 {
543 const wxString& netname = pad->GetShortNetname();
544
545 if( !netname.IsEmpty() )
546 {
547 component->AddNet( pad->GetNumber(), netname, pad->GetPinFunction(),
548 pad->GetPinType() );
549 }
550 }
551
552 nlohmann::ordered_map<wxString, wxString> fields;
553 for( PCB_FIELD* field : footprint->GetFields() )
554 fields[field->GetCanonicalName()] = field->GetText();
555
556 component->SetFields( fields );
557
558 // Add DNP and Exclude from BOM properties
559 std::map<wxString, wxString> properties;
560
561 if( footprint->GetAttributes() & FP_DNP )
562 properties.emplace( "dnp", "" );
563
564 if( footprint->GetAttributes() & FP_EXCLUDE_FROM_BOM )
565 properties.emplace( "exclude_from_bom", "" );
566
567 component->SetProperties( properties );
568
569 netlist.AddComponent( component );
570 }
571
572 netlist.Format( "pcb_netlist", &sf, 0, CTL_OMIT_FILTERS );
573 payload = sf.GetString();
574 break;
575 }
576
578 try
579 {
581 FetchNetlistFromSchematic( netlist, wxEmptyString );
582
583 BOARD_NETLIST_UPDATER updater( this, GetBoard() );
584 updater.SetLookupByTimestamp( false );
585 updater.SetDeleteUnusedFootprints( false );
586 updater.SetReplaceFootprints( false );
587 updater.SetTransferGroups( false );
588 updater.UpdateNetlist( netlist );
589
590 bool dummy;
591 OnNetlistChanged( updater, &dummy );
592 }
593 catch( const IO_ERROR& )
594 {
595 assert( false ); // should never happen
596 return;
597 }
598
599 break;
600
601 case MAIL_CROSS_PROBE:
602 ExecuteRemoteCommand( payload.c_str() );
603 break;
604
605
606 case MAIL_SELECTION:
607 if( !GetPcbNewSettings()->m_CrossProbing.on_selection )
608 break;
609
611
613 {
614 // $SELECT: <mode 0 - only footprints, 1 - with connections>,<spec1>,<spec2>,<spec3>
615 std::string prefix = "$SELECT: ";
616
617 if( !payload.compare( 0, prefix.size(), prefix ) )
618 {
619 std::string del = ",";
620 std::string paramStr = payload.substr( prefix.size() );
621 size_t modeEnd = paramStr.find( del );
622 bool selectConnections = false;
623
624 try
625 {
626 if( std::stoi( paramStr.substr( 0, modeEnd ) ) == 1 )
627 selectConnections = true;
628 }
629 catch( std::invalid_argument& )
630 {
631 wxFAIL;
632 }
633
634 std::vector<BOARD_ITEM*> items =
635 FindItemsFromSyncSelection( paramStr.substr( modeEnd + 1 ) );
636
637 m_probingSchToPcb = true; // recursion guard
638
639 if( selectConnections )
641 else
643
644 // Update 3D viewer highlighting
645 Update3DView( false, GetPcbNewSettings()->m_Display.m_Live3DRefresh );
646
647 m_probingSchToPcb = false;
648 }
649
650 break;
651 }
652
653 case MAIL_PCB_UPDATE:
655 break;
656
657 case MAIL_IMPORT_FILE:
658 {
659 // Extract file format type and path (plugin type, path and properties keys, values separated with \n)
660 std::stringstream ss( payload );
661 char delim = '\n';
662
663 std::string formatStr;
664 wxCHECK( std::getline( ss, formatStr, delim ), /* void */ );
665
666 std::string fnameStr;
667 wxCHECK( std::getline( ss, fnameStr, delim ), /* void */ );
668 wxASSERT( !fnameStr.empty() );
669
670 int importFormat;
671
672 try
673 {
674 importFormat = std::stoi( formatStr );
675 }
676 catch( std::invalid_argument& )
677 {
678 wxFAIL;
679 importFormat = -1;
680 }
681
682 std::map<std::string, UTF8> props;
683
684 std::string key, value;
685 do
686 {
687 if( !std::getline( ss, key, delim ) )
688 break;
689
690 if( !std::getline( ss, value, delim ) )
691 break;
692
693 props.emplace( key, value );
694
695 } while( true );
696
697 if( importFormat >= 0 )
698 importFile( fnameStr, importFormat, props.empty() ? nullptr : &props );
699
700 break;
701 }
702
705 break;
706
707 case MAIL_RELOAD_LIB:
709 break;
710
711 // many many others.
712 default:
713 ;
714 }
715}
716
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
static TOOL_ACTION updatePcbFromSchematic
Definition: actions.h:257
static TOOL_ACTION pluginsReload
Definition: actions.h:287
static TOOL_ACTION showFootprintLibTable
Definition: actions.h:276
CROSS_PROBING_SETTINGS m_CrossProbing
Definition: app_settings.h:214
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
FOOTPRINT * GetParentFootprint() const
Definition: board_item.cpp:97
Update the BOARD with a new netlist.
bool UpdateNetlist(NETLIST &aNetlist)
Update the board's components according to the new netlist.
void SetDeleteUnusedFootprints(bool aEnabled)
void SetReplaceFootprints(bool aEnabled)
void SetLookupByTimestamp(bool aEnabled)
void SetTransferGroups(bool aEnabled)
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:317
const std::set< int > & GetHighLightNetCodes() const
Definition: board.h:577
void SetHighLightNet(int aNetCode, bool aMulti=false)
Select the netcode to be highlighted.
Definition: board.cpp:2833
NETINFO_ITEM * FindNet(int aNetcode) const
Search for a net with the given netcode.
Definition: board.cpp:2090
const ZONES & Zones() const
Definition: board.h:362
void ResetNetHighLight()
Reset all high light data to the init state.
Definition: board.cpp:2824
const FOOTPRINTS & Footprints() const
Definition: board.h:358
const TRACKS & Tracks() const
Definition: board.h:356
bool IsHighLightNetON() const
Definition: board.h:593
void HighLightON(bool aValue=true)
Enable or disable net highlighting.
Definition: board.cpp:2846
constexpr size_type GetWidth() const
Definition: box2.h:214
constexpr Vec Centre() const
Definition: box2.h:97
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:658
constexpr size_type GetHeight() const
Definition: box2.h:215
Store all of the related footprint information found in a netlist.
Definition: pcb_netlist.h:100
void SetFields(nlohmann::ordered_map< wxString, wxString > &aFields)
Definition: pcb_netlist.h:148
void SetProperties(std::map< wxString, wxString > &aProps)
Definition: pcb_netlist.h:154
void AddNet(const wxString &aPinName, const wxString &aNetName, const wxString &aPinFunction, const wxString &aPinType)
Definition: pcb_netlist.h:120
void SetMsgPanel(const std::vector< MSG_PANEL_ITEM > &aList)
Clear the message panel and populates it with the contents of aList.
void FocusOnLocation(const VECTOR2I &aPos)
Useful to focus on a particular location, in find functions.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:97
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:109
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:97
const wxString & GetReference() const
Definition: footprint.h:625
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
bool IsHighlightEnabled() const
Return current highlight setting.
void SetHighlight(bool aEnabled, int aNetcode=-1, bool aMulti=false)
Turns on/off highlighting.
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:67
void UpdateAllLayersColor()
Apply the new coloring scheme to all layers.
Definition: view.cpp:765
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:216
Carry a payload from one KIWAY_PLAYER to another within a PROJECT.
Definition: kiway_express.h:40
std::string & GetPayload()
Return the payload, which can be any text but it typically self identifying s-expression.
Definition: kiway_express.h:58
MAIL_T Command()
Returns the MAIL_T associated with this mail.
Definition: kiway_express.h:50
virtual void ExpressMail(FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
Send aPayload to aDestination from aSource.
Definition: kiway.cpp:499
Handle the data for a net.
Definition: netinfo.h:56
int GetNetCode() const
Definition: netinfo.h:108
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Return the information about the NETINFO_ITEM in aList to display in the message panel.
Store information read from a netlist along with the flags used to update the NETLIST in the BOARD.
Definition: pcb_netlist.h:274
Definition: pad.h:54
static TOOL_ACTION runDRC
Definition: pcb_actions.h:447
static TOOL_ACTION syncSelection
Sets selection to specified items, zooms to fit, if enabled.
Definition: pcb_actions.h:63
static TOOL_ACTION syncSelectionWithNets
Sets selection to specified items with connected nets, zooms to fit, if enabled.
Definition: pcb_actions.h:66
PCBNEW_SETTINGS * GetPcbNewSettings() const
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
BOARD * GetBoard() const
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
void ShowBoardSetupDialog(const wxString &aInitialPage=wxEmptyString)
void KiwayMailIn(KIWAY_EXPRESS &aEvent) override
Receive KIWAY_EXPRESS messages from other players.
void OnNetlistChanged(BOARD_NETLIST_UPDATER &aUpdater, bool *aRunDragCommand)
Called after netlist is updated.
Definition: netlist.cpp:87
void ExecuteRemoteCommand(const char *cmdline) override
Execute a remote command send by Eeschema via a socket, port KICAD_PCB_PORT_SERVICE_NUMBER (currently...
void SendCrossProbeItem(BOARD_ITEM *aSyncItem)
Send a message to the schematic editor so that it may move its cursor to an item with the same refere...
bool FetchNetlistFromSchematic(NETLIST &aNetlist, const wxString &aAnnotateMessage)
void SendSelectItemsToSch(const std::deque< EDA_ITEM * > &aItems, EDA_ITEM *aFocusItem, bool aForce)
Send a message to the schematic editor to try to find schematic counterparts of specified PCB items a...
std::vector< BOARD_ITEM * > FindItemsFromSyncSelection(std::string syncStr)
Used to find items by selection synchronization spec string.
PCB_DESIGN_BLOCK_PANE * m_designBlocksPane
bool importFile(const wxString &aFileName, int aFileType, const std::map< std::string, UTF8 > *aProperties=nullptr)
Load the given filename but sets the path to the current project path.
void SendCrossProbeNetName(const wxString &aNetName)
Send a net name to Eeschema for highlighting.
bool IsReference() const
Definition: pcb_field.h:68
bool IsValue() const
Definition: pcb_field.h:69
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:53
The selection tool: currently supports:
Implement an OUTPUTFORMATTER to a memory buffer.
Definition: richio.h:449
const std::string & GetString()
Definition: richio.h:472
TOOL_MANAGER * m_toolManager
Definition: tools_holder.h:171
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:55
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:150
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:395
Handle a list of polygons defining a copper zone.
Definition: zone.h:74
#define CTL_OMIT_FILTERS
Omit the ki_fp_filters attribute in .kicad_xxx files.
Definition: ctl_flags.h:41
#define _(s)
bool SendCommand(int aService, const std::string &aMessage)
Used by a client to sent (by a socket connection) a data to a server.
Definition: eda_dde.cpp:310
DDE server & client.
#define MSG_TO_SCH
Definition: eda_dde.h:50
@ FP_DNP
Definition: footprint.h:86
@ FP_BOARD_ONLY
Definition: footprint.h:84
@ FP_EXCLUDE_FROM_BOM
Definition: footprint.h:83
@ FRAME_SCH
Definition: frame_type.h:34
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
@ MAIL_PCB_UPDATE_LINKS
Definition: mail_type.h:52
@ MAIL_IMPORT_FILE
Definition: mail_type.h:48
@ MAIL_CROSS_PROBE
Definition: mail_type.h:39
@ MAIL_PCB_UPDATE
Definition: mail_type.h:46
@ MAIL_SELECTION_FORCE
Definition: mail_type.h:41
@ MAIL_RELOAD_PLUGINS
Definition: mail_type.h:58
@ MAIL_SELECTION
Definition: mail_type.h:40
@ MAIL_RELOAD_LIB
Definition: mail_type.h:57
@ MAIL_PCB_GET_NETLIST
Definition: mail_type.h:51
Class to handle a set of BOARD_ITEMs.
void collectItemsForSyncParts(ItemContainer &aItems, std::set< wxString > &parts)
std::string FormatProbeItem(BOARD_ITEM *aItem)
int StrPrintf(std::string *result, const char *format,...)
This is like sprintf() but the output is appended to a std::string instead of to a character array.
Definition: richio.cpp:71
KIWAY Kiway(KFCTL_STANDALONE)
std::vector< FAB_LAYER_COLOR > dummy
wxString UnescapeString(const wxString &aSource)
wxString From_UTF8(const char *cstring)
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: string_utils.h:429
@ CTX_IPC
Definition: string_utils.h:56
Cross-probing behavior.
Definition: app_settings.h:32
bool zoom_to_fit
Zoom to fit items (ignored if center_on_items is off).
Definition: app_settings.h:35
bool center_on_items
Automatically pan to cross-probed items.
Definition: app_settings.h:34
bool auto_highlight
Automatically turn on highlight mode in the target frame.
Definition: app_settings.h:36
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:110
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition: typeinfo.h:90
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition: typeinfo.h:86
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87