KiCad PCB EDA Suite
Loading...
Searching...
No Matches
kicad_clipboard.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) 2017 KiCad Developers, see AUTHORS.TXT for contributors.
5 * Copyright (C) 2017-2023 KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Kristoffer Ödmark
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include <wx/clipbrd.h>
27#include <wx/log.h>
28
29#include <board.h>
30#include <build_version.h>
31#include <core/ignore.h>
32#include <font/fontconfig.h>
33#include <pad.h>
34#include <pcb_group.h>
35#include <pcb_generator.h>
36#include <pcb_text.h>
37#include <pcb_table.h>
38#include <zone.h>
39#include <locale_io.h>
42#include <kicad_clipboard.h>
43#include <kidialog.h>
44
47 m_formatter()
48{
50}
51
52
54{
55}
56
57
59{
60 m_board = aBoard;
61}
62
63
64void CLIPBOARD_IO::SaveSelection( const PCB_SELECTION& aSelected, bool isFootprintEditor )
65{
66 VECTOR2I refPoint( 0, 0 );
67
68 // dont even start if the selection is empty
69 if( aSelected.Empty() )
70 return;
71
72 if( aSelected.HasReferencePoint() )
73 refPoint = aSelected.GetReferencePoint();
74
75 // Prepare net mapping that assures that net codes saved in a file are consecutive integers
77
78 auto deleteUnselectedCells =
79 []( PCB_TABLE* aTable )
80 {
81 int minCol = aTable->GetColCount();
82 int maxCol = -1;
83 int minRow = aTable->GetRowCount();
84 int maxRow = -1;
85
86 for( int row = 0; row < aTable->GetRowCount(); ++row )
87 {
88 for( int col = 0; col < aTable->GetColCount(); ++col )
89 {
90 PCB_TABLECELL* cell = aTable->GetCell( row, col );
91
92 if( cell->IsSelected() )
93 {
94 minRow = std::min( minRow, row );
95 maxRow = std::max( maxRow, row );
96 minCol = std::min( minCol, col );
97 maxCol = std::max( maxCol, col );
98 }
99 else
100 {
101 cell->SetFlags( STRUCT_DELETED );
102 }
103 }
104 }
105
106 wxCHECK_MSG( maxCol >= minCol && maxRow >= minRow, /*void*/,
107 wxT( "No selected cells!" ) );
108
109 // aTable is always a clone in the clipboard case
110 int destRow = 0;
111
112 for( int row = minRow; row <= maxRow; row++ )
113 aTable->SetRowHeight( destRow++, aTable->GetRowHeight( row ) );
114
115 int destCol = 0;
116
117 for( int col = minCol; col <= maxCol; col++ )
118 aTable->SetColWidth( destCol++, aTable->GetColWidth( col ) );
119
120 aTable->DeleteMarkedCells();
121 aTable->SetColCount( ( maxCol - minCol ) + 1 );
122 aTable->Normalize();
123 };
124
125 std::set<PCB_TABLE*> promotedTables;
126
127 auto parentIsPromoted =
128 [&]( PCB_TABLECELL* cell ) -> bool
129 {
130 for( PCB_TABLE* table : promotedTables )
131 {
132 if( table->m_Uuid == cell->GetParent()->m_Uuid )
133 return true;
134 }
135
136 return false;
137 };
138
139 if( aSelected.Size() == 1 && aSelected.Front()->Type() == PCB_FOOTPRINT_T )
140 {
141 // make the footprint safe to transfer to other pcbs
142 const FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aSelected.Front() );
143 // Do not modify existing board
144 FOOTPRINT newFootprint( *footprint );
145
146 for( PAD* pad : newFootprint.Pads() )
147 pad->SetNetCode( 0 );
148
149 // locked means "locked in place"; copied items therefore can't be locked
150 newFootprint.SetLocked( false );
151
152 // locate the reference point at (0, 0) in the copied items
153 newFootprint.Move( VECTOR2I( -refPoint.x, -refPoint.y ) );
154
155 Format( static_cast<BOARD_ITEM*>( &newFootprint ) );
156
157 newFootprint.SetParent( nullptr );
158 newFootprint.SetParentGroup( nullptr );
159 }
160 else if( isFootprintEditor )
161 {
162 FOOTPRINT partialFootprint( m_board );
163
164 // Useful to copy the selection to the board editor (if any), and provides
165 // a dummy lib id.
166 // Perhaps not a good Id, but better than a empty id
167 KIID dummy;
168 LIB_ID id( "clipboard", dummy.AsString() );
169 partialFootprint.SetFPID( id );
170
171 for( EDA_ITEM* item : aSelected )
172 {
173 BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( item );
174 BOARD_ITEM* copy = nullptr;
175
176 wxCHECK2( boardItem, continue );
177
178 if( PCB_FIELD* field = dynamic_cast<PCB_FIELD*>( item ) )
179 {
180 if( field->IsMandatoryField() )
181 continue;
182 }
183
184 if( boardItem->Type() == PCB_GROUP_T )
185 {
186 copy = static_cast<PCB_GROUP*>( boardItem )->DeepClone();
187 }
188 else if( boardItem->Type() == PCB_GENERATOR_T )
189 {
190 copy = static_cast<PCB_GENERATOR*>( boardItem )->DeepClone();
191 }
192 else if( item->Type() == PCB_TABLECELL_T )
193 {
194 if( parentIsPromoted( static_cast<PCB_TABLECELL*>( item ) ) )
195 continue;
196
197 copy = static_cast<BOARD_ITEM*>( item->GetParent()->Clone() );
198 promotedTables.insert( static_cast<PCB_TABLE*>( copy ) );
199 }
200 else
201 {
202 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
203 }
204
205 // If it is only a footprint, clear the nets from the pads
206 if( PAD* pad = dynamic_cast<PAD*>( copy ) )
207 pad->SetNetCode( 0 );
208
209 // Don't copy group membership information for the 1st level objects being copied
210 // since the group they belong to isn't being copied.
211 copy->SetParentGroup( nullptr );
212
213 // Add the pad to the new footprint before moving to ensure the local coords are
214 // correct
215 partialFootprint.Add( copy );
216
217 // A list of not added items, when adding items to the footprint
218 // some PCB_TEXT (reference and value) cannot be added to the footprint
219 std::vector<BOARD_ITEM*> skipped_items;
220
221 if( copy->Type() == PCB_GROUP_T || copy->Type() == PCB_GENERATOR_T )
222 {
223 copy->RunOnDescendants(
224 [&]( BOARD_ITEM* descendant )
225 {
226 // One cannot add an additional mandatory field to a given footprint:
227 // only one is allowed. So add only non-mandatory fields.
228 bool can_add = true;
229
230 if( const PCB_FIELD* field = dynamic_cast<const PCB_FIELD*>( item ) )
231 {
232 if( field->IsMandatoryField() )
233 can_add = false;
234 }
235
236 if( can_add )
237 partialFootprint.Add( descendant );
238 else
239 skipped_items.push_back( descendant );
240 } );
241 }
242
243 // locate the reference point at (0, 0) in the copied items
244 copy->Move( -refPoint );
245
246 // Now delete items, duplicated but not added:
247 for( BOARD_ITEM* skipped_item : skipped_items )
248 {
249 static_cast<PCB_GROUP*>( copy )->RemoveItem( skipped_item );
250 skipped_item->SetParentGroup( nullptr );
251 delete skipped_item;
252 }
253 }
254
255 // Set the new relative internal local coordinates of copied items
256 FOOTPRINT* editedFootprint = m_board->Footprints().front();
257 VECTOR2I moveVector = partialFootprint.GetPosition() + editedFootprint->GetPosition();
258
259 partialFootprint.MoveAnchorPosition( moveVector );
260
261 for( PCB_TABLE* table : promotedTables )
262 deleteUnselectedCells( table );
263
264 Format( &partialFootprint, 0 );
265
266 partialFootprint.SetParent( nullptr );
267 }
268 else
269 {
270 // we will fake being a .kicad_pcb to get the full parser kicking
271 // This means we also need layers and nets
272 LOCALE_IO io;
273
274 m_formatter.Print( 0, "(kicad_pcb (version %d) (generator \"pcbnew\") (generator_version \"%s\")\n",
276
277 m_formatter.Print( 0, "\n" );
278
281
282 m_formatter.Print( 0, "\n" );
283
284 for( EDA_ITEM* item : aSelected )
285 {
286 BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( item );
287 BOARD_ITEM* copy = nullptr;
288
289 wxCHECK2( boardItem, continue );
290
291 if( boardItem->Type() == PCB_FIELD_T )
292 {
293 PCB_FIELD* field = static_cast<PCB_FIELD*>( boardItem );
294 copy = new PCB_TEXT( m_board );
295
296 PCB_TEXT* textItem = static_cast<PCB_TEXT*>( copy );
297 textItem->SetPosition( field->GetPosition() );
298 textItem->SetLayer( field->GetLayer() );
299 textItem->SetHyperlink( field->GetHyperlink() );
300 textItem->SetText( field->GetText() );
301 textItem->SetAttributes( field->GetAttributes() );
302 textItem->SetTextAngle( field->GetDrawRotation() );
303
304 if ( textItem->GetText() == wxT( "${VALUE}" ) )
305 textItem->SetText( boardItem->GetParentFootprint()->GetValue() );
306 else if ( textItem->GetText() == wxT( "${REFERENCE}" ) )
307 textItem->SetText( boardItem->GetParentFootprint()->GetReference() );
308
309 }
310 else if( boardItem->Type() == PCB_TEXT_T )
311 {
312 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
313
314 PCB_TEXT* textItem = static_cast<PCB_TEXT*>( copy );
315
316 if( textItem->GetText() == wxT( "${VALUE}" ) )
317 textItem->SetText( boardItem->GetParentFootprint()->GetValue() );
318 else if( textItem->GetText() == wxT( "${REFERENCE}" ) )
319 textItem->SetText( boardItem->GetParentFootprint()->GetReference() );
320 }
321 else if( boardItem->Type() == PCB_GROUP_T )
322 {
323 copy = static_cast<PCB_GROUP*>( boardItem )->DeepClone();
324 }
325 else if( boardItem->Type() == PCB_GENERATOR_T )
326 {
327 copy = static_cast<PCB_GENERATOR*>( boardItem )->DeepClone();
328 }
329 else if( item->Type() == PCB_TABLECELL_T )
330 {
331 if( parentIsPromoted( static_cast<PCB_TABLECELL*>( item ) ) )
332 continue;
333
334 copy = static_cast<BOARD_ITEM*>( item->GetParent()->Clone() );
335 promotedTables.insert( static_cast<PCB_TABLE*>( copy ) );
336 }
337 else
338 {
339 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
340 }
341
342 if( copy )
343 {
344 if( copy->Type() == PCB_FIELD_T || copy->Type() == PCB_PAD_T )
345 {
346 // Create a parent footprint to own the copied item
347 FOOTPRINT* footprint = new FOOTPRINT( m_board );
348
349 footprint->SetPosition( copy->GetPosition() );
350 footprint->Add( copy );
351
352 // Convert any mandatory fields to user fields. The destination footprint
353 // will already have its own mandatory fields.
354 if( PCB_FIELD* field = dynamic_cast<PCB_FIELD*>( copy ) )
355 {
356 if( field->IsMandatoryField() )
357 field->SetId( footprint->GetFieldCount() );
358 }
359
360 copy = footprint;
361 }
362
363 copy->SetLocked( false );
364
365 // locate the reference point at (0, 0) in the copied items
366 copy->Move( -refPoint );
367
368 if( copy->Type() == PCB_TABLE_T )
369 {
370 PCB_TABLE* table = static_cast<PCB_TABLE*>( copy );
371
372 if( promotedTables.count( table ) )
373 deleteUnselectedCells( table );
374 }
375
376 Format( copy, 1 );
377
378 if( copy->Type() == PCB_GROUP_T || copy->Type() == PCB_GENERATOR_T )
379 {
380 copy->RunOnDescendants(
381 [&]( BOARD_ITEM* descendant )
382 {
383 descendant->SetLocked( false );
384 Format( descendant, 1 );
385 } );
386 }
387
388 copy->SetParentGroup( nullptr );
389 delete copy;
390 }
391 }
392
393 m_formatter.Print( 0, "\n)" );
394 }
395
396 // These are placed at the end to minimize the open time of the clipboard
397 wxLogNull doNotLog; // disable logging of failed clipboard actions
398 auto clipboard = wxTheClipboard;
399 wxClipboardLocker clipboardLock( clipboard );
400
401 if( !clipboardLock || !clipboard->IsOpened() )
402 return;
403
404 clipboard->SetData( new wxTextDataObject( wxString( m_formatter.GetString().c_str(),
405 wxConvUTF8 ) ) );
406
407 clipboard->Flush();
408
409 #ifndef __WXOSX__
410 // This section exists to return the clipboard data, ensuring it has fully
411 // been processed by the system clipboard. This appears to be needed for
412 // extremely large clipboard copies on asynchronous linux clipboard managers
413 // such as KDE's Klipper. However, a read back of the data on OSX before the
414 // clipboard is closed seems to cause an ASAN error (heap-buffer-overflow)
415 // since it uses the cached version of the clipboard data and not the system
416 // clipboard data.
417 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
418 {
419 wxTextDataObject data;
420 clipboard->GetData( data );
421 ignore_unused( data.GetText() );
422 }
423 #endif
424}
425
426
428{
429 BOARD_ITEM* item;
430 wxString result;
431
432 wxLogNull doNotLog; // disable logging of failed clipboard actions
433
434 auto clipboard = wxTheClipboard;
435 wxClipboardLocker clipboardLock( clipboard );
436
437 if( !clipboardLock )
438 return nullptr;
439
440 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
441 {
442 wxTextDataObject data;
443 clipboard->GetData( data );
444 result = data.GetText();
445 }
446
447 try
448 {
449 item = PCB_IO_KICAD_SEXPR::Parse( result );
450 }
451 catch (...)
452 {
453 item = nullptr;
454 }
455
456 return item;
457}
458
459
460void CLIPBOARD_IO::SaveBoard( const wxString& aFileName, BOARD* aBoard,
461 const STRING_UTF8_MAP* aProperties )
462{
463 init( aProperties );
464
465 m_board = aBoard; // after init()
466
467 // Prepare net mapping that assures that net codes saved in a file are consecutive integers
468 m_mapping->SetBoard( aBoard );
469
470 STRING_FORMATTER formatter;
471
472 m_out = &formatter;
473
474 m_out->Print( 0, "(kicad_pcb (version %d) (generator \"pcbnew\") (generator_version \"%s\")\n", SEXPR_BOARD_FILE_VERSION, GetMajorMinorVersion().c_str().AsChar() );
475
476 Format( aBoard, 1 );
477
478 m_out->Print( 0, ")\n" );
479
480 wxLogNull doNotLog; // disable logging of failed clipboard actions
481
482 auto clipboard = wxTheClipboard;
483 wxClipboardLocker clipboardLock( clipboard );
484
485 if( !clipboardLock )
486 return;
487
488 clipboard->SetData( new wxTextDataObject(
489 wxString( m_formatter.GetString().c_str(), wxConvUTF8 ) ) );
490 clipboard->Flush();
491
492 // This section exists to return the clipboard data, ensuring it has fully
493 // been processed by the system clipboard. This appears to be needed for
494 // extremely large clipboard copies on asynchronous linux clipboard managers
495 // such as KDE's Klipper
496 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
497 {
498 wxTextDataObject data;
499 clipboard->GetData( data );
500 ignore_unused( data.GetText() );
501 }
502}
503
504
505BOARD* CLIPBOARD_IO::LoadBoard( const wxString& aFileName, BOARD* aAppendToMe,
506 const STRING_UTF8_MAP* aProperties, PROJECT* aProject )
507{
508 std::string result;
509
510 wxLogNull doNotLog; // disable logging of failed clipboard actions
511
513
514 auto clipboard = wxTheClipboard;
515 wxClipboardLocker clipboardLock( clipboard );
516
517 if( !clipboardLock )
518 return nullptr;
519
520 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
521 {
522 wxTextDataObject data;
523 clipboard->GetData( data );
524
525 result = data.GetText().mb_str();
526 }
527
528 std::function<bool( wxString, int, wxString, wxString )> queryUser =
529 [&]( wxString aTitle, int aIcon, wxString aMessage, wxString aAction ) -> bool
530 {
531 KIDIALOG dlg( nullptr, aMessage, aTitle, wxOK | wxCANCEL | aIcon );
532
533 if( !aAction.IsEmpty() )
534 dlg.SetOKLabel( aAction );
535
536 dlg.DoNotShowCheckbox( aMessage, 0 );
537
538 return dlg.ShowModal() == wxID_OK;
539 };
540
541 STRING_LINE_READER reader( result, wxT( "clipboard" ) );
542 PCB_IO_KICAD_SEXPR_PARSER parser( &reader, aAppendToMe, queryUser );
543
544 init( aProperties );
545
546 BOARD_ITEM* item;
547 BOARD* board;
548
549 try
550 {
551 item = parser.Parse();
552 }
553 catch( const FUTURE_FORMAT_ERROR& )
554 {
555 // Don't wrap a FUTURE_FORMAT_ERROR in another
556 throw;
557 }
558 catch( const PARSE_ERROR& parse_error )
559 {
560 if( parser.IsTooRecent() )
561 throw FUTURE_FORMAT_ERROR( parse_error, parser.GetRequiredVersion() );
562 else
563 throw;
564 }
565
566 if( item->Type() != PCB_T )
567 {
568 // The parser loaded something that was valid, but wasn't a board.
569 THROW_PARSE_ERROR( _( "Clipboard content is not KiCad compatible" ), parser.CurSource(),
570 parser.CurLine(), parser.CurLineNumber(), parser.CurOffset() );
571 }
572 else
573 {
574 board = dynamic_cast<BOARD*>( item );
575 }
576
577 // Give the filename to the board if it's new
578 if( board && !aAppendToMe )
579 board->SetFileName( aFileName );
580
581 return board;
582}
wxString GetMajorMinorVersion()
Get only the major and minor version in a string major.minor.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:240
void SetParentGroup(PCB_GROUP *aGroup)
Definition: board_item.h:92
virtual void SetLocked(bool aLocked)
Definition: board_item.h:316
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Definition: board_item.h:276
FOOTPRINT * GetParentFootprint() const
Definition: board_item.cpp:264
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:289
void SetFileName(const wxString &aFileName)
Definition: board.h:324
const FOOTPRINTS & Footprints() const
Definition: board.h:330
void SaveSelection(const PCB_SELECTION &selected, bool isFootprintEditor)
STRING_FORMATTER m_formatter
BOARD * LoadBoard(const wxString &aFileName, BOARD *aAppendToMe, const STRING_UTF8_MAP *aProperties=nullptr, PROJECT *aProject=nullptr) override
Load information from some input file format that this PCB_IO implementation knows about into either ...
BOARD_ITEM * Parse()
void SaveBoard(const wxString &aFileName, BOARD *aBoard, const STRING_UTF8_MAP *aProperties=nullptr) override
Write aBoard to a storage file in a format that this PCB_IO implementation knows about or it can be u...
void SetBoard(BOARD *aBoard)
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:89
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:127
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:101
bool IsSelected() const
Definition: eda_item.h:110
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:104
virtual EDA_ITEM * Clone() const
Create a duplicate of this item with linked list members set to NULL.
Definition: eda_item.cpp:82
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:94
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:291
wxString GetHyperlink() const
Definition: eda_text.h:358
const TEXT_ATTRIBUTES & GetAttributes() const
Definition: eda_text.h:191
void SetHyperlink(wxString aLink)
Definition: eda_text.h:359
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:182
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
Definition: eda_text.cpp:204
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2343
void SetFPID(const LIB_ID &aFPID)
Definition: footprint.h:238
int GetFieldCount() const
Return the number of fields in this symbol.
Definition: footprint.h:709
void SetLocked(bool isLocked) override
Set the #MODULE_is_LOCKED bit in the m_ModuleStatus.
Definition: footprint.h:410
void MoveAnchorPosition(const VECTOR2I &aMoveVector)
Move the reference point of the footprint.
Definition: footprint.cpp:2370
PADS & Pads()
Definition: footprint.h:195
void Move(const VECTOR2I &aMoveVector) override
Move this object.
Definition: footprint.cpp:2237
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: footprint.cpp:978
const wxString & GetValue() const
Definition: footprint.h:613
const wxString & GetReference() const
Definition: footprint.h:591
VECTOR2I GetPosition() const override
Definition: footprint.h:213
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition: kidialog.h:43
void DoNotShowCheckbox(wxString file, int line)
Checks the 'do not show again' setting for the dialog.
Definition: kidialog.cpp:51
int ShowModal() override
Definition: kidialog.cpp:95
Definition: kiid.h:49
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:49
void SetBoard(const BOARD *aBoard)
Set a BOARD object that is used to prepare the net code map.
Definition: netinfo.h:223
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:458
Definition: pad.h:54
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:52
Read a Pcbnew s-expression formatted LINE_READER object and returns the appropriate BOARD_ITEM object...
bool IsTooRecent()
Return whether a version number, if any was parsed, was too recent.
wxString GetRequiredVersion()
Return a string representing the version of KiCad required to open this file.
A #PLUGIN derivation for saving and loading Pcbnew s-expression formatted files.
NETINFO_MAPPING * m_mapping
mapping for net codes, so only not empty net codes are stored with consecutive integers as net codes
void init(const STRING_UTF8_MAP *aProperties)
void formatNetInformation(const BOARD *aBoard, int aNestLevel=0) const
formats the Nets and Netclasses
void Format(const BOARD_ITEM *aItem, int aNestLevel=0) const
Output aItem to aFormatter in s-expression format.
BOARD_ITEM * Parse(const wxString &aClipboardSourceInput)
void formatBoardLayers(const BOARD *aBoard, int aNestLevel=0) const
formats the board layer information
OUTPUTFORMATTER * m_out
output any Format()s to this, no ownership
BOARD * m_board
The board BOARD being worked on, no ownership here.
Definition: pcb_io.h:343
virtual VECTOR2I GetPosition() const override
Definition: pcb_text.h:82
virtual void SetPosition(const VECTOR2I &aPos) override
Definition: pcb_text.h:87
EDA_ANGLE GetDrawRotation() const override
Definition: pcb_text.cpp:227
Container for project specific data.
Definition: project.h:62
VECTOR2I GetReferencePoint() const
Definition: selection.cpp:171
EDA_ITEM * Front() const
Definition: selection.h:172
int Size() const
Returns the number of selected parts.
Definition: selection.h:116
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:110
bool HasReferencePoint() const
Definition: selection.h:211
Implement an OUTPUTFORMATTER to a memory buffer.
Definition: richio.h:433
const std::string & GetString()
Definition: richio.h:456
Is a LINE_READER that reads from a multiline 8 bit wide std::string.
Definition: richio.h:253
A name/value tuple with unique names and optional values.
static void SetReporter(REPORTER *aReporter)
Set the reporter to use for reporting font substitution warnings.
Definition: fontconfig.cpp:64
#define _(s)
#define STRUCT_DELETED
flag indication structures to be erased
void ignore_unused(const T &)
Definition: ignore.h:24
#define THROW_PARSE_ERROR(aProblem, aSource, aInputLine, aLineNumber, aByteIndex)
Definition: ki_exception.h:165
This file is part of the common library.
Class to handle a set of BOARD_ITEMs.
#define CTL_FOR_CLIPBOARD
Format output for the clipboard instead of footprint library or BOARD.
#define SEXPR_BOARD_FILE_VERSION
Current s-expression file format version. 2 was the last legacy format version.
Pcbnew s-expression file format parser definition.
std::vector< FAB_LAYER_COLOR > dummy
Variant of PARSE_ERROR indicating that a syntax or related error was likely caused by a file generate...
Definition: ki_exception.h:176
A filename or source description, a problem input line, a line number, a byte offset,...
Definition: ki_exception.h:120
@ PCB_T
Definition: typeinfo.h:82
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition: typeinfo.h:91
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:110
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition: typeinfo.h:92
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition: typeinfo.h:90
@ PCB_TABLECELL_T
class PCB_TABLECELL, PCB_TEXTBOX for use in tables
Definition: typeinfo.h:95
@ 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
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition: typeinfo.h:94
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:673