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 <pad.h>
33#include <pcb_group.h>
34#include <pcb_generator.h>
35#include <pcb_text.h>
36#include <pcb_table.h>
37#include <zone.h>
38#include <locale_io.h>
41#include <kicad_clipboard.h>
42#include "confirm.h"
43
46 m_formatter()
47{
49}
50
51
53{
54}
55
56
58{
59 m_board = aBoard;
60}
61
62
63void CLIPBOARD_IO::SaveSelection( const PCB_SELECTION& aSelected, bool isFootprintEditor )
64{
65 VECTOR2I refPoint( 0, 0 );
66
67 // dont even start if the selection is empty
68 if( aSelected.Empty() )
69 return;
70
71 if( aSelected.HasReferencePoint() )
72 refPoint = aSelected.GetReferencePoint();
73
74 // Prepare net mapping that assures that net codes saved in a file are consecutive integers
76
77 auto deleteUnselectedCells =
78 []( PCB_TABLE* aTable )
79 {
80 int minCol = aTable->GetColCount();
81 int maxCol = -1;
82 int minRow = aTable->GetRowCount();
83 int maxRow = -1;
84
85 for( int row = 0; row < aTable->GetRowCount(); ++row )
86 {
87 for( int col = 0; col < aTable->GetColCount(); ++col )
88 {
89 PCB_TABLECELL* cell = aTable->GetCell( row, col );
90
91 if( cell->IsSelected() )
92 {
93 minRow = std::min( minRow, row );
94 maxRow = std::max( maxRow, row );
95 minCol = std::min( minCol, col );
96 maxCol = std::max( maxCol, col );
97 }
98 else
99 {
100 cell->SetFlags( STRUCT_DELETED );
101 }
102 }
103 }
104
105 wxCHECK_MSG( maxCol >= minCol && maxRow >= minRow, /*void*/,
106 wxT( "No selected cells!" ) );
107
108 // aTable is always a clone in the clipboard case
109 int destRow = 0;
110
111 for( int row = minRow; row <= maxRow; row++ )
112 aTable->SetRowHeight( destRow++, aTable->GetRowHeight( row ) );
113
114 int destCol = 0;
115
116 for( int col = minCol; col <= maxCol; col++ )
117 aTable->SetColWidth( destCol++, aTable->GetColWidth( col ) );
118
119 aTable->DeleteMarkedCells();
120 aTable->SetColCount( ( maxCol - minCol ) + 1 );
121 aTable->Normalize();
122 };
123
124 std::set<PCB_TABLE*> promotedTables;
125
126 auto parentIsPromoted =
127 [&]( PCB_TABLECELL* cell ) -> bool
128 {
129 for( PCB_TABLE* table : promotedTables )
130 {
131 if( table->m_Uuid == cell->GetParent()->m_Uuid )
132 return true;
133 }
134
135 return false;
136 };
137
138 if( aSelected.Size() == 1 && aSelected.Front()->Type() == PCB_FOOTPRINT_T )
139 {
140 // make the footprint safe to transfer to other pcbs
141 const FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aSelected.Front() );
142 // Do not modify existing board
143 FOOTPRINT newFootprint( *footprint );
144
145 for( PAD* pad : newFootprint.Pads() )
146 pad->SetNetCode( 0 );
147
148 // locked means "locked in place"; copied items therefore can't be locked
149 newFootprint.SetLocked( false );
150
151 // locate the reference point at (0, 0) in the copied items
152 newFootprint.Move( VECTOR2I( -refPoint.x, -refPoint.y ) );
153
154 Format( static_cast<BOARD_ITEM*>( &newFootprint ) );
155
156 newFootprint.SetParent( nullptr );
157 newFootprint.SetParentGroup( nullptr );
158 }
159 else if( isFootprintEditor )
160 {
161 FOOTPRINT partialFootprint( m_board );
162
163 // Useful to copy the selection to the board editor (if any), and provides
164 // a dummy lib id.
165 // Perhaps not a good Id, but better than a empty id
166 KIID dummy;
167 LIB_ID id( "clipboard", dummy.AsString() );
168 partialFootprint.SetFPID( id );
169
170 for( EDA_ITEM* item : aSelected )
171 {
172 BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( item );
173 BOARD_ITEM* copy = nullptr;
174
175 wxCHECK2( boardItem, continue );
176
177 if( PCB_FIELD* field = dynamic_cast<PCB_FIELD*>( item ) )
178 {
179 if( field->IsMandatoryField() )
180 continue;
181 }
182
183 if( boardItem->Type() == PCB_GROUP_T )
184 {
185 copy = static_cast<PCB_GROUP*>( boardItem )->DeepClone();
186 }
187 else if( boardItem->Type() == PCB_GENERATOR_T )
188 {
189 copy = static_cast<PCB_GENERATOR*>( boardItem )->DeepClone();
190 }
191 else if( item->Type() == PCB_TABLECELL_T )
192 {
193 if( parentIsPromoted( static_cast<PCB_TABLECELL*>( item ) ) )
194 continue;
195
196 copy = static_cast<BOARD_ITEM*>( item->GetParent()->Clone() );
197 promotedTables.insert( static_cast<PCB_TABLE*>( copy ) );
198 }
199 else
200 {
201 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
202 }
203
204 // If it is only a footprint, clear the nets from the pads
205 if( PAD* pad = dynamic_cast<PAD*>( copy ) )
206 pad->SetNetCode( 0 );
207
208 // Don't copy group membership information for the 1st level objects being copied
209 // since the group they belong to isn't being copied.
210 copy->SetParentGroup( nullptr );
211
212 // Add the pad to the new footprint before moving to ensure the local coords are
213 // correct
214 partialFootprint.Add( copy );
215
216 // A list of not added items, when adding items to the footprint
217 // some PCB_TEXT (reference and value) cannot be added to the footprint
218 std::vector<BOARD_ITEM*> skipped_items;
219
220 if( copy->Type() == PCB_GROUP_T || copy->Type() == PCB_GENERATOR_T )
221 {
222 copy->RunOnDescendants(
223 [&]( BOARD_ITEM* descendant )
224 {
225 // One cannot add an additional mandatory field to a given footprint:
226 // only one is allowed. So add only non-mandatory fields.
227 bool can_add = true;
228
229 if( const PCB_FIELD* field = dynamic_cast<const PCB_FIELD*>( item ) )
230 {
231 if( field->IsMandatoryField() )
232 can_add = false;
233 }
234
235 if( can_add )
236 partialFootprint.Add( descendant );
237 else
238 skipped_items.push_back( descendant );
239 } );
240 }
241
242 // locate the reference point at (0, 0) in the copied items
243 copy->Move( -refPoint );
244
245 // Now delete items, duplicated but not added:
246 for( BOARD_ITEM* skipped_item : skipped_items )
247 {
248 static_cast<PCB_GROUP*>( copy )->RemoveItem( skipped_item );
249 skipped_item->SetParentGroup( nullptr );
250 delete skipped_item;
251 }
252 }
253
254 // Set the new relative internal local coordinates of copied items
255 FOOTPRINT* editedFootprint = m_board->Footprints().front();
256 VECTOR2I moveVector = partialFootprint.GetPosition() + editedFootprint->GetPosition();
257
258 partialFootprint.MoveAnchorPosition( moveVector );
259
260 for( PCB_TABLE* table : promotedTables )
261 deleteUnselectedCells( table );
262
263 Format( &partialFootprint, 0 );
264
265 partialFootprint.SetParent( nullptr );
266 }
267 else
268 {
269 // we will fake being a .kicad_pcb to get the full parser kicking
270 // This means we also need layers and nets
271 LOCALE_IO io;
272
273 m_formatter.Print( 0, "(kicad_pcb (version %d) (generator \"pcbnew\") (generator_version \"%s\")\n",
275
276 m_formatter.Print( 0, "\n" );
277
280
281 m_formatter.Print( 0, "\n" );
282
283 for( EDA_ITEM* item : aSelected )
284 {
285 BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( item );
286 BOARD_ITEM* copy = nullptr;
287
288 wxCHECK2( boardItem, continue );
289
290 if( boardItem->Type() == PCB_FIELD_T || boardItem->Type() == PCB_TEXT_T )
291 {
292 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
293
294 PCB_TEXT* textItem = static_cast<PCB_TEXT*>( copy );
295
296 if( textItem->GetText() == wxT( "${VALUE}" ) )
297 textItem->SetText( boardItem->GetParentFootprint()->GetValue() );
298 else if( textItem->GetText() == wxT( "${REFERENCE}" ) )
299 textItem->SetText( boardItem->GetParentFootprint()->GetReference() );
300 }
301 else if( boardItem->Type() == PCB_GROUP_T )
302 {
303 copy = static_cast<PCB_GROUP*>( boardItem )->DeepClone();
304 }
305 else if( boardItem->Type() == PCB_GENERATOR_T )
306 {
307 copy = static_cast<PCB_GENERATOR*>( boardItem )->DeepClone();
308 }
309 else if( item->Type() == PCB_TABLECELL_T )
310 {
311 if( parentIsPromoted( static_cast<PCB_TABLECELL*>( item ) ) )
312 continue;
313
314 copy = static_cast<BOARD_ITEM*>( item->GetParent()->Clone() );
315 promotedTables.insert( static_cast<PCB_TABLE*>( copy ) );
316 }
317 else
318 {
319 copy = static_cast<BOARD_ITEM*>( boardItem->Clone() );
320 }
321
322 if( copy )
323 {
324 if( copy->Type() == PCB_FIELD_T || copy->Type() == PCB_PAD_T )
325 {
326 // Create a parent footprint to own the copied item
327 FOOTPRINT* footprint = new FOOTPRINT( m_board );
328
329 footprint->SetPosition( copy->GetPosition() );
330 footprint->Add( copy );
331
332 // Convert any mandatory fields to user fields. The destination footprint
333 // will already have its own mandatory fields.
334 if( PCB_FIELD* field = dynamic_cast<PCB_FIELD*>( copy ) )
335 {
336 if( field->IsMandatoryField() )
337 field->SetId( footprint->GetFieldCount() );
338 }
339
340 copy = footprint;
341 }
342
343 copy->SetLocked( false );
344
345 // locate the reference point at (0, 0) in the copied items
346 copy->Move( -refPoint );
347
348 if( copy->Type() == PCB_TABLE_T )
349 {
350 PCB_TABLE* table = static_cast<PCB_TABLE*>( copy );
351
352 if( promotedTables.count( table ) )
353 deleteUnselectedCells( table );
354 }
355
356 Format( copy, 1 );
357
358 if( copy->Type() == PCB_GROUP_T || copy->Type() == PCB_GENERATOR_T )
359 {
360 copy->RunOnDescendants(
361 [&]( BOARD_ITEM* descendant )
362 {
363 descendant->SetLocked( false );
364 Format( descendant, 1 );
365 } );
366 }
367
368 copy->SetParentGroup( nullptr );
369 delete copy;
370 }
371 }
372
373 m_formatter.Print( 0, "\n)" );
374 }
375
376 // These are placed at the end to minimize the open time of the clipboard
377 wxLogNull doNotLog; // disable logging of failed clipboard actions
378 auto clipboard = wxTheClipboard;
379 wxClipboardLocker clipboardLock( clipboard );
380
381 if( !clipboardLock || !clipboard->IsOpened() )
382 return;
383
384 clipboard->SetData( new wxTextDataObject( wxString( m_formatter.GetString().c_str(),
385 wxConvUTF8 ) ) );
386
387 clipboard->Flush();
388
389 #ifndef __WXOSX__
390 // This section exists to return the clipboard data, ensuring it has fully
391 // been processed by the system clipboard. This appears to be needed for
392 // extremely large clipboard copies on asynchronous linux clipboard managers
393 // such as KDE's Klipper. However, a read back of the data on OSX before the
394 // clipboard is closed seems to cause an ASAN error (heap-buffer-overflow)
395 // since it uses the cached version of the clipboard data and not the system
396 // clipboard data.
397 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
398 {
399 wxTextDataObject data;
400 clipboard->GetData( data );
401 ignore_unused( data.GetText() );
402 }
403 #endif
404}
405
406
408{
409 BOARD_ITEM* item;
410 wxString result;
411
412 wxLogNull doNotLog; // disable logging of failed clipboard actions
413
414 auto clipboard = wxTheClipboard;
415 wxClipboardLocker clipboardLock( clipboard );
416
417 if( !clipboardLock )
418 return nullptr;
419
420 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
421 {
422 wxTextDataObject data;
423 clipboard->GetData( data );
424 result = data.GetText();
425 }
426
427 try
428 {
429 item = PCB_IO_KICAD_SEXPR::Parse( result );
430 }
431 catch (...)
432 {
433 item = nullptr;
434 }
435
436 return item;
437}
438
439
440void CLIPBOARD_IO::SaveBoard( const wxString& aFileName, BOARD* aBoard,
441 const STRING_UTF8_MAP* aProperties )
442{
443 init( aProperties );
444
445 m_board = aBoard; // after init()
446
447 // Prepare net mapping that assures that net codes saved in a file are consecutive integers
448 m_mapping->SetBoard( aBoard );
449
450 STRING_FORMATTER formatter;
451
452 m_out = &formatter;
453
454 m_out->Print( 0, "(kicad_pcb (version %d) (generator \"pcbnew\") (generator_version \"%s\")\n", SEXPR_BOARD_FILE_VERSION, GetMajorMinorVersion().c_str().AsChar() );
455
456 Format( aBoard, 1 );
457
458 m_out->Print( 0, ")\n" );
459
460 wxLogNull doNotLog; // disable logging of failed clipboard actions
461
462 auto clipboard = wxTheClipboard;
463 wxClipboardLocker clipboardLock( clipboard );
464
465 if( !clipboardLock )
466 return;
467
468 clipboard->SetData( new wxTextDataObject(
469 wxString( m_formatter.GetString().c_str(), wxConvUTF8 ) ) );
470 clipboard->Flush();
471
472 // This section exists to return the clipboard data, ensuring it has fully
473 // been processed by the system clipboard. This appears to be needed for
474 // extremely large clipboard copies on asynchronous linux clipboard managers
475 // such as KDE's Klipper
476 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
477 {
478 wxTextDataObject data;
479 clipboard->GetData( data );
480 ignore_unused( data.GetText() );
481 }
482}
483
484
485BOARD* CLIPBOARD_IO::LoadBoard( const wxString& aFileName, BOARD* aAppendToMe,
486 const STRING_UTF8_MAP* aProperties, PROJECT* aProject )
487{
488 std::string result;
489
490 wxLogNull doNotLog; // disable logging of failed clipboard actions
491
492 auto clipboard = wxTheClipboard;
493 wxClipboardLocker clipboardLock( clipboard );
494
495 if( !clipboardLock )
496 return nullptr;
497
498 if( clipboard->IsSupported( wxDF_TEXT ) || clipboard->IsSupported( wxDF_UNICODETEXT ) )
499 {
500 wxTextDataObject data;
501 clipboard->GetData( data );
502
503 result = data.GetText().mb_str();
504 }
505
506 std::function<bool( wxString, int, wxString, wxString )> queryUser =
507 [&]( wxString aTitle, int aIcon, wxString aMessage, wxString aAction ) -> bool
508 {
509 KIDIALOG dlg( nullptr, aMessage, aTitle, wxOK | wxCANCEL | aIcon );
510
511 if( !aAction.IsEmpty() )
512 dlg.SetOKLabel( aAction );
513
514 dlg.DoNotShowCheckbox( aMessage, 0 );
515
516 return dlg.ShowModal() == wxID_OK;
517 };
518
519 STRING_LINE_READER reader( result, wxT( "clipboard" ) );
520 PCB_IO_KICAD_SEXPR_PARSER parser( &reader, aAppendToMe, queryUser );
521
522 init( aProperties );
523
524 BOARD_ITEM* item;
525 BOARD* board;
526
527 try
528 {
529 item = parser.Parse();
530 }
531 catch( const FUTURE_FORMAT_ERROR& )
532 {
533 // Don't wrap a FUTURE_FORMAT_ERROR in another
534 throw;
535 }
536 catch( const PARSE_ERROR& parse_error )
537 {
538 if( parser.IsTooRecent() )
539 throw FUTURE_FORMAT_ERROR( parse_error, parser.GetRequiredVersion() );
540 else
541 throw;
542 }
543
544 if( item->Type() != PCB_T )
545 {
546 // The parser loaded something that was valid, but wasn't a board.
547 THROW_PARSE_ERROR( _( "Clipboard content is not KiCad compatible" ), parser.CurSource(),
548 parser.CurLine(), parser.CurLineNumber(), parser.CurOffset() );
549 }
550 else
551 {
552 board = dynamic_cast<BOARD*>( item );
553 }
554
555 // Give the filename to the board if it's new
556 if( board && !aAppendToMe )
557 board->SetFileName( aFileName );
558
559 return board;
560}
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:77
void SetParentGroup(PCB_GROUP *aGroup)
Definition: board_item.h:90
virtual void SetLocked(bool aLocked)
Definition: board_item.h:300
FOOTPRINT * GetParentFootprint() const
Definition: board_item.cpp:248
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:281
void SetFileName(const wxString &aFileName)
Definition: board.h:316
const FOOTPRINTS & Footprints() const
Definition: board.h:322
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:88
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:126
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:100
bool IsSelected() const
Definition: eda_item.h:109
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:103
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:98
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:183
void SetPosition(const VECTOR2I &aPos) override
Definition: footprint.cpp:2297
void SetFPID(const LIB_ID &aFPID)
Definition: footprint.h:234
int GetFieldCount() const
Return the number of fields in this symbol.
Definition: footprint.h:706
void SetLocked(bool isLocked) override
Set the #MODULE_is_LOCKED bit in the m_ModuleStatus.
Definition: footprint.h:407
void MoveAnchorPosition(const VECTOR2I &aMoveVector)
Move the reference point of the footprint.
Definition: footprint.cpp:2324
PADS & Pads()
Definition: footprint.h:191
void Move(const VECTOR2I &aMoveVector) override
Move this object.
Definition: footprint.cpp:2191
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition: footprint.cpp:968
const wxString & GetValue() const
Definition: footprint.h:610
const wxString & GetReference() const
Definition: footprint.h:588
VECTOR2I GetPosition() const override
Definition: footprint.h:209
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition: confirm.h:47
void DoNotShowCheckbox(wxString file, int line)
Checks the 'do not show again' setting for the dialog.
Definition: confirm.cpp:56
int ShowModal() override
Definition: confirm.cpp:100
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:219
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:458
Definition: pad.h:59
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:51
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
Container for project specific data.
Definition: project.h:62
VECTOR2I GetReferencePoint() const
Definition: selection.cpp:170
EDA_ITEM * Front() const
Definition: selection.h:208
int Size() const
Returns the number of selected parts.
Definition: selection.h:115
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:109
bool HasReferencePoint() const
Definition: selection.h:247
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.
This file is part of the common library.
#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
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< int > VECTOR2I
Definition: vector2d.h:588