KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_easyeda_parser.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) 2023 Alex Shvartzkop <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include "sch_easyeda_parser.h"
26
27#include <sch_io/sch_io_mgr.h>
28#include <schematic.h>
29#include <sch_sheet.h>
30#include <sch_line.h>
31#include <sch_no_connect.h>
32#include <sch_label.h>
33#include <sch_junction.h>
34#include <sch_edit_frame.h>
35#include <sch_shape.h>
36#include <sch_bitmap.h>
37#include <string_utils.h>
38#include <bezier_curves.h>
39#include <wx/base64.h>
40#include <wx/mstream.h>
41#include <core/map_helpers.h>
42#include <gfx_import_utils.h>
43#include <import_gfx/svg_import_plugin.h>
44#include <import_gfx/graphics_importer_lib_symbol.h>
45#include <import_gfx/graphics_importer_sch.h>
46
47
48// clang-format off
49static const std::vector<wxString> c_attributesWhitelist = { "Datasheet",
50 "Manufacturer Part",
51 "Manufacturer",
52 "BOM_Manufacturer Part",
53 "BOM_Manufacturer",
54 "Supplier Part",
55 "Supplier",
56 "BOM_Supplier Part",
57 "BOM_Supplier",
58 "LCSC Part Name" };
59// clang-format on
60
61
62SCH_EASYEDA_PARSER::SCH_EASYEDA_PARSER( SCHEMATIC* aSchematic,
63 PROGRESS_REPORTER* aProgressReporter )
64{
65 m_schematic = aSchematic;
66}
67
68
69SCH_EASYEDA_PARSER::~SCH_EASYEDA_PARSER()
70{
71}
72
73
74static std::vector<std::vector<wxString>> RegexMatchAll( wxRegEx& aRegex, const wxString& aString )
75{
76 std::vector<std::vector<wxString>> allMatches;
77
78 size_t start = 0;
79 size_t len = 0;
80 size_t prevstart = 0;
81
82 wxString str = aString;
83
84 while( aRegex.Matches( str ) )
85 {
86 std::vector<wxString> matches;
87 aRegex.GetMatch( &start, &len );
88
89 for( size_t i = 0; i < aRegex.GetMatchCount(); i++ )
90 matches.emplace_back( aRegex.GetMatch( str, i ) );
91
92 allMatches.emplace_back( matches );
93
94 prevstart = start + len;
95 str = str.Mid( prevstart );
96 }
97
98 return allMatches;
99}
100
101
109static std::vector<std::pair<wxString, std::vector<double>>>
110ParseImageTransform( const wxString& transformData )
111{
112 wxRegEx transformRegex( "(rotate|translate|scale)\\(([\\w\\s,\\.\\-]*)\\)", wxRE_ICASE );
113 std::vector<std::vector<wxString>> allMatches = RegexMatchAll( transformRegex, transformData );
114
115 std::vector<std::pair<wxString, std::vector<double>>> transformCmds;
116
117 for( int cmdId = allMatches.size() - 1; cmdId >= 0; cmdId-- )
118 {
119 std::vector<wxString>& groups = allMatches[cmdId];
120
121 if( groups.size() != 3 )
122 continue;
123
124 const wxString& cmdName = groups[1].Strip( wxString::both ).Lower();
125 const wxString& cmdArgsStr = groups[2];
126
127 wxArrayString cmdParts = wxSplit( cmdArgsStr, ',', '\0' );
128 std::vector<double> cmdArgs;
129
130 for( const wxString& cmdPart : cmdParts )
131 {
132 double arg = 0;
133 wxASSERT( cmdPart.Strip( wxString::both ).ToCDouble( &arg ) );
134
135 cmdArgs.push_back( arg );
136 }
137
138 transformCmds.emplace_back( cmdName, cmdArgs );
139 }
140
141 return transformCmds;
142}
143
144
145static LIB_ID EasyEdaToKiCadLibID( const wxString& aLibName, const wxString& aLibReference )
146{
147 wxString libReference = EscapeString( aLibReference, CTX_LIBID );
148
149 wxString key = !aLibName.empty() ? ( aLibName + ':' + libReference ) : libReference;
150
151 LIB_ID libId;
152 libId.Parse( key, true );
153
154 return libId;
155}
156
157
158static LINE_STYLE ConvertStrokeStyle( const wxString& aStyle )
159{
160 if( aStyle == wxS( "0" ) )
161 return LINE_STYLE::SOLID;
162 else if( aStyle == wxS( "1" ) )
163 return LINE_STYLE::DASH;
164 else if( aStyle == wxS( "2" ) )
165 return LINE_STYLE::DOT;
166
167 return LINE_STYLE::DEFAULT;
168}
169
170
171static ELECTRICAL_PINTYPE ConvertElecType( const wxString& aType )
172{
173 if( aType == wxS( "0" ) )
174 return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
175 else if( aType == wxS( "1" ) )
176 return ELECTRICAL_PINTYPE::PT_INPUT;
177 else if( aType == wxS( "2" ) )
178 return ELECTRICAL_PINTYPE::PT_OUTPUT;
179 else if( aType == wxS( "3" ) )
180 return ELECTRICAL_PINTYPE::PT_BIDI;
181 else if( aType == wxS( "4" ) )
182 return ELECTRICAL_PINTYPE::PT_PASSIVE;
183
184 return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
185}
186
187
188VECTOR2I HelperGeneratePowerPortGraphics( LIB_SYMBOL* aKsymbol, EASYEDA::POWER_FLAG_STYLE aStyle,
189 REPORTER* aReporter )
190{
191 if( aStyle == EASYEDA::POWER_FLAG_STYLE::CIRCLE || aStyle == EASYEDA::POWER_FLAG_STYLE::ARROW )
192 {
193 SCH_SHAPE* line1 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
194 line1->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
195 line1->AddPoint( { 0, 0 } );
196 line1->AddPoint( { 0, schIUScale.MilsToIU( 50 ) } );
197 aKsymbol->AddDrawItem( line1, false );
198
199 if( aStyle == EASYEDA::POWER_FLAG_STYLE::CIRCLE )
200 {
201 SCH_SHAPE* circle = new SCH_SHAPE( SHAPE_T::CIRCLE, LAYER_DEVICE );
202 circle->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 5 ), LINE_STYLE::SOLID ) );
203 circle->SetPosition( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 75 ) } );
204 circle->SetEnd( circle->GetPosition() + VECTOR2I( schIUScale.MilsToIU( 25 ), 0 ) );
205 aKsymbol->AddDrawItem( circle, false );
206 }
207 else
208 {
209 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
210 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
211 line2->AddPoint( { schIUScale.MilsToIU( -25 ), schIUScale.MilsToIU( 50 ) } );
212 line2->AddPoint( { schIUScale.MilsToIU( 25 ), schIUScale.MilsToIU( 50 ) } );
213 line2->AddPoint( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 100 ) } );
214 line2->AddPoint( { schIUScale.MilsToIU( -25 ), schIUScale.MilsToIU( 50 ) } );
215 aKsymbol->AddDrawItem( line2, false );
216 }
217
218 return { 0, schIUScale.MilsToIU( 150 ) };
219 }
220 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::WAVE )
221 {
222 SCH_SHAPE* line = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
223 line->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
224 line->AddPoint( { 0, 0 } );
225 line->AddPoint( { 0, schIUScale.MilsToIU( 72 ) } );
226 aKsymbol->AddDrawItem( line, false );
227
228 SCH_SHAPE* bezier = new SCH_SHAPE( SHAPE_T::BEZIER, LAYER_DEVICE );
229 bezier->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 5 ), LINE_STYLE::SOLID ) );
230 bezier->SetStart( { schIUScale.MilsToIU( 30 ), schIUScale.MilsToIU( 50 ) } );
231 bezier->SetBezierC1( { schIUScale.MilsToIU( 30 ), schIUScale.MilsToIU( 87 ) } );
232 bezier->SetBezierC2( { schIUScale.MilsToIU( -30 ), schIUScale.MilsToIU( 63 ) } );
233 bezier->SetEnd( { schIUScale.MilsToIU( -30 ), schIUScale.MilsToIU( 100 ) } );
234 aKsymbol->AddDrawItem( bezier, false );
235
236 return { 0, schIUScale.MilsToIU( 150 ) };
237 }
238 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::POWER_GROUND
239 || aStyle == EASYEDA::POWER_FLAG_STYLE::SIGNAL_GROUND
240 || aStyle == EASYEDA::POWER_FLAG_STYLE::EARTH
241 || aStyle == EASYEDA::POWER_FLAG_STYLE::GOST_ARROW )
242 {
243 SCH_SHAPE* line1 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
244 line1->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
245 line1->AddPoint( { 0, 0 } );
246 line1->AddPoint( { 0, schIUScale.MilsToIU( 100 ) } );
247 aKsymbol->AddDrawItem( line1, false );
248
249 if( aStyle == EASYEDA::POWER_FLAG_STYLE::POWER_GROUND )
250 {
251 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
252 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
253 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 100 ) } );
254 line2->AddPoint( { schIUScale.MilsToIU( 100 ), schIUScale.MilsToIU( 100 ) } );
255 aKsymbol->AddDrawItem( line2, false );
256
257 SCH_SHAPE* line3 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
258 line3->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
259 line3->AddPoint( { schIUScale.MilsToIU( -70 ), schIUScale.MilsToIU( 120 ) } );
260 line3->AddPoint( { schIUScale.MilsToIU( 70 ), schIUScale.MilsToIU( 120 ) } );
261 aKsymbol->AddDrawItem( line3, false );
262
263 SCH_SHAPE* line4 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
264 line4->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
265 line4->AddPoint( { schIUScale.MilsToIU( -40 ), schIUScale.MilsToIU( 140 ) } );
266 line4->AddPoint( { schIUScale.MilsToIU( 40 ), schIUScale.MilsToIU( 140 ) } );
267 aKsymbol->AddDrawItem( line4, false );
268
269 SCH_SHAPE* line5 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
270 line5->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
271 line5->AddPoint( { schIUScale.MilsToIU( -10 ), schIUScale.MilsToIU( 160 ) } );
272 line5->AddPoint( { schIUScale.MilsToIU( 10 ), schIUScale.MilsToIU( 160 ) } );
273 aKsymbol->AddDrawItem( line5, false );
274 }
275 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::SIGNAL_GROUND )
276 {
277 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
278 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
279 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 100 ) } );
280 line2->AddPoint( { schIUScale.MilsToIU( 100 ), schIUScale.MilsToIU( 100 ) } );
281 line2->AddPoint( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 160 ) } );
282 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 100 ) } );
283 aKsymbol->AddDrawItem( line2, false );
284 }
285 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::EARTH )
286 {
287 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
288 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
289 line2->AddPoint( { schIUScale.MilsToIU( -150 ), schIUScale.MilsToIU( 200 ) } );
290 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 100 ) } );
291 line2->AddPoint( { schIUScale.MilsToIU( 100 ), schIUScale.MilsToIU( 100 ) } );
292 line2->AddPoint( { schIUScale.MilsToIU( 50 ), schIUScale.MilsToIU( 200 ) } );
293 aKsymbol->AddDrawItem( line2, false );
294
295 SCH_SHAPE* line3 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
296 line3->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
297 line3->AddPoint( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 100 ) } );
298 line3->AddPoint( { schIUScale.MilsToIU( -50 ), schIUScale.MilsToIU( 200 ) } );
299 aKsymbol->AddDrawItem( line3, false );
300 }
301 else // EASYEDA::POWER_FLAG_STYLE::GOST_ARROW
302 {
303 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
304 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
305 line2->AddPoint( { schIUScale.MilsToIU( -25 ), schIUScale.MilsToIU( 50 ) } );
306 line2->AddPoint( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 100 ) } );
307 line2->AddPoint( { schIUScale.MilsToIU( 25 ), schIUScale.MilsToIU( 50 ) } );
308 aKsymbol->AddDrawItem( line2, false );
309
310 return { 0, schIUScale.MilsToIU( 150 ) }; // special case
311 }
312
313 return { 0, schIUScale.MilsToIU( 250 ) };
314 }
315 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::GOST_POWER_GROUND
316 || aStyle == EASYEDA::POWER_FLAG_STYLE::GOST_EARTH )
317 {
318 SCH_SHAPE* line1 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
319 line1->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
320 line1->AddPoint( { 0, 0 } );
321 line1->AddPoint( { 0, schIUScale.MilsToIU( 160 ) } );
322 aKsymbol->AddDrawItem( line1, false );
323
324 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
325 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
326 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 160 ) } );
327 line2->AddPoint( { schIUScale.MilsToIU( 100 ), schIUScale.MilsToIU( 160 ) } );
328 aKsymbol->AddDrawItem( line2, false );
329
330 SCH_SHAPE* line3 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
331 line3->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
332 line3->AddPoint( { schIUScale.MilsToIU( -60 ), schIUScale.MilsToIU( 200 ) } );
333 line3->AddPoint( { schIUScale.MilsToIU( 60 ), schIUScale.MilsToIU( 200 ) } );
334 aKsymbol->AddDrawItem( line3, false );
335
336 SCH_SHAPE* line4 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
337 line4->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
338 line4->AddPoint( { schIUScale.MilsToIU( -20 ), schIUScale.MilsToIU( 240 ) } );
339 line4->AddPoint( { schIUScale.MilsToIU( 20 ), schIUScale.MilsToIU( 240 ) } );
340 aKsymbol->AddDrawItem( line4, false );
341
342 if( aStyle == EASYEDA::POWER_FLAG_STYLE::GOST_POWER_GROUND )
343 return { 0, schIUScale.MilsToIU( -300 ) };
344
345 SCH_SHAPE* circle = new SCH_SHAPE( SHAPE_T::CIRCLE, LAYER_DEVICE );
346 circle->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
347 circle->SetPosition( { schIUScale.MilsToIU( 0 ), schIUScale.MilsToIU( 160 ) } );
348 circle->SetEnd( circle->GetPosition() + VECTOR2I( schIUScale.MilsToIU( 120 ), 0 ) );
349 aKsymbol->AddDrawItem( circle, false );
350
351 return { 0, schIUScale.MilsToIU( 350 ) };
352 }
353 else if( aStyle == EASYEDA::POWER_FLAG_STYLE::GOST_BAR )
354 {
355 SCH_SHAPE* line1 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
356 line1->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
357 line1->AddPoint( { 0, 0 } );
358 line1->AddPoint( { 0, schIUScale.MilsToIU( 200 ) } );
359 aKsymbol->AddDrawItem( line1, false );
360
361 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
362 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
363 line2->AddPoint( { schIUScale.MilsToIU( -100 ), schIUScale.MilsToIU( 200 ) } );
364 line2->AddPoint( { schIUScale.MilsToIU( 100 ), schIUScale.MilsToIU( 200 ) } );
365 aKsymbol->AddDrawItem( line2, false );
366
367 return { 0, schIUScale.MilsToIU( 250 ) };
368 }
369 else
370 {
371 if( aStyle != EASYEDA::POWER_FLAG_STYLE::BAR )
372 {
373 aReporter->Report( _( "Power Port with unknown style imported as 'Bar' type." ),
374 RPT_SEVERITY_WARNING );
375 }
376
377 SCH_SHAPE* line1 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
378 line1->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
379 line1->AddPoint( { 0, 0 } );
380 line1->AddPoint( { 0, schIUScale.MilsToIU( 100 ) } );
381 aKsymbol->AddDrawItem( line1, false );
382
383 SCH_SHAPE* line2 = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
384 line2->SetStroke( STROKE_PARAMS( schIUScale.MilsToIU( 10 ), LINE_STYLE::SOLID ) );
385 line2->AddPoint( { schIUScale.MilsToIU( -50 ), schIUScale.MilsToIU( 100 ) } );
386 line2->AddPoint( { schIUScale.MilsToIU( 50 ), schIUScale.MilsToIU( 100 ) } );
387 aKsymbol->AddDrawItem( line2, false );
388
389 return { 0, schIUScale.MilsToIU( 150 ) };
390 }
391}
392
393
394void SCH_EASYEDA_PARSER::ParseSymbolShapes( LIB_SYMBOL* aSymbol,
395 std::map<wxString, wxString> paramMap,
396 wxArrayString aShapes )
397{
398 for( wxString shapeStr : aShapes )
399 {
400 wxArrayString arr = wxSplit( shapeStr, '~', '\0' );
401
402 wxString elType = arr[0];
403 if( elType == wxS( "PL" ) || elType == wxS( "PG" ) )
404 {
405 wxArrayString ptArr = wxSplit( arr[1], ' ', '\0' );
406 wxString strokeColor = arr[2];
407 double lineWidth = Convert( arr[3] );
408 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[4] );
409 wxString fillColor = arr[5].Lower();
410 //bool locked = arr[7] != wxS( "0" );
411
412 SHAPE_LINE_CHAIN chain;
413
414 for( size_t i = 1; i < ptArr.size(); i += 2 )
415 {
416 chain.Append(
417 RelPosSym( VECTOR2I( Convert( ptArr[i - 1] ), Convert( ptArr[i] ) ) ) );
418 }
419
420 auto line = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, LAYER_DEVICE );
421
422 if( elType == wxS( "PG" ) )
423 chain.SetClosed( true );
424
425 if( chain.PointCount() < 2 )
426 continue;
427
428 for( int i = 0; i < chain.PointCount(); i++ )
429 line->AddPoint( chain.CPoint( i ) );
430
431 if( chain.IsClosed() )
432 line->AddPoint( chain.CPoint( 0 ) );
433
434 line->SetUnit( 0 );
435 line->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
436
437 if( fillColor != wxS( "none" ) )
438 {
439 line->SetFilled( true );
440
441 if( fillColor == strokeColor )
442 line->SetFillMode( FILL_T::FILLED_SHAPE );
443 else
444 line->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
445 }
446
447 aSymbol->AddDrawItem( line.release() );
448 }
449 else if( elType == wxS( "PT" ) ) // Freedraw
450 {
451 wxString pointsData = arr[1];
452 wxString strokeColor = arr[2];
453 double lineWidth = Convert( arr[3] );
454 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[4] );
455 wxString fillColor = arr[5].Lower();
456 //bool locked = arr[7] != wxS( "0" );
457
458 std::vector<SHAPE_LINE_CHAIN> lineChains =
459 ParseLineChains( pointsData, schIUScale.MilsToIU( 10 ), false );
460
461 for( SHAPE_LINE_CHAIN outline : lineChains )
462 {
463 auto shape = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, LAYER_DEVICE );
464
465 if( outline.IsClosed() )
466 outline.Append( outline.CPoint( 0 ), true );
467
468 for( const VECTOR2I& pt : outline.CPoints() )
469 shape->AddPoint( pt );
470
471 shape->SetUnit( 0 );
472 shape->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
473
474 if( fillColor != wxS( "none" ) )
475 {
476 shape->SetFilled( true );
477
478 if( fillColor == strokeColor )
479 shape->SetFillMode( FILL_T::FILLED_SHAPE );
480 else
481 shape->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
482 }
483
484 aSymbol->AddDrawItem( shape.release() );
485 }
486 }
487 else if( elType == wxS( "Pimage" ) )
488 {
489 //double angle = Convert( arr[4] ); // TODO
490 VECTOR2D start( Convert( arr[6] ), Convert( arr[7] ) );
491 VECTOR2D size( Convert( arr[8] ), Convert( arr[9] ) );
492 wxString imageUrl = arr[10];
493
494 if( imageUrl.BeforeFirst( ':' ) == wxS( "data" ) )
495 {
496 wxArrayString paramsArr =
497 wxSplit( imageUrl.AfterFirst( ':' ).BeforeFirst( ',' ), ';', '\0' );
498
499 wxString data = imageUrl.AfterFirst( ',' );
500
501 if( paramsArr.size() > 0 )
502 {
503 wxString mimeType = paramsArr[0];
504 wxMemoryBuffer buf = wxBase64Decode( data );
505
506 if( mimeType == wxS( "image/svg+xml" ) )
507 {
508 VECTOR2D offset = RelPosSym( start );
509
510 SVG_IMPORT_PLUGIN svgImportPlugin;
511 GRAPHICS_IMPORTER_LIB_SYMBOL libsymImporter( aSymbol, 0 );
512
513 svgImportPlugin.SetImporter( &libsymImporter );
514 svgImportPlugin.LoadFromMemory( buf );
515
516 VECTOR2D imSize( svgImportPlugin.GetImageWidth(),
517 svgImportPlugin.GetImageHeight() );
518
519 VECTOR2D pixelScale( schIUScale.IUTomm( ScaleSize( size.x ) ) / imSize.x,
520 schIUScale.IUTomm( ScaleSize( size.y ) ) / imSize.y );
521
522 libsymImporter.SetScale( pixelScale );
523
524 VECTOR2D offsetMM( schIUScale.IUTomm( offset.x ),
525 schIUScale.IUTomm( offset.y ) );
526
527 libsymImporter.SetImportOffsetMM( offsetMM );
528
529 svgImportPlugin.Import();
530
531 for( std::unique_ptr<EDA_ITEM>& item : libsymImporter.GetItems() )
532 aSymbol->AddDrawItem( static_cast<SCH_ITEM*>( item.release() ) );
533 }
534 else
535 {
536 wxMemoryInputStream memis( buf.GetData(), buf.GetDataLen() );
537
538 wxImage::SetDefaultLoadFlags( wxImage::GetDefaultLoadFlags()
539 & ~wxImage::Load_Verbose );
540 wxImage img;
541 if( img.LoadFile( memis, mimeType ) )
542 {
543 int dimMul = img.GetWidth() * img.GetHeight();
544 double maxPixels = 30000;
545
546 if( dimMul > maxPixels )
547 {
548 double scale = sqrt( maxPixels / dimMul );
549 img.Rescale( img.GetWidth() * scale, img.GetHeight() * scale );
550 }
551
552 VECTOR2D pixelScale( ScaleSize( size.x ) / img.GetWidth(),
553 ScaleSize( size.y ) / img.GetHeight() );
554
555 ConvertImageToLibShapes( aSymbol, 0, img, pixelScale,
556 RelPosSym( start ) );
557 }
558 }
559 }
560 }
561 }
562 else if( elType == wxS( "A" ) )
563 {
564 wxString data = arr[1];
565 wxString strokeColor = arr[3];
566 double lineWidth = Convert( arr[4] );
567 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[5] );
568 wxString fillColor = arr[6].Lower();
569 //bool locked = arr[8] != wxS( "0" );
570
571 std::vector<SHAPE_LINE_CHAIN> chains =
572 ParseLineChains( data, schIUScale.MilsToIU( 10 ), false );
573
574 auto transform = []( VECTOR2I aVec )
575 {
576 return VECTOR2I( aVec.x, aVec.y );
577 };
578
579 for( const SHAPE_LINE_CHAIN& chain : chains )
580 {
581 for( int i = 0; i <= chain.PointCount() && i != -1; i = chain.NextShape( i ) )
582 {
583 if( chain.IsArcStart( i ) )
584 {
585 SHAPE_ARC arc = chain.Arc( chain.ArcIndex( i ) );
586
587 std::unique_ptr<SCH_SHAPE> shape =
588 std::make_unique<SCH_SHAPE>( SHAPE_T::ARC, LAYER_DEVICE );
589
590 shape->SetArcGeometry( transform( arc.GetP0() ),
591 transform( arc.GetArcMid() ),
592 transform( arc.GetP1() ) );
593
594 shape->SetUnit( 0 );
595 shape->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
596
597 if( fillColor != wxS( "none" ) )
598 {
599 shape->SetFilled( true );
600
601 if( fillColor == strokeColor )
602 shape->SetFillMode( FILL_T::FILLED_SHAPE );
603 else
604 shape->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
605 }
606
607 aSymbol->AddDrawItem( shape.release() );
608 }
609 else
610 {
611 SEG seg = chain.CSegment( i );
612
613 std::unique_ptr<SCH_SHAPE> shape =
614 std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, LAYER_DEVICE );
615
616 shape->AddPoint( transform( seg.A ) );
617 shape->AddPoint( transform( seg.B ) );
618
619 shape->SetUnit( 0 );
620 shape->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
621
622 aSymbol->AddDrawItem( shape.release() );
623 }
624 }
625 }
626 }
627 else if( elType == wxS( "R" ) )
628 {
629 VECTOR2D start( Convert( arr[1] ), Convert( arr[2] ) );
630
631 VECTOR2D cr;
632 cr.x = !arr[3].empty() ? Convert( arr[3] ) : 0,
633 cr.y = !arr[4].empty() ? Convert( arr[4] ) : 0; // TODO: corner radius
634
635 VECTOR2D size( Convert( arr[5] ), Convert( arr[6] ) );
636 wxString strokeColor = arr[7];
637 double lineWidth = Convert( arr[8] );
638 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[9] );
639 wxString fillColor = arr[10].Lower();
640 //bool locked = arr[12] != wxS( "0" );
641
642 //if( cr.x == 0 )
643 {
644 auto rect = std::make_unique<SCH_SHAPE>( SHAPE_T::RECTANGLE, LAYER_DEVICE );
645
646 rect->SetStart( RelPosSym( start ) );
647 rect->SetEnd( RelPosSym( start + size ) );
648
649 rect->SetUnit( 0 );
650 rect->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
651
652 if( fillColor != wxS( "none" ) )
653 {
654 rect->SetFilled( true );
655
656 if( fillColor == strokeColor )
657 rect->SetFillMode( FILL_T::FILLED_SHAPE );
658 else
659 rect->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
660 }
661
662 aSymbol->AddDrawItem( rect.release() );
663 }
664 // TODO: rounded rectangles
665 }
666 else if( elType == wxS( "E" ) )
667 {
668 auto circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE, LAYER_DEVICE );
669
670 VECTOR2D center( Convert( arr[1] ), Convert( arr[2] ) );
671 VECTOR2D radius( Convert( arr[3] ), Convert( arr[4] ) ); // TODO: corner radius
672 wxString strokeColor = arr[5];
673 double lineWidth = Convert( arr[6] );
674 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[7] );
675 wxString fillColor = arr[8].Lower();
676 //bool locked = arr[10] != wxS( "0" );
677
678 circle->SetCenter( RelPosSym( center ) );
679 circle->SetEnd( RelPosSym( center + VECTOR2I( radius.x, 0 ) ) );
680
681 circle->SetUnit( 0 );
682 circle->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
683
684 if( fillColor != wxS( "none" ) )
685 {
686 circle->SetFilled( true );
687
688 if( fillColor == strokeColor )
689 circle->SetFillMode( FILL_T::FILLED_SHAPE );
690 else
691 circle->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
692 }
693
694 aSymbol->AddDrawItem( circle.release() );
695 }
696 else if( elType == wxS( "P" ) )
697 {
698 wxString sepShapeStr = shapeStr;
699 sepShapeStr.Replace( wxS( "^^" ), wxS( "\n" ) );
700
701 wxArrayString segments = wxSplit( sepShapeStr, '\n', '\0' );
702 wxArrayString mainParts = wxSplit( segments[0], '~', '\0' );
703 wxArrayString pinDotParts = wxSplit( segments[1], '~', '\0' );
704 wxArrayString pinPathColorParts = wxSplit( segments[2], '~', '\0' );
705 wxArrayString pinNameParts = wxSplit( segments[3], '~', '\0' );
706 wxArrayString pinNumParts = wxSplit( segments[4], '~', '\0' );
707
708 //bool show = mainParts[1].Lower() != wxS( "none" );
709 ELECTRICAL_PINTYPE elecType = ConvertElecType( mainParts[2] );
710 wxString pinNumber = mainParts[3];
711 VECTOR2D pinPos( Convert( mainParts[4] ), Convert( mainParts[5] ) );
712 //int pinRot = Convert( mainParts[6] );
713
714 VECTOR2D pinDotPos( Convert( pinDotParts[0] ), Convert( pinDotParts[1] ) );
715
716 bool nameVisible = pinNameParts[0] != wxS( "0" );
717 wxString pinName = pinNameParts[4];
718
719 bool numVisible = pinNumParts[0] != wxS( "0" );
720 wxString ptSize = pinNumParts[4];
721
722 VECTOR2D startPoint;
723 bool vertical = false;
724 double pinLen = 0;
725
726 // M360,290h10 or M 420 300 h -5
727 wxString lineData = pinPathColorParts[0];
728 wxRegEx regex( wxS( "^M\\s*([-\\d.]+)[,\\s]([-\\d.]+)\\s*([h|v])\\s*([-\\d.]+)\\s*$" ) );
729
730 if( regex.Matches( lineData ) )
731 {
732 startPoint.x = Convert( regex.GetMatch( lineData, 1 ) );
733 startPoint.y = Convert( regex.GetMatch( lineData, 2 ) );
734
735 vertical = regex.GetMatch( lineData, 3 ).Contains( wxS( "v" ) );
736 pinLen = Convert( regex.GetMatch( lineData, 4 ) );
737 }
738
739 int pinRotation = 0;
740
741 if( !vertical )
742 {
743 if( startPoint.x == pinPos.x && pinLen < 0 )
744 pinRotation = 180;
745 else if( startPoint.x == pinPos.x && pinLen > 0 )
746 pinRotation = 0;
747 else if( startPoint.x != pinPos.x && pinLen < 0 )
748 pinRotation = 0;
749 else if( startPoint.x != pinPos.x && pinLen > 0 )
750 pinRotation = 180;
751 }
752 else
753 {
754 if( startPoint.y == pinPos.y && pinLen < 0 )
755 pinRotation = 90;
756 else if( startPoint.y == pinPos.y && pinLen > 0 )
757 pinRotation = 270;
758 else if( startPoint.y != pinPos.y && pinLen < 0 )
759 pinRotation = 270;
760 else if( startPoint.y != pinPos.y && pinLen > 0 )
761 pinRotation = 90;
762 }
763
764 PIN_ORIENTATION orient = PIN_ORIENTATION::PIN_RIGHT;
765
766 if( pinRotation == 0 )
767 orient = PIN_ORIENTATION::PIN_RIGHT;
768 else if( pinRotation == 90 )
769 orient = PIN_ORIENTATION::PIN_UP;
770 else if( pinRotation == 180 )
771 orient = PIN_ORIENTATION::PIN_LEFT;
772 else if( pinRotation == 270 )
773 orient = PIN_ORIENTATION::PIN_DOWN;
774
775 int pinUnit = 0;
776 int kPinLen = ScaleSize( std::abs( pinLen ) );
777
778 if( segments.size() > 5 )
779 {
780 wxArrayString dotParts = wxSplit( segments[5], '~', '\0' );
781 wxArrayString clockParts = wxSplit( segments[6], '~', '\0' );
782
783 if( dotParts.size() == 3 && clockParts.size() == 2 )
784 {
785 if( dotParts[0] == wxS( "1" ) )
786 {
787 VECTOR2D dotPos( Convert( dotParts[1] ), Convert( dotParts[2] ) );
788
789 auto circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE, LAYER_DEVICE );
790
791 circle->SetCenter( RelPosSym( dotPos ) );
792 circle->SetEnd( RelPosSym(
793 pinPos + ( dotPos - pinPos ).Resize( std::abs( pinLen ) ) ) );
794
795 circle->SetUnit( 0 );
796
797 aSymbol->AddDrawItem( circle.release() );
798 }
799
800 if( clockParts[0] == wxS( "1" ) )
801 {
802 std::vector<SHAPE_LINE_CHAIN> lineChains =
803 ParseLineChains( clockParts[1], schIUScale.MilsToIU( 10 ), false );
804
805 for( SHAPE_LINE_CHAIN outline : lineChains )
806 {
807 auto shape = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, LAYER_DEVICE );
808
809 if( outline.IsClosed() )
810 outline.Append( outline.CPoint( 0 ), true );
811
812 for( const VECTOR2I& pt : outline.CPoints() )
813 shape->AddPoint( pt );
814
815 shape->SetUnit( 0 );
816
817 aSymbol->AddDrawItem( shape.release() );
818 }
819 }
820 }
821 }
822
823 std::unique_ptr<SCH_PIN> pin = std::make_unique<SCH_PIN>( aSymbol );
824
825 pin->SetName( pinName );
826 pin->SetNumber( pinNumber );
827 pin->SetOrientation( orient );
828 pin->SetType( elecType );
829 pin->SetLength( kPinLen );
830 pin->SetPosition( RelPosSym( pinPos ) );
831 pin->SetUnit( pinUnit );
832
833 if( pin->GetNumberTextSize() * int( pinNumber.size() ) > kPinLen )
834 pin->SetNumberTextSize( kPinLen / pinNumber.size() );
835
836 if( !nameVisible )
837 pin->SetNameTextSize( schIUScale.MilsToIU( 1 ) );
838
839 if( !numVisible )
840 pin->SetNumberTextSize( schIUScale.MilsToIU( 1 ) );
841
842 aSymbol->AddDrawItem( pin.release() );
843 }
844 else if( elType == wxS( "T" ) )
845 {
846 wxString textType = arr[1];
847 VECTOR2D pos( Convert( arr[2] ), Convert( arr[3] ) );
848 int angle = Convert( arr[4] );
849 wxString color = arr[5];
850 wxString fontname = arr[6];
851 wxString fontSize = arr[7];
852 wxString baselineAlign = arr[10];
853 wxString textStr = arr[12];
854 bool visible = arr[13] != wxS( "0" );
855
856 textStr.Replace( wxS( "\\n" ), wxS( "\n" ) );
857 textStr = UnescapeHTML( textStr );
858
859 wxString halignStr = arr[14]; // Empty, start, middle, end, inherit
860
861 bool added = false;
862 EDA_TEXT* textItem = nullptr;
863
864 if( textType == wxS( "P" ) )
865 {
866 textItem = &aSymbol->GetReferenceField();
867 textItem->SetTextPos( RelPosSym( pos ) );
868 textItem->SetText( textStr );
869 }
870 else if( textType == wxS( "N" ) )
871 {
872 textItem = &aSymbol->GetValueField();
873 textItem->SetTextPos( RelPosSym( pos ) );
874 textItem->SetText( textStr );
875 }
876 else
877 {
878 textItem = new SCH_TEXT( RelPosSym( pos ), textStr, LAYER_DEVICE );
879 added = true;
880 }
881
882 textItem->SetTextAngleDegrees( ( 360 - angle ) % 360 );
883 textItem->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
884
885 if( halignStr == wxS( "middle" ) )
886 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
887 else if( halignStr == wxS( "end" ) )
888 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
889 else
890 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
891
892 textItem->SetFont( KIFONT::FONT::GetFont( fontname ) );
893 textItem->SetVisible( visible );
894
895 double ptSize = 7;
896
897 if( !fontSize.IsEmpty() )
898 {
899 if( fontSize.EndsWith( wxS( "pt" ) ) )
900 ptSize = Convert( fontSize.BeforeFirst( 'p' ) );
901 else if( fontSize.IsNumber() )
902 ptSize = Convert( fontSize );
903 }
904
905 double ktextSize = ScaleSize( ptSize );
906
907 if( textStr.Contains( wxS( "\n" ) ) )
908 ktextSize *= 0.8;
909 else
910 ktextSize *= 0.95;
911
912 textItem->SetTextSize( VECTOR2I( ktextSize, ktextSize ) );
913
914 TransformTextToBaseline( textItem, baselineAlign );
915
916 if( added )
917 aSymbol->AddDrawItem( dynamic_cast<SCH_ITEM*>( textItem ) );
918 }
919 }
920}
921
922
923LIB_SYMBOL* SCH_EASYEDA_PARSER::ParseSymbol( const VECTOR2D& aOrigin,
924 std::map<wxString, wxString> aParams,
925 wxArrayString aShapes )
926{
927 std::unique_ptr<LIB_SYMBOL> ksymbol = std::make_unique<LIB_SYMBOL>( wxEmptyString );
928
929 m_relOrigin = aOrigin;
930
931 std::optional<wxString> valOpt;
932 wxString symbolName = wxS( "Unknown" );
933
934 if( ( valOpt = get_opt( aParams, wxS( "name" ) ) ) )
935 symbolName = *valOpt;
936 else if( ( valOpt = get_opt( aParams, wxS( "spiceSymbolName" ) ) ) )
937 symbolName = *valOpt;
938
939 wxString symbolPrefix;
940
941 if( ( valOpt = get_opt( aParams, wxS( "pre" ) ) ) )
942 symbolPrefix = *valOpt;
943 else if( ( valOpt = get_opt( aParams, wxS( "spicePre" ) ) ) )
944 symbolPrefix = *valOpt;
945
946 LIB_ID libId = EasyEdaToKiCadLibID( wxEmptyString, symbolName );
947
948 ksymbol->SetLibId( libId );
949 ksymbol->SetName( symbolName );
950
951 ksymbol->GetReferenceField().SetText( symbolPrefix );
952 ksymbol->GetValueField().SetText( symbolName );
953
954 for( wxString attrName : c_attributesWhitelist )
955 {
956 wxString srcName = attrName;
957
958 if( srcName == wxS( "Datasheet" ) )
959 srcName = wxS( "link" );
960
961 if( ( valOpt = get_opt( aParams, srcName ) ) )
962 {
963 if( valOpt->empty() )
964 continue;
965
966 SCH_FIELD* fd = ksymbol->FindFieldCaseInsensitive( attrName );
967
968 if( !fd )
969 {
970 fd = new SCH_FIELD( ksymbol.get(), FIELD_T::USER, attrName );
971 ksymbol->AddField( fd );
972 }
973
974 fd->SetText( *valOpt );
975 fd->SetVisible( false );
976 }
977 }
978
979 ParseSymbolShapes( ksymbol.get(), aParams, aShapes );
980
981 return ksymbol.release();
982}
983
984std::pair<LIB_SYMBOL*, bool> SCH_EASYEDA_PARSER::MakePowerSymbol( const wxString& aFlagTypename,
985 const wxString& aNetname )
986{
987 std::unique_ptr<LIB_SYMBOL> ksymbol = std::make_unique<LIB_SYMBOL>( wxEmptyString );
988
989 m_relOrigin = VECTOR2D();
990
991 LIB_ID libId = EasyEdaToKiCadLibID( wxEmptyString, aNetname );
992
993 ksymbol->SetGlobalPower();
994 ksymbol->SetLibId( libId );
995 ksymbol->SetName( aNetname );
996 ksymbol->GetReferenceField().SetText( wxS( "#PWR" ) );
997 ksymbol->GetReferenceField().SetVisible( false );
998 ksymbol->GetValueField().SetText( aNetname );
999 ksymbol->GetValueField().SetVisible( true );
1000 ksymbol->SetDescription( wxString::Format( _( "Power symbol creates a global "
1001 "label with name '%s'" ),
1002 aNetname ) );
1003 ksymbol->SetKeyWords( wxS( "power-flag" ) );
1004 ksymbol->SetShowPinNames( false );
1005 ksymbol->SetShowPinNumbers( false );
1006
1007 std::unique_ptr<SCH_PIN> pin = std::make_unique<SCH_PIN>( ksymbol.get() );
1008
1009 pin->SetName( aNetname );
1010 pin->SetNumber( wxS( "1" ) );
1011 pin->SetOrientation( PIN_ORIENTATION::PIN_DOWN );
1012 pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
1013 pin->SetLength( 0 );
1014
1015 ksymbol->AddDrawItem( pin.release() );
1016
1017 EASYEDA::POWER_FLAG_STYLE flagStyle = EASYEDA::POWER_FLAG_STYLE::POWER_GROUND;
1018
1019 bool flip = false;
1020
1021 if( aFlagTypename == wxS( "part_netLabel_gnD" ) )
1022 {
1023 flagStyle = EASYEDA::POWER_FLAG_STYLE::POWER_GROUND;
1024 }
1025 else if( aFlagTypename == wxS( "part_netLabel_GNd" ) )
1026 {
1027 flagStyle = EASYEDA::POWER_FLAG_STYLE::SIGNAL_GROUND;
1028 }
1029 else if( aFlagTypename == wxS( "part_netLabel_gNd" ) )
1030 {
1031 flagStyle = EASYEDA::POWER_FLAG_STYLE::BAR;
1032 }
1033 else if( aFlagTypename == wxS( "part_netLabel_GnD" ) )
1034 {
1035 flagStyle = EASYEDA::POWER_FLAG_STYLE::EARTH;
1036 }
1037 else if( aFlagTypename == wxS( "part_netLabel_VCC" ) )
1038 {
1039 flagStyle = EASYEDA::POWER_FLAG_STYLE::BAR;
1040 flip = true;
1041 }
1042 else if( aFlagTypename == wxS( "part_netLabel_+5V" ) )
1043 {
1044 flagStyle = EASYEDA::POWER_FLAG_STYLE::BAR;
1045 flip = true;
1046 }
1047 else if( aFlagTypename == wxS( "part_netLabel_VEE" ) )
1048 {
1049 flagStyle = EASYEDA::POWER_FLAG_STYLE::BAR;
1050 }
1051 else if( aFlagTypename == wxS( "part_netLabel_-5V" ) )
1052 {
1053 flagStyle = EASYEDA::POWER_FLAG_STYLE::BAR;
1054 }
1055 else if( aFlagTypename == wxS( "part_netLabel_Bar" ) )
1056 {
1057 flagStyle = EASYEDA::POWER_FLAG_STYLE::CIRCLE;
1058 flip = true;
1059 }
1060
1061 VECTOR2I valueFieldPos = HelperGeneratePowerPortGraphics( ksymbol.get(), flagStyle, nullptr );
1062 ksymbol->GetValueField().SetPosition( valueFieldPos );
1063
1064 return std::make_pair( ksymbol.release(), flip );
1065}
1066
1067void SCH_EASYEDA_PARSER::ParseSchematic( SCHEMATIC* aSchematic, SCH_SHEET* aRootSheet,
1068 const wxString& aFileName, wxArrayString aShapes )
1069{
1070 std::map<wxString, std::unique_ptr<LIB_SYMBOL>> loadedSymbols;
1071 std::map<wxString, int> namesCounter;
1072 std::vector<std::unique_ptr<SCH_ITEM>> createdItems;
1073
1074 for( wxString shap : aShapes )
1075 {
1076 shap.Replace( wxS( "#@$" ), wxS( "\n" ) );
1077 wxArrayString parts = wxSplit( shap, '\n', '\0' );
1078
1079 if( parts.size() < 1 )
1080 continue;
1081
1082 wxArrayString arr = wxSplit( parts[0], '~', '\0' );
1083
1084 if( arr.size() < 1 )
1085 continue;
1086
1087 wxString rootType = arr[0];
1088
1089 if( rootType == wxS( "LIB" ) )
1090 {
1091 if( arr.size() < 4 )
1092 continue;
1093
1094 VECTOR2D origin( Convert( arr[1] ), Convert( arr[2] ) );
1095
1096 wxString symbolName = wxString::Format( wxS( "Unknown_%s_%s" ), arr[1], arr[2] );
1097
1098 wxArrayString paramParts = wxSplit( arr[3], '`', '\0' );
1099
1100 std::map<wxString, wxString> paramMap;
1101
1102 for( size_t i = 1; i < paramParts.size(); i += 2 )
1103 {
1104 wxString key = paramParts[i - 1];
1105 wxString value = paramParts[i];
1106
1107 if( key == wxS( "spiceSymbolName" ) && !value.IsEmpty() )
1108 symbolName = value;
1109
1110 paramMap[key] = value;
1111 }
1112
1113 int& serial = namesCounter[symbolName];
1114
1115 if( serial > 0 )
1116 symbolName << wxS( "_" ) << serial;
1117
1118 serial++;
1119
1120 paramMap[wxS( "spiceSymbolName" )] = symbolName;
1121
1122 parts.RemoveAt( 0 );
1123
1124 VECTOR2D pcbOrigin = m_relOrigin;
1125
1126 LIB_SYMBOL* sym = ParseSymbol( origin, paramMap, parts );
1127 loadedSymbols.emplace( symbolName, sym );
1128
1129 wxString referenceStr = sym->GetReferenceField().GetText();
1130
1131 m_relOrigin = pcbOrigin;
1132 LIB_ID libId = EasyEdaToKiCadLibID( wxEmptyString, symbolName );
1133
1134 std::unique_ptr<SCH_SYMBOL> schSym =
1135 std::make_unique<SCH_SYMBOL>( *sym, libId, &aSchematic->CurrentSheet(), 0 );
1136
1137 schSym->SetPosition( RelPos( origin ) );
1138 schSym->SetRef( &aSchematic->CurrentSheet(), referenceStr );
1139
1140 createdItems.push_back( std::move( schSym ) );
1141 }
1142 else if( rootType == wxS( "F" ) )
1143 {
1144 wxString sepShapeStr = parts[0];
1145 sepShapeStr.Replace( wxS( "^^" ), wxS( "\n" ) );
1146
1147 wxArrayString segments = wxSplit( sepShapeStr, '\n', '\0' );
1148 wxArrayString mainParts = wxSplit( segments[0], '~', '\0' );
1149 wxArrayString uselessParts = wxSplit( segments[1], '~', '\0' );
1150 wxArrayString valueParts = wxSplit( segments[2], '~', '\0' );
1151
1152 wxString flagTypename = arr[1];
1153 VECTOR2D pos( Convert( arr[2] ), Convert( arr[3] ) );
1154 double angle = Convert( arr[4] );
1155
1156 wxString netnameValue = valueParts[0];
1157 VECTOR2D valuePos( Convert( valueParts[2] ), Convert( valueParts[3] ) );
1158 double textAngle = Convert( valueParts[4] );
1159 wxString halignStr = valueParts[5];
1160 wxString valueFontname = valueParts[7];
1161 wxString valueFontsize = valueParts[8];
1162
1163 if( flagTypename == wxS( "part_netLabel_netPort" ) )
1164 {
1165 std::unique_ptr<SCH_GLOBALLABEL> label =
1166 std::make_unique<SCH_GLOBALLABEL>( RelPos( pos ), netnameValue );
1167
1168 SPIN_STYLE spin = SPIN_STYLE::LEFT;
1169
1170 for( double i = angle; i > 0; i -= 90 )
1171 spin = spin.RotateCCW();
1172
1173 // If the shape was mirrored, we can't rely on angle value to determine direction.
1174 if( segments.size() > 3 )
1175 {
1176 wxArrayString shapeParts = wxSplit( segments[3], '~', '\0' );
1177 if( shapeParts[0] == wxS( "PL" ) )
1178 {
1179 wxArrayString ptArr = wxSplit( shapeParts[1], ' ', '\0' );
1180
1181 SHAPE_LINE_CHAIN chain;
1182
1183 for( size_t i = 1; i < ptArr.size(); i += 2 )
1184 {
1185 chain.Append( RelPos(
1186 VECTOR2I( Convert( ptArr[i - 1] ), Convert( ptArr[i] ) ) ) );
1187 }
1188
1189 chain.Move( -RelPos( pos ) );
1190
1191 VECTOR2I shapeCenter = chain.Centre();
1192
1193 if( std::abs( shapeCenter.x ) >= std::abs( shapeCenter.y ) )
1194 {
1195 if( shapeCenter.x >= 0 )
1196 spin = SPIN_STYLE::RIGHT;
1197 else
1198 spin = SPIN_STYLE::LEFT;
1199 }
1200 else
1201 {
1202 if( shapeCenter.y >= 0 )
1203 spin = SPIN_STYLE::BOTTOM;
1204 else
1205 spin = SPIN_STYLE::UP;
1206 }
1207 }
1208 }
1209
1210 label->SetSpinStyle( spin );
1211 label->SetShape( LABEL_FLAG_SHAPE::L_INPUT );
1212
1213 createdItems.push_back( std::move( label ) );
1214 }
1215 else
1216 {
1217 auto pair = MakePowerSymbol( flagTypename, netnameValue );
1218 LIB_SYMBOL* pwrLibSym = pair.first;
1219 bool flip = pair.second;
1220
1221 LIB_ID libId = EasyEdaToKiCadLibID( wxEmptyString, netnameValue );
1222
1223 std::unique_ptr<SCH_SYMBOL> schSym = std::make_unique<SCH_SYMBOL>(
1224 *pwrLibSym, libId, &aSchematic->CurrentSheet(), 0 );
1225
1226 if( flip )
1227 schSym->SetOrientation( SYM_MIRROR_X );
1228
1229 if( angle == 0 )
1230 {
1231 }
1232 else if( angle == 90 )
1233 {
1234 schSym->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
1235 }
1236 if( angle == 180 )
1237 {
1238 schSym->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
1239 schSym->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
1240 }
1241 if( angle == 270 )
1242 {
1243 schSym->SetOrientation( SYM_ROTATE_CLOCKWISE );
1244 }
1245
1246 schSym->SetPosition( RelPos( pos ) );
1247
1248 SCH_FIELD* valField = schSym->GetField( FIELD_T::VALUE );
1249
1250 valField->SetPosition( RelPos( valuePos ) );
1251 valField->SetTextAngleDegrees( textAngle - angle );
1252
1253 if( !flip )
1254 valField->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
1255 else
1256 valField->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
1257
1258 if( halignStr == wxS( "middle" ) )
1259 valField->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
1260 else if( halignStr == wxS( "end" ) )
1261 valField->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
1262 else
1263 valField->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
1264
1265 if( flip && ( angle == 90 || angle == 270 ) )
1266 {
1267 if( valField->GetVertJustify() == GR_TEXT_V_ALIGN_BOTTOM )
1268 valField->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
1269 else if( valField->GetVertJustify() == GR_TEXT_V_ALIGN_TOP )
1270 valField->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
1271
1272 if( valField->GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT )
1273 valField->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
1274 else if( valField->GetHorizJustify() == GR_TEXT_H_ALIGN_LEFT )
1275 valField->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
1276
1277 if( flagTypename == wxS( "part_netLabel_Bar" ) ) // "Circle"
1278 valField->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
1279 }
1280
1281 if( angle == 0 && flagTypename == wxS( "part_netLabel_Bar" ) ) // "Circle"
1282 valField->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
1283
1284 valField->SetFont( KIFONT::FONT::GetFont( valueFontname ) );
1285
1286 double ptSize = 7;
1287
1288 if( valueFontsize.EndsWith( wxS( "pt" ) ) )
1289 ptSize = Convert( valueFontsize.BeforeFirst( 'p' ) );
1290
1291 double ktextSize = ScaleSize( ptSize );
1292
1293 if( netnameValue.Contains( wxS( "\n" ) ) )
1294 ktextSize *= 0.8;
1295 else
1296 ktextSize *= 0.95;
1297
1298 valField->SetTextSize( VECTOR2I( ktextSize, ktextSize ) );
1299
1300 //TransformTextToBaseline( valField, wxS( "" ), true );
1301
1302 createdItems.push_back( std::move( schSym ) );
1303 }
1304 }
1305 else if( rootType == wxS( "W" ) )
1306 {
1307 wxArrayString ptArr = wxSplit( arr[1], ' ', '\0' );
1308 wxString strokeColor = arr[2];
1309 //double lineWidth = Convert( arr[3] );
1310 //LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[4] );
1311 wxString fillColor = arr[5].Lower();
1312 //bool locked = arr[7] != wxS( "0" );
1313
1314 SHAPE_LINE_CHAIN chain;
1315
1316 for( size_t i = 1; i < ptArr.size(); i += 2 )
1317 chain.Append( VECTOR2I( RelPosX( ptArr[i - 1] ), RelPosY( ptArr[i] ) ) );
1318
1319 for( int segId = 0; segId < chain.SegmentCount(); segId++ )
1320 {
1321 const SEG& seg = chain.CSegment( segId );
1322
1323 std::unique_ptr<SCH_LINE> line = std::make_unique<SCH_LINE>( seg.A, LAYER_WIRE );
1324 line->SetEndPoint( seg.B );
1325
1326 createdItems.push_back( std::move( line ) );
1327 }
1328 }
1329 else if( rootType == wxS( "N" ) )
1330 {
1331 VECTOR2D pos( Convert( arr[1] ), Convert( arr[2] ) );
1332 double angle = Convert( arr[3] );
1333 wxString netname = arr[5];
1334 wxString halignStr = arr[7];
1335 VECTOR2D text_pos( Convert( arr[8] ),
1336 Convert( arr[9] ) ); // TODO: detect top/bottom align
1337
1338 wxString fontname = arr[10];
1339 wxString fontSize = arr[11];
1340
1341 std::unique_ptr<SCH_LABEL> label =
1342 std::make_unique<SCH_LABEL>( RelPos( pos ), netname );
1343
1344 if( halignStr == wxS( "middle" ) )
1345 label->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
1346 else if( halignStr == wxS( "end" ) )
1347 label->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
1348 else
1349 label->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
1350
1351 for( int left = angle; left > 0; left -= 90 )
1352 label->Rotate90( false );
1353
1354 createdItems.push_back( std::move( label ) );
1355 }
1356 else if( rootType == wxS( "O" ) )
1357 {
1358 VECTOR2D pos( Convert( arr[1] ), Convert( arr[2] ) );
1359
1360 std::unique_ptr<SCH_NO_CONNECT> noConn =
1361 std::make_unique<SCH_NO_CONNECT>( RelPos( pos ) );
1362
1363 createdItems.push_back( std::move( noConn ) );
1364 }
1365 else if( rootType == wxS( "J" ) )
1366 {
1367 VECTOR2D pos( Convert( arr[1] ), Convert( arr[2] ) );
1368 //double dia = Convert( arr[3] );
1369
1370 std::unique_ptr<SCH_JUNCTION> junction =
1371 std::make_unique<SCH_JUNCTION>( RelPos( pos ) /*, ScaleSizeUnit( dia )*/ );
1372
1373 createdItems.push_back( std::move( junction ) );
1374 }
1375 else if( rootType == wxS( "T" ) )
1376 {
1377 VECTOR2D pos( Convert( arr[2] ), Convert( arr[3] ) );
1378 int angle = Convert( arr[4] );
1379 wxString color = arr[5];
1380 wxString fontname = arr[6];
1381 wxString fontSize = arr[7];
1382 wxString baselineAlign = arr[10];
1383 wxString textStr = arr[12];
1384
1385 textStr.Replace( wxS( "\\n" ), wxS( "\n" ) );
1386 textStr = UnescapeHTML( textStr );
1387
1388 wxString halignStr = arr[14]; // Empty, start, middle, end, inherit
1389
1390 std::unique_ptr<SCH_TEXT> textItem =
1391 std::make_unique<SCH_TEXT>( RelPos( pos ), textStr );
1392
1393 textItem->SetTextAngleDegrees( ( 360 - angle ) % 360 );
1394 textItem->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
1395
1396 if( halignStr == wxS( "middle" ) )
1397 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
1398 else if( halignStr == wxS( "end" ) )
1399 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
1400 else
1401 textItem->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
1402
1403 textItem->SetFont( KIFONT::FONT::GetFont( fontname ) );
1404
1405 double ptSize = 7;
1406
1407 if( fontSize.EndsWith( wxS( "pt" ) ) )
1408 ptSize = Convert( fontSize.BeforeFirst( 'p' ) );
1409
1410 double ktextSize = ScaleSize( ptSize );
1411
1412 if( textStr.Contains( wxS( "\n" ) ) )
1413 ktextSize *= 0.8;
1414 else
1415 ktextSize *= 0.95;
1416
1417 textItem->SetTextSize( VECTOR2I( ktextSize, ktextSize ) );
1418
1419 TransformTextToBaseline( textItem.get(), baselineAlign );
1420
1421 createdItems.push_back( std::move( textItem ) );
1422 }
1423 else if( rootType == wxS( "R" ) )
1424 {
1425 VECTOR2D start( Convert( arr[1] ), Convert( arr[2] ) );
1426
1427 VECTOR2D cr;
1428 cr.x = !arr[3].empty() ? Convert( arr[3] ) : 0,
1429 cr.y = !arr[4].empty() ? Convert( arr[4] ) : 0; // TODO: corner radius
1430
1431 VECTOR2D size( Convert( arr[5] ), Convert( arr[6] ) );
1432 wxString strokeColor = arr[7];
1433 double lineWidth = Convert( arr[8] );
1434 LINE_STYLE strokeStyle = ConvertStrokeStyle( arr[9] );
1435 wxString fillColor = arr[10].Lower();
1436 //bool locked = arr[12] != wxS( "0" );
1437
1438 //if( cr.x == 0 )
1439 {
1440 std::unique_ptr<SCH_SHAPE> rect = std::make_unique<SCH_SHAPE>( SHAPE_T::RECTANGLE );
1441
1442 rect->SetStart( RelPos( start ) );
1443 rect->SetEnd( RelPos( start + size ) );
1444
1445 rect->SetStroke( STROKE_PARAMS( ScaleSize( lineWidth ), strokeStyle ) );
1446
1447 if( fillColor != wxS( "none" ) )
1448 {
1449 rect->SetFilled( true );
1450
1451 if( fillColor == strokeColor )
1452 rect->SetFillMode( FILL_T::FILLED_SHAPE );
1453 else
1454 rect->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
1455 }
1456
1457 createdItems.push_back( std::move( rect ) );
1458 }
1459 /*else
1460 {
1461 }*/
1462 }
1463 else if( rootType == wxS( "I" ) )
1464 {
1465 VECTOR2D start( Convert( arr[1] ), Convert( arr[2] ) );
1466 VECTOR2D size( Convert( arr[3] ), Convert( arr[4] ) );
1467 //double angle = Convert( arr[5] ); // CSS-like transformations are used instead.
1468 wxString imageUrl = arr[6];
1469 wxString transformData = arr[9];
1470
1471 VECTOR2D kstart = RelPos( start );
1472 VECTOR2D ksize = ScalePos( size );
1473
1474 std::vector<std::pair<wxString, std::vector<double>>> transformCmds =
1475 ParseImageTransform( transformData );
1476
1477 auto applyTransform = [&]( SCH_ITEM* aSchItem )
1478 {
1479 for( const auto& cmd : transformCmds )
1480 {
1481 if( cmd.first == wxS( "rotate" ) )
1482 {
1483 if( cmd.second.size() != 3 )
1484 continue;
1485
1486 double cmdAngle = 360 - cmd.second[0];
1487 VECTOR2D cmdAround( cmd.second[1], cmd.second[2] );
1488
1489 for( double i = cmdAngle; i > 0; i -= 90 )
1490 {
1491 if( aSchItem->Type() == SCH_LINE_T )
1492 {
1493 // Lines need special handling for some reason
1494 aSchItem->SetFlags( STARTPOINT );
1495 aSchItem->Rotate( RelPos( cmdAround ), false );
1496 aSchItem->ClearFlags( STARTPOINT );
1497
1498 aSchItem->SetFlags( ENDPOINT );
1499 aSchItem->Rotate( RelPos( cmdAround ), false );
1500 aSchItem->ClearFlags( ENDPOINT );
1501 }
1502 else
1503 {
1504 aSchItem->Rotate( RelPos( cmdAround ), false );
1505 }
1506 }
1507 }
1508 else if( cmd.first == wxS( "translate" ) )
1509 {
1510 if( cmd.second.size() != 2 )
1511 continue;
1512
1513 VECTOR2D cmdOffset( cmd.second[0], cmd.second[1] );
1514 aSchItem->Move( ScalePos( cmdOffset ) );
1515 }
1516 else if( cmd.first == wxS( "scale" ) )
1517 {
1518 if( cmd.second.size() != 2 )
1519 continue;
1520
1521 double cmdScaleX = cmd.second[0];
1522 double cmdScaleY = cmd.second[1];
1523
1524 // Lines need special handling for some reason
1525 if( aSchItem->Type() == SCH_LINE_T )
1526 aSchItem->SetFlags( STARTPOINT | ENDPOINT );
1527
1528 if( cmdScaleX < 0 && cmdScaleY > 0 )
1529 {
1530 aSchItem->MirrorHorizontally( 0 );
1531 }
1532 else if( cmdScaleX > 0 && cmdScaleY < 0 )
1533 {
1534 aSchItem->MirrorVertically( 0 );
1535 }
1536 else if( cmdScaleX < 0 && cmdScaleY < 0 )
1537 {
1538 aSchItem->MirrorHorizontally( 0 );
1539 aSchItem->MirrorVertically( 0 );
1540 }
1541
1542 if( aSchItem->Type() == SCH_LINE_T )
1543 aSchItem->ClearFlags( STARTPOINT | ENDPOINT );
1544 }
1545 }
1546 };
1547
1548 if( imageUrl.BeforeFirst( ':' ) == wxS( "data" ) )
1549 {
1550 wxArrayString paramsArr =
1551 wxSplit( imageUrl.AfterFirst( ':' ).BeforeFirst( ',' ), ';', '\0' );
1552
1553 wxString data = imageUrl.AfterFirst( ',' );
1554
1555 if( paramsArr.size() > 0 )
1556 {
1557 wxString mimeType = paramsArr[0];
1558 wxMemoryBuffer buf = wxBase64Decode( data );
1559
1560 if( mimeType == wxS( "image/svg+xml" ) )
1561 {
1562 VECTOR2D offset = RelPos( start );
1563
1564 SVG_IMPORT_PLUGIN svgImportPlugin;
1565 GRAPHICS_IMPORTER_SCH schImporter;
1566
1567 svgImportPlugin.SetImporter( &schImporter );
1568 svgImportPlugin.LoadFromMemory( buf );
1569
1570 VECTOR2D imSize( svgImportPlugin.GetImageWidth(),
1571 svgImportPlugin.GetImageHeight() );
1572
1573 VECTOR2D pixelScale( schIUScale.IUTomm( ScaleSize( size.x ) ) / imSize.x,
1574 schIUScale.IUTomm( ScaleSize( size.y ) ) / imSize.y );
1575
1576 schImporter.SetScale( pixelScale );
1577
1578 VECTOR2D offsetMM( schIUScale.IUTomm( offset.x ),
1579 schIUScale.IUTomm( offset.y ) );
1580
1581 schImporter.SetImportOffsetMM( offsetMM );
1582
1583 svgImportPlugin.Import();
1584
1585 for( std::unique_ptr<EDA_ITEM>& item : schImporter.GetItems() )
1586 {
1587 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item.release() );
1588
1589 applyTransform( schItem );
1590
1591 createdItems.emplace_back( schItem );
1592 }
1593 }
1594 else
1595 {
1596 std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();
1597 REFERENCE_IMAGE& refImage = bitmap->GetReferenceImage();
1598
1599 wxImage::SetDefaultLoadFlags( wxImage::GetDefaultLoadFlags()
1600 & ~wxImage::Load_Verbose );
1601
1602 if( refImage.ReadImageFile( buf ) )
1603 {
1604 VECTOR2D kcenter = kstart + ksize / 2;
1605
1606 double scaleFactor = ScaleSize( size.x ) / refImage.GetSize().x;
1607 refImage.SetImageScale( scaleFactor );
1608 bitmap->SetPosition( kcenter );
1609
1610 applyTransform( bitmap.get() );
1611
1612 createdItems.push_back( std::move( bitmap ) );
1613 }
1614 }
1615 }
1616 }
1617 }
1618 }
1619
1620 BOX2I sheetBBox;
1621
1622 for( std::unique_ptr<SCH_ITEM>& ptr : createdItems )
1623 if( ptr->Type() == SCH_SYMBOL_T )
1624 sheetBBox.Merge( static_cast<SCH_SYMBOL*>( ptr.get() )->GetBodyBoundingBox() );
1625
1626 SCH_SCREEN* screen = aRootSheet->GetScreen();
1627 PAGE_INFO pageInfo = screen->GetPageSettings();
1628
1629 int alignGrid = schIUScale.MilsToIU( 50 );
1630
1631 VECTOR2D offset( -sheetBBox.GetLeft(), -sheetBBox.GetTop() );
1632 offset.x = KiROUND( offset.x / alignGrid ) * alignGrid;
1633 offset.y = KiROUND( offset.y / alignGrid ) * alignGrid;
1634
1635 pageInfo.SetWidthMils( schIUScale.IUToMils( sheetBBox.GetWidth() ) );
1636 pageInfo.SetHeightMils( schIUScale.IUToMils( sheetBBox.GetHeight() ) );
1637
1638 screen->SetPageSettings( pageInfo );
1639
1640 for( std::unique_ptr<SCH_ITEM>& ptr : createdItems )
1641 {
1642 ptr->Move( offset );
1643 screen->Append( ptr.release() );
1644 }
1645}
color
int color
Definition: DXF_plotter.cpp:60
schIUScale
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:112
bezier_curves.h
BITMAPS::left
@ left
BITMAPS::pin
@ pin
KiROUND
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition: box2.h:990
BOX2::GetWidth
constexpr size_type GetWidth() const
Definition: box2.h:214
BOX2::Merge
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
BOX2::GetHeight
constexpr size_type GetHeight() const
Definition: box2.h:215
BOX2::GetLeft
constexpr coord_type GetLeft() const
Definition: box2.h:228
BOX2::GetTop
constexpr coord_type GetTop() const
Definition: box2.h:229
EASYEDA_PARSER_BASE::ParseLineChains
std::vector< SHAPE_LINE_CHAIN > ParseLineChains(const wxString &aData, int aArcMinSegLen, bool aForceClosed)
Definition: easyeda_parser_base.cpp:111
EASYEDA_PARSER_BASE::Convert
static double Convert(const wxString &aValue)
Definition: easyeda_parser_base.cpp:33
EASYEDA_PARSER_BASE::RelPosX
double RelPosX(double aValue)
Definition: easyeda_parser_base.cpp:44
EASYEDA_PARSER_BASE::RelPosY
double RelPosY(double aValue)
Definition: easyeda_parser_base.cpp:51
EASYEDA_PARSER_BASE::RelPos
VECTOR2< T > RelPos(const VECTOR2< T > &aVec)
Definition: easyeda_parser_base.h:58
EASYEDA_PARSER_BASE::m_relOrigin
VECTOR2D m_relOrigin
Definition: easyeda_parser_base.h:69
EASYEDA_PARSER_BASE::ScalePos
VECTOR2< T > ScalePos(const VECTOR2< T > &aValue)
Definition: easyeda_parser_base.h:46
EASYEDA_PARSER_BASE::TransformTextToBaseline
void TransformTextToBaseline(EDA_TEXT *textItem, const wxString &baselineAlign)
Definition: easyeda_parser_base.cpp:70
EDA_SHAPE::SetBezierC2
void SetBezierC2(const VECTOR2I &aPt)
Definition: eda_shape.h:257
EDA_SHAPE::SetStart
void SetStart(const VECTOR2I &aStart)
Definition: eda_shape.h:177
EDA_SHAPE::SetEnd
void SetEnd(const VECTOR2I &aEnd)
Definition: eda_shape.h:219
EDA_SHAPE::SetBezierC1
void SetBezierC1(const VECTOR2I &aPt)
Definition: eda_shape.h:254
EDA_TEXT
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:80
EDA_TEXT::SetTextSize
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
Definition: eda_text.cpp:533
EDA_TEXT::GetText
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:98
EDA_TEXT::SetTextPos
void SetTextPos(const VECTOR2I &aPoint)
Definition: eda_text.cpp:578
EDA_TEXT::SetVertJustify
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
Definition: eda_text.cpp:417
EDA_TEXT::GetHorizJustify
GR_TEXT_H_ALIGN_T GetHorizJustify() const
Definition: eda_text.h:198
EDA_TEXT::SetVisible
virtual void SetVisible(bool aVisible)
Definition: eda_text.cpp:386
EDA_TEXT::SetTextAngleDegrees
void SetTextAngleDegrees(double aOrientation)
Definition: eda_text.h:148
EDA_TEXT::GetVertJustify
GR_TEXT_V_ALIGN_T GetVertJustify() const
Definition: eda_text.h:201
EDA_TEXT::SetText
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:270
EDA_TEXT::SetFont
void SetFont(KIFONT::FONT *aFont)
Definition: eda_text.cpp:499
EDA_TEXT::SetHorizJustify
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
Definition: eda_text.cpp:409
GRAPHICS_IMPORTER_LIB_SYMBOL
Definition: graphics_importer_lib_symbol.h:36
GRAPHICS_IMPORTER_SCH
Definition: graphics_importer_sch.h:36
GRAPHICS_IMPORTER::SetImportOffsetMM
void SetImportOffsetMM(const VECTOR2D &aOffset)
Set the offset in millimeters to add to coordinates when importing graphic items.
Definition: graphics_importer.h:189
GRAPHICS_IMPORTER::SetScale
void SetScale(const VECTOR2D &aScale)
Set the scale factor affecting the imported shapes.
Definition: graphics_importer.h:199
GRAPHICS_IMPORTER::GetItems
std::list< std::unique_ptr< EDA_ITEM > > & GetItems()
Return the list of objects representing the imported shapes.
Definition: graphics_importer.h:223
GRAPHICS_IMPORT_PLUGIN::SetImporter
virtual void SetImporter(GRAPHICS_IMPORTER *aImporter)
Set the receiver of the imported shapes.
Definition: graphics_import_plugin.h:47
KIFONT::FONT::GetFont
static FONT * GetFont(const wxString &aFontName=wxEmptyString, bool aBold=false, bool aItalic=false, const std::vector< wxString > *aEmbeddedFiles=nullptr, bool aForDrawingSheet=false)
Definition: font.cpp:147
LIB_ID
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
LIB_ID::Parse
int Parse(const UTF8 &aId, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition: lib_id.cpp:52
LIB_SYMBOL
Define a library symbol object.
Definition: lib_symbol.h:85
LIB_SYMBOL::GetValueField
SCH_FIELD & GetValueField()
Return reference to the value field.
Definition: lib_symbol.h:334
LIB_SYMBOL::AddDrawItem
void AddDrawItem(SCH_ITEM *aItem, bool aSort=true)
Add a new draw aItem to the draw object list and sort according to aSort.
Definition: lib_symbol.cpp:786
LIB_SYMBOL::GetReferenceField
SCH_FIELD & GetReferenceField()
Return reference to the reference designator field.
Definition: lib_symbol.h:338
PAGE_INFO
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:59
PAGE_INFO::SetHeightMils
void SetHeightMils(double aHeightInMils)
Definition: page_info.cpp:261
PAGE_INFO::SetWidthMils
void SetWidthMils(double aWidthInMils)
Definition: page_info.cpp:247
PROGRESS_REPORTER
A progress reporter interface for use in multi-threaded environments.
Definition: progress_reporter.h:39
REFERENCE_IMAGE
A REFERENCE_IMAGE is a wrapper around a BITMAP_IMAGE that is displayed in an editor as a reference fo...
Definition: reference_image.h:43
REFERENCE_IMAGE::ReadImageFile
bool ReadImageFile(const wxString &aFullFilename)
Read and store an image file.
Definition: reference_image.cpp:267
REFERENCE_IMAGE::GetSize
VECTOR2I GetSize() const
Definition: reference_image.cpp:168
REFERENCE_IMAGE::SetImageScale
void SetImageScale(double aScale)
Set the image "zoom" value.
Definition: reference_image.cpp:200
REPORTER
A pure virtual class used to derive REPORTER objects from.
Definition: reporter.h:73
REPORTER::Report
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Report a string with a given severity.
Definition: reporter.h:102
SCHEMATIC
Holds all the data relating to one schematic.
Definition: schematic.h:69
SCHEMATIC::CurrentSheet
SCH_SHEET_PATH & CurrentSheet() const
Definition: schematic.h:148
SCH_EASYEDA_PARSER::ParseSymbolShapes
void ParseSymbolShapes(LIB_SYMBOL *aContainer, std::map< wxString, wxString > paramMap, wxArrayString aShapes)
Definition: sch_easyeda_parser.cpp:394
SCH_EASYEDA_PARSER::~SCH_EASYEDA_PARSER
~SCH_EASYEDA_PARSER()
Definition: sch_easyeda_parser.cpp:69
SCH_EASYEDA_PARSER::MakePowerSymbol
std::pair< LIB_SYMBOL *, bool > MakePowerSymbol(const wxString &aFlagTypename, const wxString &aNetname)
Definition: sch_easyeda_parser.cpp:984
SCH_EASYEDA_PARSER::ScaleSize
double ScaleSize(double aValue) override
Definition: sch_easyeda_parser.h:42
SCH_EASYEDA_PARSER::ParseSchematic
void ParseSchematic(SCHEMATIC *aSchematic, SCH_SHEET *aRootSheet, const wxString &aFileName, wxArrayString aShapes)
Definition: sch_easyeda_parser.cpp:1067
SCH_EASYEDA_PARSER::RelPosSym
VECTOR2< T > RelPosSym(const VECTOR2< T > &aVec)
Definition: sch_easyeda_parser.h:48
SCH_EASYEDA_PARSER::m_schematic
SCHEMATIC * m_schematic
Definition: sch_easyeda_parser.h:66
SCH_EASYEDA_PARSER::ParseSymbol
LIB_SYMBOL * ParseSymbol(const VECTOR2D &aOrigin, std::map< wxString, wxString > aParams, wxArrayString aShapes)
Definition: sch_easyeda_parser.cpp:923
SCH_EASYEDA_PARSER::SCH_EASYEDA_PARSER
SCH_EASYEDA_PARSER(SCHEMATIC *aSchematic, PROGRESS_REPORTER *aProgressReporter)
Definition: sch_easyeda_parser.cpp:62
SCH_FIELD
Definition: sch_field.h:42
SCH_FIELD::SetPosition
void SetPosition(const VECTOR2I &aPosition) override
Definition: sch_field.cpp:1301
SCH_FIELD::SetText
void SetText(const wxString &aText) override
Definition: sch_field.cpp:1077
SCH_ITEM
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:167
SCH_SCREEN
Definition: sch_screen.h:94
SCH_SCREEN::GetPageSettings
const PAGE_INFO & GetPageSettings() const
Definition: sch_screen.h:134
SCH_SCREEN::Append
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Definition: sch_screen.cpp:156
SCH_SCREEN::SetPageSettings
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: sch_screen.h:135
SCH_SHAPE
Definition: sch_shape.h:33
SCH_SHAPE::SetStroke
void SetStroke(const STROKE_PARAMS &aStroke) override
Definition: sch_shape.cpp:63
SCH_SHAPE::AddPoint
void AddPoint(const VECTOR2I &aPosition)
Definition: sch_shape.cpp:394
SCH_SHEET
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:47
SCH_SHEET::GetScreen
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:116
SCH_SYMBOL
Schematic symbol object.
Definition: sch_symbol.h:75
SCH_SYMBOL::GetBodyBoundingBox
BOX2I GetBodyBoundingBox() const override
Return a bounding box for the symbol body but not the pins or fields.
Definition: sch_symbol.cpp:1880
SCH_TEXT
Definition: sch_text.h:38
SEG
Definition: seg.h:42
SEG::A
VECTOR2I A
Definition: seg.h:49
SEG::B
VECTOR2I B
Definition: seg.h:50
SHAPE_ARC
Definition: shape_arc.h:40
SHAPE_ARC::GetArcMid
const VECTOR2I & GetArcMid() const
Definition: shape_arc.h:118
SHAPE_ARC::GetP1
const VECTOR2I & GetP1() const
Definition: shape_arc.h:117
SHAPE_ARC::GetP0
const VECTOR2I & GetP0() const
Definition: shape_arc.h:116
SHAPE_CIRCLE::SetCenter
void SetCenter(const VECTOR2I &aCenter)
Definition: shape_circle.h:113
SHAPE_LINE_CHAIN
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Definition: shape_line_chain.h:82
SHAPE_LINE_CHAIN::Move
void Move(const VECTOR2I &aVector) override
Definition: shape_line_chain.h:743
SHAPE_LINE_CHAIN::Arc
const SHAPE_ARC & Arc(size_t aArc) const
Definition: shape_line_chain.h:833
SHAPE_LINE_CHAIN::IsClosed
bool IsClosed() const override
Definition: shape_line_chain.h:279
SHAPE_LINE_CHAIN::SetClosed
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
Definition: shape_line_chain.h:270
SHAPE_LINE_CHAIN::PointCount
int PointCount() const
Return the number of points (vertices) in this line chain.
Definition: shape_line_chain.h:351
SHAPE_LINE_CHAIN::ArcIndex
ssize_t ArcIndex(size_t aSegment) const
Return the arc index for the given segment index.
Definition: shape_line_chain.h:825
SHAPE_LINE_CHAIN::NextShape
int NextShape(int aPointIndex) const
Return the vertex index of the next shape in the chain, or -1 if aPointIndex is the last shape.
Definition: shape_line_chain.cpp:1276
SHAPE_LINE_CHAIN::Append
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
Definition: shape_line_chain.h:501
SHAPE_LINE_CHAIN::CPoint
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
Definition: shape_line_chain.h:402
SHAPE_LINE_CHAIN::SegmentCount
int SegmentCount() const
Return the number of segments in this line chain.
Definition: shape_line_chain.h:309
SHAPE_LINE_CHAIN::CSegment
const SEG CSegment(int aIndex) const
Return a constant copy of the aIndex segment in the line chain.
Definition: shape_line_chain.h:372
SHAPE_LINE_CHAIN::IsArcStart
bool IsArcStart(size_t aIndex) const
Definition: shape_line_chain.cpp:3022
SHAPE::Centre
virtual VECTOR2I Centre() const
Compute a center-of-mass of the shape.
Definition: shape.h:232
SPIN_STYLE
Definition: sch_label.h:42
SPIN_STYLE::RIGHT
@ RIGHT
Definition: sch_label.h:48
SPIN_STYLE::LEFT
@ LEFT
Definition: sch_label.h:46
SPIN_STYLE::UP
@ UP
Definition: sch_label.h:47
SPIN_STYLE::BOTTOM
@ BOTTOM
Definition: sch_label.h:49
SPIN_STYLE::RotateCCW
SPIN_STYLE RotateCCW()
Definition: sch_label.cpp:107
STROKE_PARAMS
Simple container to manage line stroke parameters.
Definition: stroke_params.h:94
SVG_IMPORT_PLUGIN
Definition: svg_import_plugin.h:38
SVG_IMPORT_PLUGIN::Import
bool Import() override
Actually imports the file.
Definition: svg_import_plugin.cpp:97
SVG_IMPORT_PLUGIN::GetImageWidth
virtual double GetImageWidth() const override
Return image width from original imported file.
Definition: svg_import_plugin.cpp:238
SVG_IMPORT_PLUGIN::LoadFromMemory
bool LoadFromMemory(const wxMemoryBuffer &aMemBuffer) override
Set memory buffer with content for import.
Definition: svg_import_plugin.cpp:79
SVG_IMPORT_PLUGIN::GetImageHeight
virtual double GetImageHeight() const override
Return image height from original imported file.
Definition: svg_import_plugin.cpp:226
_
#define _(s)
Definition: eda_3d_actions.cpp:36
ENDPOINT
#define ENDPOINT
ends. (Used to support dragging.)
Definition: eda_item_flags.h:46
STARTPOINT
#define STARTPOINT
When a line is selected, these flags indicate which.
Definition: eda_item_flags.h:45
SHAPE_T::CIRCLE
@ CIRCLE
SHAPE_T::POLY
@ POLY
SHAPE_T::BEZIER
@ BEZIER
ConvertImageToLibShapes
void ConvertImageToLibShapes(LIB_SYMBOL *aSymbol, int unit, wxImage img, VECTOR2D pixelScale, VECTOR2D offset)
Definition: gfx_import_utils.cpp:109
gfx_import_utils.h
graphics_importer_lib_symbol.h
graphics_importer_sch.h
LAYER_DEVICE
@ LAYER_DEVICE
Definition: layer_ids.h:455
LAYER_WIRE
@ LAYER_WIRE
Definition: layer_ids.h:441
map_helpers.h
get_opt
std::optional< V > get_opt(const std::map< wxString, V > &aMap, const wxString &aKey)
Definition: map_helpers.h:34
std::abs
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition: eda_angle.h:393
ELECTRICAL_PINTYPE
ELECTRICAL_PINTYPE
The symbol library pin object electrical types used in ERC tests.
Definition: pin_type.h:36
ELECTRICAL_PINTYPE::PT_INPUT
@ PT_INPUT
usual pin input: must be connected
ELECTRICAL_PINTYPE::PT_OUTPUT
@ PT_OUTPUT
usual output
ELECTRICAL_PINTYPE::PT_BIDI
@ PT_BIDI
input or output (like port for a microprocessor)
ELECTRICAL_PINTYPE::PT_UNSPECIFIED
@ PT_UNSPECIFIED
unknown electrical properties: creates always a warning when connected
ELECTRICAL_PINTYPE::PT_PASSIVE
@ PT_PASSIVE
pin for passive symbols: must be connected, and can be connected to any pin.
PIN_ORIENTATION
PIN_ORIENTATION
The symbol library pin object orientations.
Definition: pin_type.h:80
RPT_SEVERITY_WARNING
@ RPT_SEVERITY_WARNING
Definition: report_severity.h:31
sch_bitmap.h
RegexMatchAll
static std::vector< std::vector< wxString > > RegexMatchAll(wxRegEx &aRegex, const wxString &aString)
Definition: sch_easyeda_parser.cpp:74
c_attributesWhitelist
static const std::vector< wxString > c_attributesWhitelist
Definition: sch_easyeda_parser.cpp:49
ConvertElecType
static ELECTRICAL_PINTYPE ConvertElecType(const wxString &aType)
Definition: sch_easyeda_parser.cpp:171
HelperGeneratePowerPortGraphics
VECTOR2I HelperGeneratePowerPortGraphics(LIB_SYMBOL *aKsymbol, EASYEDA::POWER_FLAG_STYLE aStyle, REPORTER *aReporter)
Definition: sch_easyeda_parser.cpp:188
EasyEdaToKiCadLibID
static LIB_ID EasyEdaToKiCadLibID(const wxString &aLibName, const wxString &aLibReference)
Definition: sch_easyeda_parser.cpp:145
ParseImageTransform
static std::vector< std::pair< wxString, std::vector< double > > > ParseImageTransform(const wxString &transformData)
EasyEDA image transformations are in the form of:
Definition: sch_easyeda_parser.cpp:110
ConvertStrokeStyle
static LINE_STYLE ConvertStrokeStyle(const wxString &aStyle)
Definition: sch_easyeda_parser.cpp:158
sch_easyeda_parser.h
sch_edit_frame.h
HelperGeneratePowerPortGraphics
VECTOR2I HelperGeneratePowerPortGraphics(LIB_SYMBOL *aKsymbol, ASCH_POWER_PORT_STYLE aStyle, REPORTER *aReporter)
Definition: sch_io_altium.cpp:3450
sch_io_mgr.h
sch_junction.h
sch_label.h
sch_line.h
sch_no_connect.h
sch_shape.h
sch_sheet.h
scale
const int scale
Definition: spread_footprints.cpp:56
EscapeString
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
Definition: string_utils.cpp:179
UnescapeHTML
wxString UnescapeHTML(const wxString &aString)
Return a new wxString unescaped from HTML format.
Definition: string_utils.cpp:591
string_utils.h
CTX_LIBID
@ CTX_LIBID
Definition: string_utils.h:54
LINE_STYLE
LINE_STYLE
Dashed line types.
Definition: stroke_params.h:46
LINE_STYLE::DOT
@ DOT
LINE_STYLE::DEFAULT
@ DEFAULT
LINE_STYLE::DASH
@ DASH
LINE_STYLE::SOLID
@ SOLID
EDA_IU_SCALE::IUTomm
constexpr double IUTomm(int iu) const
Definition: base_units.h:88
EDA_IU_SCALE::IUToMils
constexpr int IUToMils(int iu) const
Definition: base_units.h:101
EDA_IU_SCALE::MilsToIU
constexpr int MilsToIU(int mils) const
Definition: base_units.h:95
svg_import_plugin.h
SYM_ROTATE_CLOCKWISE
@ SYM_ROTATE_CLOCKWISE
Definition: symbol.h:37
SYM_ROTATE_COUNTERCLOCKWISE
@ SYM_ROTATE_COUNTERCLOCKWISE
Definition: symbol.h:38
SYM_MIRROR_X
@ SYM_MIRROR_X
Definition: symbol.h:43
center
VECTOR2I center
Definition: test_shape_arc.cpp:520
chain
const SHAPE_LINE_CHAIN chain
Definition: test_shape_arc.cpp:1047
radius
int radius
Definition: test_shape_arc.cpp:1057
circle
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
GR_TEXT_H_ALIGN_CENTER
@ GR_TEXT_H_ALIGN_CENTER
Definition: text_attributes.h:45
GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_RIGHT
Definition: text_attributes.h:46
GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_H_ALIGN_LEFT
Definition: text_attributes.h:44
GR_TEXT_V_ALIGN_BOTTOM
@ GR_TEXT_V_ALIGN_BOTTOM
Definition: text_attributes.h:55
GR_TEXT_V_ALIGN_CENTER
@ GR_TEXT_V_ALIGN_CENTER
Definition: text_attributes.h:54
GR_TEXT_V_ALIGN_TOP
@ GR_TEXT_V_ALIGN_TOP
Definition: text_attributes.h:53
SCH_LINE_T
@ SCH_LINE_T
Definition: typeinfo.h:163
SCH_SYMBOL_T
@ SCH_SYMBOL_T
Definition: typeinfo.h:172
VECTOR2I
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
VECTOR2D
VECTOR2< double > VECTOR2D
Definition: vector2d.h:694