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