KiCad PCB EDA Suite
Loading...
Searching...
No Matches
altium_parser_pcb.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) 2020 Thomas Pointhuber <[email protected]>
5 * Copyright (C) 2023 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 <map>
26#include <unordered_map>
27
28#include <ki_exception.h>
29#include <math/util.h>
30
31#include <wx/log.h>
32
33#include "altium_parser_pcb.h"
36
37
38ALTIUM_LAYER altium_layer_from_name( const wxString& aName )
39{
40 static const std::unordered_map<std::string, ALTIUM_LAYER> hash_map = {
41 { "TOP", ALTIUM_LAYER::TOP_LAYER },
42 { "MID1", ALTIUM_LAYER::MID_LAYER_1 },
43 { "MID2", ALTIUM_LAYER::MID_LAYER_2 },
44 { "MID3", ALTIUM_LAYER::MID_LAYER_3 },
45 { "MID4", ALTIUM_LAYER::MID_LAYER_4 },
46 { "MID5", ALTIUM_LAYER::MID_LAYER_5 },
47 { "MID6", ALTIUM_LAYER::MID_LAYER_6 },
48 { "MID7", ALTIUM_LAYER::MID_LAYER_7 },
49 { "MID8", ALTIUM_LAYER::MID_LAYER_8 },
50 { "MID9", ALTIUM_LAYER::MID_LAYER_9 },
51 { "MID10", ALTIUM_LAYER::MID_LAYER_10 },
52 { "MID11", ALTIUM_LAYER::MID_LAYER_11 },
53 { "MID12", ALTIUM_LAYER::MID_LAYER_12 },
54 { "MID13", ALTIUM_LAYER::MID_LAYER_13 },
55 { "MID14", ALTIUM_LAYER::MID_LAYER_14 },
56 { "MID15", ALTIUM_LAYER::MID_LAYER_15 },
57 { "MID16", ALTIUM_LAYER::MID_LAYER_16 },
58 { "MID17", ALTIUM_LAYER::MID_LAYER_17 },
59 { "MID18", ALTIUM_LAYER::MID_LAYER_18 },
60 { "MID19", ALTIUM_LAYER::MID_LAYER_19 },
61 { "MID20", ALTIUM_LAYER::MID_LAYER_20 },
62 { "MID21", ALTIUM_LAYER::MID_LAYER_21 },
63 { "MID22", ALTIUM_LAYER::MID_LAYER_22 },
64 { "MID23", ALTIUM_LAYER::MID_LAYER_23 },
65 { "MID24", ALTIUM_LAYER::MID_LAYER_24 },
66 { "MID25", ALTIUM_LAYER::MID_LAYER_25 },
67 { "MID26", ALTIUM_LAYER::MID_LAYER_26 },
68 { "MID27", ALTIUM_LAYER::MID_LAYER_27 },
69 { "MID28", ALTIUM_LAYER::MID_LAYER_28 },
70 { "MID29", ALTIUM_LAYER::MID_LAYER_29 },
71 { "MID30", ALTIUM_LAYER::MID_LAYER_30 },
72 { "BOTTOM", ALTIUM_LAYER::BOTTOM_LAYER },
73
74 { "TOPOVERLAY", ALTIUM_LAYER::TOP_OVERLAY },
75 { "BOTTOMOVERLAY", ALTIUM_LAYER::BOTTOM_OVERLAY },
76 { "TOPPASTE", ALTIUM_LAYER::TOP_PASTE },
77 { "BOTTOMPASTE", ALTIUM_LAYER::BOTTOM_PASTE },
78 { "TOPSOLDER", ALTIUM_LAYER::TOP_SOLDER },
79 { "BOTTOMSOLDER", ALTIUM_LAYER::BOTTOM_SOLDER },
80
97
98 { "DRILLGUIDE", ALTIUM_LAYER::DRILL_GUIDE },
99 { "KEEPOUT", ALTIUM_LAYER::KEEP_OUT_LAYER },
100
101 { "MECHANICAL1", ALTIUM_LAYER::MECHANICAL_1 },
102 { "MECHANICAL2", ALTIUM_LAYER::MECHANICAL_2 },
103 { "MECHANICAL3", ALTIUM_LAYER::MECHANICAL_3 },
104 { "MECHANICAL4", ALTIUM_LAYER::MECHANICAL_4 },
105 { "MECHANICAL5", ALTIUM_LAYER::MECHANICAL_5 },
106 { "MECHANICAL6", ALTIUM_LAYER::MECHANICAL_6 },
107 { "MECHANICAL7", ALTIUM_LAYER::MECHANICAL_7 },
108 { "MECHANICAL8", ALTIUM_LAYER::MECHANICAL_8 },
109 { "MECHANICAL9", ALTIUM_LAYER::MECHANICAL_9 },
110 { "MECHANICAL10", ALTIUM_LAYER::MECHANICAL_10 },
111 { "MECHANICAL11", ALTIUM_LAYER::MECHANICAL_11 },
112 { "MECHANICAL12", ALTIUM_LAYER::MECHANICAL_12 },
113 { "MECHANICAL13", ALTIUM_LAYER::MECHANICAL_13 },
114 { "MECHANICAL14", ALTIUM_LAYER::MECHANICAL_14 },
115 { "MECHANICAL15", ALTIUM_LAYER::MECHANICAL_15 },
116 { "MECHANICAL16", ALTIUM_LAYER::MECHANICAL_16 },
117
118 { "DRILLDRAWING", ALTIUM_LAYER::DRILL_DRAWING },
119 { "MULTILAYER", ALTIUM_LAYER::MULTI_LAYER },
120
121 // FIXME: the following mapping is just a guess
122 { "CONNECTIONS", ALTIUM_LAYER::CONNECTIONS },
123 { "BACKGROUND", ALTIUM_LAYER::BACKGROUND },
124 { "DRCERRORMARKERS", ALTIUM_LAYER::DRC_ERROR_MARKERS },
125 { "SELECTIONS", ALTIUM_LAYER::SELECTIONS },
126 { "VISIBLEGRID1", ALTIUM_LAYER::VISIBLE_GRID_1 },
127 { "VISIBLEGRID2", ALTIUM_LAYER::VISIBLE_GRID_2 },
128 { "PADHOLES", ALTIUM_LAYER::PAD_HOLES },
129 { "VIAHOLES", ALTIUM_LAYER::VIA_HOLES },
130 };
131
132 auto it = hash_map.find( std::string( aName.c_str() ) );
133
134 if( it == hash_map.end() )
135 {
136 wxLogError( _( "Unknown mapping of the Altium layer '%s'." ), aName );
138 }
139 else
140 {
141 return it->second;
142 }
143}
144
145void altium_parse_polygons( std::map<wxString, wxString>& aProps,
146 std::vector<ALTIUM_VERTICE>& aVertices )
147{
148 for( size_t i = 0; i < std::numeric_limits<size_t>::max(); i++ )
149 {
150 const wxString si = std::to_string( i );
151
152 const wxString vxi = wxT( "VX" ) + si;
153 const wxString vyi = wxT( "VY" ) + si;
154
155 if( aProps.find( vxi ) == aProps.end() || aProps.find( vyi ) == aProps.end() )
156 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
157
158 const bool isRound = ALTIUM_PROPS_UTILS::ReadInt( aProps, wxT( "KIND" ) + si, 0 ) != 0;
159 const int32_t radius = ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "R" ) + si, wxT( "0mil" ) );
160 const double sa = ALTIUM_PROPS_UTILS::ReadDouble( aProps, wxT( "SA" ) + si, 0. );
161 const double ea = ALTIUM_PROPS_UTILS::ReadDouble( aProps, wxT( "EA" ) + si, 0. );
162 const VECTOR2I vp = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, vxi, wxT( "0mil" ) ),
163 -ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, vyi, wxT( "0mil" ) ) );
164 const VECTOR2I cp = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "CX" ) + si, wxT( "0mil" ) ),
165 -ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "CY" ) + si, wxT( "0mil" ) ) );
166
167 aVertices.emplace_back( isRound, radius, sa, ea, vp, cp );
168 }
169}
170
171
172static ALTIUM_MODE ReadAltiumModeFromProperties( const std::map<wxString, wxString>& aProps,
173 wxString aKey )
174{
175 wxString mode = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
176
177 if( mode == wxT( "None" ) )
178 return ALTIUM_MODE::NONE;
179 else if( mode == wxT( "Rule" ) )
180 return ALTIUM_MODE::RULE;
181 else if( mode == wxT( "Manual" ) )
182 return ALTIUM_MODE::MANUAL;
183
184 wxLogError( _( "Unknown Mode string: '%s'." ), mode );
186}
187
188
189static ALTIUM_RECORD ReadAltiumRecordFromProperties( const std::map<wxString, wxString>& aProps,
190 wxString aKey )
191{
192 wxString record = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
193
194 if( record == wxT( "Arc" ) )
195 return ALTIUM_RECORD::ARC;
196 else if( record == wxT( "Pad" ) )
197 return ALTIUM_RECORD::PAD;
198 else if( record == wxT( "Via" ) )
199 return ALTIUM_RECORD::VIA;
200 else if( record == wxT( "Track" ) )
202 else if( record == wxT( "Text" ) )
203 return ALTIUM_RECORD::TEXT;
204 else if( record == wxT( "Fill" ) )
205 return ALTIUM_RECORD::FILL;
206 else if( record == wxT( "Region" ) ) // correct?
208 else if( record == wxT( "Model" ) )
210
211 wxLogError( _( "Unknown Record name string: '%s'." ), record );
213}
214
215
218 const std::map<wxString, wxString>& aProps, wxString aKey )
219{
220 wxString parsedType = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
221
222 if( parsedType == wxT( "Mask" ) )
224
225 wxLogError( _( "Unknown Extended Primitive Information type: '%s'." ), parsedType );
227}
228
229
238static void ExpectSubrecordLengthAtLeast( const std::string& aStreamType,
239 const std::string& aSubrecordName, size_t aExpectedLength,
240 size_t aActualLength )
241{
242 if( aActualLength < aExpectedLength )
243 {
244 THROW_IO_ERROR( wxString::Format( "%s stream %s has length %d, "
245 "which is unexpected (expected at least %d)",
246 aStreamType, aSubrecordName, aActualLength,
247 aExpectedLength ) );
248 }
249}
250
251
253{
254 const std::map<wxString, wxString> props = aReader.ReadProperties();
255
256 if( props.empty() )
257 THROW_IO_ERROR( wxT( "ExtendedPrimitiveInformation stream has no properties!" ) );
258
259 primitiveIndex = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "PRIMITIVEINDEX" ), -1 );
260 primitiveObjectId = ReadAltiumRecordFromProperties( props, wxT( "PRIMITIVEOBJECTID" ) );
262
263 pastemaskexpansionmode = ReadAltiumModeFromProperties( props, wxT( "PASTEMASKEXPANSIONMODE" ) );
265 props, wxT( "PASTEMASKEXPANSION_MANUAL" ), wxT( "0mil" ) );
267 ReadAltiumModeFromProperties( props, wxT( "SOLDERMASKEXPANSIONMODE" ) );
269 props, wxT( "SOLDERMASKEXPANSION_MANUAL" ), wxT( "0mil" ) );
270}
271
272
274{
275 std::map<wxString, wxString> props = aReader.ReadProperties();
276
277 if( props.empty() )
278 THROW_IO_ERROR( wxT( "Board6 stream has no properties!" ) );
279
280 sheetpos = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETX" ), wxT( "0mil" ) ),
281 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETY" ), wxT( "0mil" ) ) );
282 sheetsize = wxSize( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETWIDTH" ), wxT( "0mil" ) ),
283 ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETHEIGHT" ), wxT( "0mil" ) ) );
284
285 layercount = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "LAYERSETSCOUNT" ), 1 ) + 1;
286
287 for( size_t i = 1; i < std::numeric_limits<size_t>::max(); i++ )
288 {
289 const wxString layeri = wxT( "LAYER" ) + wxString( std::to_string( i ) );
290 const wxString layername = layeri + wxT( "NAME" );
291
292 auto layernameit = props.find( layername );
293
294 if( layernameit == props.end() )
295 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
296
298
299 l.name = ALTIUM_PROPS_UTILS::ReadString( props, layername, wxT( "" ) );
300 wxString originalName = l.name;
301 int ii = 2;
302
303 // Ensure that layer names are unique in KiCad
304 while( !layerNames.insert( l.name ).second )
305 l.name = wxString::Format( wxT( "%s %d" ), originalName, ii++ );
306
307 l.nextId = ALTIUM_PROPS_UTILS::ReadInt( props, layeri + wxT( "NEXT" ), 0 );
308 l.prevId = ALTIUM_PROPS_UTILS::ReadInt( props, layeri + wxT( "PREV" ), 0 );
309 l.copperthick = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, layeri + wxT( "COPTHICK" ), wxT( "1.4mil" ) );
310
311 l.dielectricconst = ALTIUM_PROPS_UTILS::ReadDouble( props, layeri + wxT( "DIELCONST" ), 0. );
312 l.dielectricthick = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, layeri + wxT( "DIELHEIGHT" ), wxT( "60mil" ) );
313 l.dielectricmaterial = ALTIUM_PROPS_UTILS::ReadString( props, layeri + wxT( "DIELMATERIAL" ), wxT( "FR-4" ) );
314
315 stackup.push_back( l );
316 }
317
319
320 if( aReader.HasParsingError() )
321 THROW_IO_ERROR( wxT( "Board6 stream was not parsed correctly!" ) );
322}
323
325{
326 std::map<wxString, wxString> properties = aReader.ReadProperties();
327
328 if( properties.empty() )
329 THROW_IO_ERROR( wxT( "Classes6 stream has no properties!" ) );
330
331 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
332 uniqueid = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "UNIQUEID" ), wxT( "" ) );
333 kind = static_cast<ALTIUM_CLASS_KIND>( ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KIND" ), -1 ) );
334
335 for( size_t i = 0; i < std::numeric_limits<size_t>::max(); i++ )
336 {
337 auto mit = properties.find( wxT( "M" ) + wxString( std::to_string( i ) ) );
338
339 if( mit == properties.end() )
340 break; // it doesn't seem like we know beforehand how many components are in the netclass
341
342 names.push_back( mit->second );
343 }
344
345 if( aReader.HasParsingError() )
346 THROW_IO_ERROR( wxT( "Classes6 stream was not parsed correctly" ) );
347}
348
350{
351 std::map<wxString, wxString> props = aReader.ReadProperties();
352
353 if( props.empty() )
354 THROW_IO_ERROR( wxT( "Components6 stream has no props" ) );
355
356 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( props, wxT( "LAYER" ), wxT( "" ) ) );
357 position = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "X" ), wxT( "0mil" ) ),
358 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "Y" ), wxT( "0mil" ) ) );
359 rotation = ALTIUM_PROPS_UTILS::ReadDouble( props, wxT( "ROTATION" ), 0. );
360 locked = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "LOCKED" ), false );
361 nameon = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "NAMEON" ), true );
362 commenton = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "COMMENTON" ), false );
363 sourcedesignator = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCEDESIGNATOR" ), wxT( "" ) );
364
366 ALTIUM_PROPS_UTILS::ReadUnicodeString( props, wxT( "SOURCEFOOTPRINTLIBRARY" ), wxT( "" ) );
367 pattern = ALTIUM_PROPS_UTILS::ReadUnicodeString( props, wxT( "PATTERN" ), wxT( "" ) );
368
369 sourcecomponentlibrary = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCECOMPONENTLIBRARY" ), wxT( "" ) );
370 sourcelibreference = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCELIBREFERENCE" ), wxT( "" ) );
371
373 ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "NAMEAUTOPOSITION" ), 0 ) );
375 ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "COMMENTAUTOPOSITION" ), 0 ) );
376
377 if( aReader.HasParsingError() )
378 THROW_IO_ERROR( wxT( "Components6 stream was not parsed correctly" ) );
379}
380
382{
383 aReader.Skip( 2 );
384
385 std::map<wxString, wxString> props = aReader.ReadProperties();
386
387 if( props.empty() )
388 THROW_IO_ERROR( wxT( "Dimensions6 stream has no props" ) );
389
390 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( props, wxT( "LAYER" ), wxT( "" ) ) );
391 kind = static_cast<ALTIUM_DIMENSION_KIND>( ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "DIMENSIONKIND" ), 0 ) );
392
393 textformat = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTFORMAT" ), wxT( "" ) );
394 textprefix = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTPREFIX" ), wxT( "" ) );
395 textsuffix = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTSUFFIX" ), wxT( "" ) );
396
397 height = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "HEIGHT" ), wxT( "0mil" ) );
398 angle = ALTIUM_PROPS_UTILS::ReadDouble( props, wxT( "ANGLE" ), 0. );
399
400 linewidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "LINEWIDTH" ), wxT( "10mil" ) );
401 textheight = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTHEIGHT" ), wxT( "10mil" ) );
402 textlinewidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTLINEWIDTH" ), wxT( "6mil" ) );
403 textprecision = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "TEXTPRECISION" ), 2 );
404 textbold = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "TEXTLINEWIDTH" ), false );
405 textitalic = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "ITALIC" ), false );
406 textgap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTGAP" ), wxT( "10mil" ) );
407
408 arrowsize = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "ARROWSIZE" ), wxT( "60mil" ) );
409
410 wxString text_position_raw = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTPOSITION" ), wxT( "" ) );
411
412 xy1 = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "X1" ), wxT( "0mil" ) ),
413 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "Y1" ), wxT( "0mil" ) ) );
414
415 int refcount = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "REFERENCES_COUNT" ), 0 );
416
417 for( int i = 0; i < refcount; i++ )
418 {
419 const std::string refi = "REFERENCE" + std::to_string( i ) + "POINT";
420 const wxString ref( refi );
421 referencePoint.emplace_back( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, ref + wxT( "X" ), wxT( "0mil" ) ),
422 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, ref + wxT( "Y" ), wxT( "0mil" ) ) );
423 }
424
425 for( size_t i = 1; i < std::numeric_limits<size_t>::max(); i++ )
426 {
427 const std::string texti = "TEXT" + std::to_string( i );
428 const std::string textix = texti + "X";
429 const std::string textiy = texti + "Y";
430
431 if( props.find( textix ) == props.end() || props.find( textiy ) == props.end() )
432 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
433
434 textPoint.emplace_back( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, textix, wxT( "0mil" ) ),
435 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, textiy, wxT( "0mil" ) ) );
436 }
437
438 wxString dimensionunit = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTDIMENSIONUNIT" ), wxT( "Millimeters" ) );
439
440 if( dimensionunit == wxT( "Inches" ) ) textunit = ALTIUM_UNIT::INCHES;
441 else if( dimensionunit == wxT( "Mils" ) ) textunit = ALTIUM_UNIT::MILS;
442 else if( dimensionunit == wxT( "Millimeters" ) ) textunit = ALTIUM_UNIT::MILLIMETERS;
443 else if( dimensionunit == wxT( "Centimeters" ) ) textunit = ALTIUM_UNIT::CENTIMETER;
444 else textunit = ALTIUM_UNIT::UNKNOWN;
445
446 if( aReader.HasParsingError() )
447 THROW_IO_ERROR( wxT( "Dimensions6 stream was not parsed correctly" ) );
448}
449
451{
452 std::map<wxString, wxString> properties = aReader.ReadProperties();
453
454 if( properties.empty() )
455 THROW_IO_ERROR( wxT( "Model stream has no properties!" ) );
456
457 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
458 id = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "ID" ), wxT( "" ) );
459 isEmbedded = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "EMBED" ), false );
460
461 rotation.x = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTX" ), 0. );
462 rotation.y = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTY" ), 0. );
463 rotation.z = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTZ" ), 0. );
464
465 z_offset = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "DZ" ), 0. );
466 checksum = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "CHECKSUM" ), 0 );
467
468 if( aReader.HasParsingError() )
469 THROW_IO_ERROR( wxT( "Model stream was not parsed correctly" ) );
470}
471
473{
474 std::map<wxString, wxString> properties = aReader.ReadProperties();
475
476 if( properties.empty() )
477 THROW_IO_ERROR( wxT( "Nets6 stream has no properties" ) );
478
479 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
480
481 if( aReader.HasParsingError() )
482 THROW_IO_ERROR( wxT( "Nets6 stream was not parsed correctly" ) );
483}
484
486{
487 std::map<wxString, wxString> properties = aReader.ReadProperties();
488
489 if( properties.empty() )
490 THROW_IO_ERROR( wxT( "Polygons6 stream has no properties" ) );
491
492 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "LAYER" ), wxT( "" ) ) );
493 net = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "NET" ), ALTIUM_NET_UNCONNECTED );
494 locked = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "LOCKED" ), false );
495
496 // TODO: kind
497
498 gridsize = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "GRIDSIZE" ), wxT( "0mil" ) );
499 trackwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "TRACKWIDTH" ), wxT( "0mil" ) );
500 minprimlength = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MINPRIMLENGTH" ), wxT( "0mil" ) );
501 useoctagons = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "USEOCTAGONS" ), false );
502
503 pourindex = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "POURINDEX" ), 0 );
504
505 wxString hatchstyleraw = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "HATCHSTYLE" ), wxT( "" ) );
506
507 if( hatchstyleraw == wxT( "Solid" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::SOLID;
508 else if( hatchstyleraw == wxT( "45Degree" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::DEGREE_45;
509 else if( hatchstyleraw == wxT( "90Degree" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::DEGREE_90;
510 else if( hatchstyleraw == wxT( "Horizontal" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::HORIZONTAL;
511 else if( hatchstyleraw == wxT( "Vertical" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::VERTICAL;
512 else if( hatchstyleraw == wxT( "None" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::NONE;
513 else hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::UNKNOWN;
514
515 altium_parse_polygons( properties, vertices );
516
517 if( aReader.HasParsingError() )
518 THROW_IO_ERROR( wxT( "Polygons6 stream was not parsed correctly" ) );
519}
520
522{
523 // Initialize all variables and make Coverity happy
524 minLimit = 0;
525 maxLimit = 0;
526 preferredWidth = 0;
529 clearanceGap = 0;
534 polygonconnectStyle = ALTIUM_CONNECT_STYLE::UNKNOWN;
535
536 aReader.Skip( 2 );
537
538 std::map<wxString, wxString> props = aReader.ReadProperties();
539
540 if( props.empty() )
541 THROW_IO_ERROR( wxT( "Rules6 stream has no props" ) );
542
543 name = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "NAME" ), wxT( "" ) );
544 priority = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "PRIORITY" ), 1 );
545
546 scope1expr = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SCOPE1EXPRESSION" ), wxT( "" ) );
547 scope2expr = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SCOPE2EXPRESSION" ), wxT( "" ) );
548
549 wxString rulekind = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "RULEKIND" ), wxT( "" ) );
550 if( rulekind == wxT( "Clearance" ) )
551 {
552 kind = ALTIUM_RULE_KIND::CLEARANCE;
553 clearanceGap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "GAP" ), wxT( "10mil" ) );
554 }
555 else if( rulekind == wxT( "DiffPairsRouting" ) )
556 {
557 kind = ALTIUM_RULE_KIND::DIFF_PAIR_ROUTINGS;
558 }
559 else if( rulekind == wxT( "Height" ) )
560 {
561 kind = ALTIUM_RULE_KIND::HEIGHT;
562 }
563 else if( rulekind == wxT( "HoleSize" ) )
564 {
565 kind = ALTIUM_RULE_KIND::HOLE_SIZE;
566 minLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINLIMIT" ), wxT( "1mil" ) );
567 maxLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXLIMIT" ), wxT( "150mil" ) );
568 }
569 else if( rulekind == wxT( "HoleToHoleClearance" ) )
570 {
571 kind = ALTIUM_RULE_KIND::HOLE_TO_HOLE_CLEARANCE;
572 clearanceGap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "GAP" ), wxT( "10mil" ) );
573 }
574 else if( rulekind == wxT( "RoutingVias" ) )
575 {
576 kind = ALTIUM_RULE_KIND::ROUTING_VIAS;
577 width = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "WIDTH" ), wxT( "20mil" ) );
578 minWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINWIDTH" ), wxT( "20mil" ) );
579 maxWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXWIDTH" ), wxT( "50mil" ) );
580 holeWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "HOLEWIDTH" ), wxT( "10mil" ) );
581 minHoleWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINHOLEWIDTH" ), wxT( "10mil" ) );
582 maxHoleWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXHOLEWIDTH" ), wxT( "28mil" ) );
583 }
584 else if( rulekind == wxT( "Width" ) )
585 {
586 kind = ALTIUM_RULE_KIND::WIDTH;
587 minLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINLIMIT" ), wxT( "6mil" ) );
588 maxLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXLIMIT" ), wxT( "40mil" ) );
589 preferredWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "PREFERREDWIDTH" ), wxT( "6mil" ) );
590}
591 else if( rulekind == wxT( "PasteMaskExpansion" ) )
592 {
593 kind = ALTIUM_RULE_KIND::PASTE_MASK_EXPANSION;
594 pastemaskExpansion = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "EXPANSION" ), wxT( "0" ) );
595 }
596 else if( rulekind == wxT( "SolderMaskExpansion" ) )
597 {
598 kind = ALTIUM_RULE_KIND::SOLDER_MASK_EXPANSION;
599 soldermaskExpansion = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "EXPANSION" ), wxT( "4mil" ) );
600 }
601 else if( rulekind == wxT( "PlaneClearance" ) )
602 {
603 kind = ALTIUM_RULE_KIND::PLANE_CLEARANCE;
604 planeclearanceClearance = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "CLEARANCE" ), wxT( "10mil" ) );
605 }
606 else if( rulekind == wxT( "PolygonConnect" ) )
607 {
608 kind = ALTIUM_RULE_KIND::POLYGON_CONNECT;
609 polygonconnectAirgapwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "AIRGAPWIDTH" ), wxT( "10mil" ) );
610 polygonconnectReliefconductorwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "RELIEFCONDUCTORWIDTH" ), wxT( "10mil" ) );
611 polygonconnectReliefentries = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "RELIEFENTRIES" ), 4 );
612
613 wxString style = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "CONNECTSTYLE" ), wxT( "" ) );
614
615 if( style == wxT( "Direct" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::DIRECT;
616 else if( style == wxT( "Relief" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::RELIEF;
617 else if( style == wxT( "NoConnect" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::NONE;
618 else polygonconnectStyle = ALTIUM_CONNECT_STYLE::UNKNOWN;
619 }
620 else
621 {
622 kind = ALTIUM_RULE_KIND::UNKNOWN;
623 }
624
625 if( aReader.HasParsingError() )
626 THROW_IO_ERROR( wxT( "Rules6 stream was not parsed correctly" ) );
627}
628
630{
631 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
632 if( recordtype != ALTIUM_RECORD::ARC )
633 {
634 THROW_IO_ERROR( wxT( "Arcs6 stream has invalid recordtype" ) );
635 }
636
637 // Subrecord 1
639
640 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
641
642 uint8_t flags1 = aReader.Read<uint8_t>();
643 is_locked = ( flags1 & 0x04 ) == 0;
644 is_polygonoutline = ( flags1 & 0x02 ) != 0;
645
646 uint8_t flags2 = aReader.Read<uint8_t>();
647 is_keepout = flags2 == 2;
648
649 net = aReader.Read<uint16_t>();
650 polygon = aReader.Read<uint16_t>();
651 component = aReader.Read<uint16_t>();
652 aReader.Skip( 4 );
653 center = aReader.ReadVector2IPos();
654 radius = aReader.ReadKicadUnit();
655 startangle = aReader.Read<double>();
656 endangle = aReader.Read<double>();
657 width = aReader.ReadKicadUnit();
658 subpolyindex = aReader.Read<uint16_t>();
659
660 if( aReader.GetRemainingSubrecordBytes() >= 10 )
661 {
662 aReader.Skip( 9 );
663 keepoutrestrictions = aReader.Read<uint8_t>();
664 }
665 else
666 {
667 keepoutrestrictions = is_keepout ? 0x1F : 0;
668 }
669
670 aReader.SkipSubrecord();
671
672 if( aReader.HasParsingError() )
673 {
674 THROW_IO_ERROR( wxT( "Arcs6 stream was not parsed correctly" ) );
675 }
676}
677
679{
680 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
681
682 if( recordtype != ALTIUM_RECORD::MODEL )
683 THROW_IO_ERROR( wxT( "ComponentsBodies6 stream has invalid recordtype" ) );
684
686
687 aReader.Skip( 7 );
688 component = aReader.Read<uint16_t>();
689 aReader.Skip( 9 );
690
691 std::map<wxString, wxString> properties = aReader.ReadProperties();
692
693 if( properties.empty() )
694 THROW_IO_ERROR( wxT( "ComponentsBodies6 stream has no properties" ) );
695
696 modelName = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "MODEL.NAME" ), wxT( "" ) );
697 modelId = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "MODELID" ), wxT( "" ) );
698 modelIsEmbedded = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "MODEL.EMBED" ), false );
699
700 modelPosition.x = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.2D.X" ), wxT( "0mil" ) );
701 modelPosition.y = -ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.2D.Y" ), wxT( "0mil" ) );
702 modelPosition.z = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.3D.DZ" ), wxT( "0mil" ) );
703
704 modelRotation.x = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTX" ), 0. );
705 modelRotation.y = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTY" ), 0. );
706 modelRotation.z = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTZ" ), 0. );
707
708 rotation = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.2D.ROTATION" ), 0. );
709
710 body_opacity_3d = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "BODYOPACITY3D" ), 1. );
711
712 aReader.SkipSubrecord();
713
714 if( aReader.HasParsingError() )
715 THROW_IO_ERROR( wxT( "Components6 stream was not parsed correctly" ) );
716}
717
719{
720 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
721
722 if( recordtype != ALTIUM_RECORD::PAD )
723 THROW_IO_ERROR( wxT( "Pads6 stream has invalid recordtype" ) );
724
725 // Subrecord 1
726 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
727
728 if( subrecord1 == 0 )
729 THROW_IO_ERROR( wxT( "Pads6 stream has no subrecord1 data" ) );
730
731 name = aReader.ReadWxString();
732
733 if( aReader.GetRemainingSubrecordBytes() != 0 )
734 THROW_IO_ERROR( wxT( "Pads6 stream has invalid subrecord1 length" ) );
735
736 aReader.SkipSubrecord();
737
738 // Subrecord 2
740 aReader.SkipSubrecord();
741
742 // Subrecord 3
744 aReader.SkipSubrecord();
745
746 // Subrecord 4
748 aReader.SkipSubrecord();
749
750 // Subrecord 5
751 size_t subrecord5 = aReader.ReadAndSetSubrecordLength();
752
753 ExpectSubrecordLengthAtLeast( "Pads6", "subrecord5", 110, subrecord5 );
754
755 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
756 tolayer = ALTIUM_LAYER::UNKNOWN;
757 fromlayer = ALTIUM_LAYER::UNKNOWN;
758
759 uint8_t flags1 = aReader.Read<uint8_t>();
760 is_test_fab_top = ( flags1 & 0x80 ) != 0;
761 is_tent_bottom = ( flags1 & 0x40 ) != 0;
762 is_tent_top = ( flags1 & 0x20 ) != 0;
763 is_locked = ( flags1 & 0x04 ) == 0;
764
765 uint8_t flags2 = aReader.Read<uint8_t>();
766 is_test_fab_bottom = ( flags2 & 0x01 ) != 0;
767
768 net = aReader.Read<uint16_t>();
769 aReader.Skip( 2 );
770 component = aReader.Read<uint16_t>();
771 aReader.Skip( 4 ); // to 13
772
773 position = aReader.ReadVector2IPos();
774 topsize = aReader.ReadVector2ISize();
775 midsize = aReader.ReadVector2ISize();
776 botsize = aReader.ReadVector2ISize();
777 holesize = aReader.ReadKicadUnit(); // to 49
778
779 topshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
780 midshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
781 botshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
782
783 direction = aReader.Read<double>();
784 plated = aReader.Read<uint8_t>() != 0;
785 aReader.Skip( 1 );
786 padmode = static_cast<ALTIUM_PAD_MODE>( aReader.Read<uint8_t>() );
787 aReader.Skip( 23 );
790 aReader.Skip( 7 );
791 pastemaskexpansionmode = static_cast<ALTIUM_MODE>( aReader.Read<uint8_t>() );
792 soldermaskexpansionmode = static_cast<ALTIUM_MODE>( aReader.Read<uint8_t>() );
793 aReader.Skip( 3 ); // to 106
794
795 if( subrecord5 == 110 )
796 {
797 // Don't know exactly what this is, but it's always been 0 in the files with
798 // 110-byte subrecord5.
799 // e.g. https://gitlab.com/kicad/code/kicad/-/issues/16514
800 const uint32_t unknown = aReader.ReadKicadUnit(); // to 110
801
802 if( unknown != 0 )
803 {
804 THROW_IO_ERROR( wxString::Format( "Pads6 stream subrecord5 + 106 has value %d, "
805 "which is unexpected",
806 unknown ) );
807 }
808 holerotation = 0;
809 }
810 else
811 {
812 // More than 110, need at least 114
813 ExpectSubrecordLengthAtLeast( "Pads6", "subrecord5", 114, subrecord5 );
814 holerotation = aReader.Read<double>(); // to 114
815 }
816
817 if( subrecord5 >= 120 )
818 {
819 tolayer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
820 aReader.Skip( 2 );
821 fromlayer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
822 //aReader.skip( 2 );
823 }
824 else if( subrecord5 == 171 )
825 {
826 }
827
828 aReader.SkipSubrecord();
829
830 // Subrecord 6
831 size_t subrecord6 = aReader.ReadAndSetSubrecordLength();
832 // Known lengths: 596, 628, 651
833 // 596 is the number of bytes read in this code-block
834 if( subrecord6 >= 596 )
835 { // TODO: detect type from something else than the size?
836 sizeAndShape = std::make_unique<APAD6_SIZE_AND_SHAPE>();
837
838 for( wxSize& size : sizeAndShape->inner_size )
839 size.x = aReader.ReadKicadUnitX();
840
841 for( wxSize& size : sizeAndShape->inner_size )
842 size.y = aReader.ReadKicadUnitY();
843
844 for( ALTIUM_PAD_SHAPE& shape : sizeAndShape->inner_shape )
845 shape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
846
847 aReader.Skip( 1 );
848
849 sizeAndShape->holeshape = static_cast<ALTIUM_PAD_HOLE_SHAPE>( aReader.Read<uint8_t>() );
850 sizeAndShape->slotsize = aReader.ReadKicadUnit();
851 sizeAndShape->slotrotation = aReader.Read<double>();
852
853 for( VECTOR2I& pt : sizeAndShape->holeoffset )
854 pt.x = aReader.ReadKicadUnitX();
855
856 for( VECTOR2I& pt : sizeAndShape->holeoffset )
857 pt.y = aReader.ReadKicadUnitY();
858
859 aReader.Skip( 1 );
860
861 for( ALTIUM_PAD_SHAPE_ALT& shape : sizeAndShape->alt_shape )
862 shape = static_cast<ALTIUM_PAD_SHAPE_ALT>( aReader.Read<uint8_t>() );
863
864 for( uint8_t& radius : sizeAndShape->cornerradius )
865 radius = aReader.Read<uint8_t>();
866 }
867 else if( subrecord6 != 0 )
868 {
869 wxLogError( _( "Pads6 stream has unexpected length for subrecord 6: %d." ), subrecord6 );
870 }
871
872 aReader.SkipSubrecord();
873
874 if( aReader.HasParsingError() )
875 THROW_IO_ERROR( wxT( "Pads6 stream was not parsed correctly" ) );
876}
877
879{
880 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
881
882 if( recordtype != ALTIUM_RECORD::VIA )
883 THROW_IO_ERROR( wxT( "Vias6 stream has invalid recordtype" ) );
884
885 // Subrecord 1
886 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
887
888 aReader.Skip( 1 );
889 uint8_t flags1 = aReader.Read<uint8_t>();
890 is_test_fab_top = ( flags1 & 0x80 ) != 0;
891 is_tent_bottom = ( flags1 & 0x40 ) != 0;
892 is_tent_top = ( flags1 & 0x20 ) != 0;
893 is_locked = ( flags1 & 0x04 ) == 0;
894
895 uint8_t flags2 = aReader.Read<uint8_t>();
896 is_test_fab_bottom = ( flags2 & 0x01 ) != 0;
897
898 net = aReader.Read<uint16_t>();
899 aReader.Skip( 8 );
900 position = aReader.ReadVector2IPos();
901 diameter = aReader.ReadKicadUnit();
902 holesize = aReader.ReadKicadUnit();
903
904 layer_start = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
905 layer_end = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
906
907 if( subrecord1 <= 74 )
908 {
909 viamode = ALTIUM_PAD_MODE::SIMPLE;
910 }
911 else
912 {
913 uint8_t temp_byte = aReader.Read<uint8_t>(); // Unknown.
914
916 thermal_relief_conductorcount = aReader.Read<uint8_t>();
917 aReader.Skip( 1 ); // Unknown.
918
920
921 aReader.ReadKicadUnit(); // Unknown. 20mil?
922 aReader.ReadKicadUnit(); // Unknown. 20mil?
923
924 aReader.Skip( 4 );
926 aReader.Skip( 8 );
927
928 temp_byte = aReader.Read<uint8_t>();
929 soldermask_expansion_manual = temp_byte & 0x02;
930
931 aReader.Skip( 7 );
932
933 viamode = static_cast<ALTIUM_PAD_MODE>( aReader.Read<uint8_t>() );
934
935 for( int ii = 0; ii < 32; ++ii )
936 {
937 diameter_by_layer[ii] = aReader.ReadKicadUnit();
938 }
939 }
940
941 if( subrecord1 >= 246 )
942 {
943 aReader.Skip( 38 );
944 soldermask_expansion_linked = aReader.Read<uint8_t>() & 0x01;
946 }
947
948 if( subrecord1 >= 307 )
949 {
950 aReader.Skip( 45 );
951
952 pos_tolerance = aReader.ReadKicadUnit();
953 neg_tolerance = aReader.ReadKicadUnit();
954 }
955
956 aReader.SkipSubrecord();
957
958 if( aReader.HasParsingError() )
959 THROW_IO_ERROR( wxT( "Vias6 stream was not parsed correctly" ) );
960}
961
963{
964 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
965
966 if( recordtype != ALTIUM_RECORD::TRACK )
967 THROW_IO_ERROR( wxT( "Tracks6 stream has invalid recordtype" ) );
968
969 // Subrecord 1
971
972 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
973
974 uint8_t flags1 = aReader.Read<uint8_t>();
975 is_locked = ( flags1 & 0x04 ) == 0;
976 is_polygonoutline = ( flags1 & 0x02 ) != 0;
977
978 uint8_t flags2 = aReader.Read<uint8_t>();
979 is_keepout = flags2 == 2;
980
981 net = aReader.Read<uint16_t>();
982 polygon = aReader.Read<uint16_t>();
983 component = aReader.Read<uint16_t>();
984 aReader.Skip( 4 );
985 start = aReader.ReadVector2IPos();
986 end = aReader.ReadVector2IPos();
987 width = aReader.ReadKicadUnit();
988 subpolyindex = aReader.Read<uint16_t>();
989
990 if( aReader.GetRemainingSubrecordBytes() >= 11 )
991 {
992 aReader.Skip( 10 );
993 keepoutrestrictions = aReader.Read<uint8_t>();
994 }
995 else
996 {
997 keepoutrestrictions = is_keepout ? 0x1F : 0;
998 }
999
1000 aReader.SkipSubrecord();
1001
1002 if( aReader.HasParsingError() )
1003 THROW_IO_ERROR( wxT( "Tracks6 stream was not parsed correctly" ) );
1004}
1005
1006ATEXT6::ATEXT6( ALTIUM_BINARY_PARSER& aReader, std::map<uint32_t, wxString>& aStringTable )
1007{
1008 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
1009
1010 if( recordtype != ALTIUM_RECORD::TEXT )
1011 THROW_IO_ERROR( wxT( "Texts6 stream has invalid recordtype" ) );
1012
1013 // Subrecord 1 - Properties
1014 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
1015
1016 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1017 aReader.Skip( 6 );
1018 component = aReader.Read<uint16_t>();
1019 aReader.Skip( 4 );
1020 position = aReader.ReadVector2IPos();
1021 height = aReader.ReadKicadUnit();
1022 strokefonttype = static_cast<STROKE_FONT_TYPE>( aReader.Read<uint16_t>() );
1023 // TODO: The Serif font type doesn't match well with KiCad, we should replace it with a better match
1024
1025 rotation = aReader.Read<double>();
1026 isMirrored = aReader.Read<uint8_t>() != 0;
1027 strokewidth = aReader.ReadKicadUnit();
1028
1029 if( subrecord1 < 123 )
1030 {
1031 fonttype = ALTIUM_TEXT_TYPE::STROKE;
1032 aReader.SkipSubrecord();
1033 return;
1034 }
1035
1036 isComment = aReader.Read<uint8_t>() != 0;
1037 isDesignator = aReader.Read<uint8_t>() != 0;
1038 aReader.Skip( 1 );
1039 fonttype = static_cast<ALTIUM_TEXT_TYPE>( aReader.Read<uint8_t>() );
1040 isBold = aReader.Read<uint8_t>() != 0;
1041 isItalic = aReader.Read<uint8_t>() != 0;
1042
1043 char fontData[64] = { 0 };
1044 aReader.ReadBytes( fontData, sizeof( fontData ) );
1045 fontname = wxString( fontData, wxMBConvUTF16LE(), sizeof( fontData ) ).BeforeFirst( '\0' );
1046
1047 char tmpbyte = aReader.Read<uint8_t>();
1048 isInverted = !!tmpbyte;
1049 margin_border_width = aReader.ReadKicadUnit(); // "Margin Border"
1050 widestring_index = aReader.Read<uint32_t>();
1051 aReader.Skip( 4 );
1052
1053 // An inverted rect in Altium is like a text box with the text inverted.
1054 isInvertedRect = aReader.Read<uint8_t>() != 0;
1055
1058 textbox_rect_justification = static_cast<ALTIUM_TEXT_POSITION>( aReader.Read<uint8_t>() );
1059 text_offset_width = aReader.ReadKicadUnit(); // "Text Offset"
1060
1061 int remaining = aReader.GetRemainingSubrecordBytes();
1062
1063 if( remaining >= 103 )
1064 {
1065 aReader.Skip( 24 ); // Unknown data
1066 aReader.Skip( 64 ); // 2nd font name
1067 aReader.Skip( 5 ); // Unknown flags
1068
1069 // "Frame" text type flag
1070 isFrame = aReader.Read<uint8_t>() != 0;
1071
1072 // Use "Offset" border value instead of "Margin"
1073 isOffsetBorder = aReader.Read<uint8_t>() != 0;
1074
1075 aReader.Skip( 8 ); // Unknown data
1076 }
1077 else
1078 {
1080 isOffsetBorder = false;
1081 }
1082
1083 if( remaining >= 115 )
1084 {
1085 // textbox_rect_justification will be wrong (5) when this flag is unset,
1086 // in that case, we should always use the left bottom justification.
1087 isJustificationValid = aReader.Read<uint8_t>() != 0;
1088
1089 aReader.Skip( 3 ); // Unknown data
1090 aReader.Skip( 8 ); // Unknown data
1091 }
1092 else
1093 {
1094 isJustificationValid = false;
1095 }
1096
1097 aReader.SkipSubrecord();
1098
1099 // Subrecord 2 - Legacy 8bit string, max 255 chars, unknown codepage
1100 aReader.ReadAndSetSubrecordLength();
1101
1102 auto entry = aStringTable.find( widestring_index );
1103
1104 if( entry != aStringTable.end() )
1105 text = entry->second;
1106 else
1107 text = aReader.ReadWxString();
1108
1109 // Normalize Windows line endings
1110 text.Replace( wxT( "\r\n" ), wxT( "\n" ) );
1111
1112 aReader.SkipSubrecord();
1113
1114 // Altium only supports inverting truetype fonts
1115 if( fonttype != ALTIUM_TEXT_TYPE::TRUETYPE )
1116 {
1117 isInverted = false;
1118 isInvertedRect = false;
1119 }
1120
1121 if( aReader.HasParsingError() )
1122 THROW_IO_ERROR( wxT( "Texts6 stream was not parsed correctly" ) );
1123}
1124
1126{
1127 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
1128
1129 if( recordtype != ALTIUM_RECORD::FILL )
1130 THROW_IO_ERROR( wxT( "Fills6 stream has invalid recordtype" ) );
1131
1132 // Subrecord 1
1133 aReader.ReadAndSetSubrecordLength();
1134
1135 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1136
1137 uint8_t flags1 = aReader.Read<uint8_t>();
1138 is_locked = ( flags1 & 0x04 ) == 0;
1139
1140 uint8_t flags2 = aReader.Read<uint8_t>();
1141 is_keepout = flags2 == 2;
1142
1143 net = aReader.Read<uint16_t>();
1144 aReader.Skip( 2 );
1145 component = aReader.Read<uint16_t>();
1146 aReader.Skip( 4 );
1147 pos1 = aReader.ReadVector2IPos();
1148 pos2 = aReader.ReadVector2IPos();
1149 rotation = aReader.Read<double>();
1150
1151 if( aReader.GetRemainingSubrecordBytes() >= 10 )
1152 {
1153 aReader.Skip( 9 );
1154 keepoutrestrictions = aReader.Read<uint8_t>();
1155 }
1156 else
1157 {
1158 keepoutrestrictions = is_keepout ? 0x1F : 0;
1159 }
1160
1161 aReader.SkipSubrecord();
1162
1163 if( aReader.HasParsingError() )
1164 THROW_IO_ERROR( wxT( "Fills6 stream was not parsed correctly" ) );
1165}
1166
1167AREGION6::AREGION6( ALTIUM_BINARY_PARSER& aReader, bool aExtendedVertices )
1168{
1169 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
1170
1171 if( recordtype != ALTIUM_RECORD::REGION )
1172 THROW_IO_ERROR( wxT( "Regions6 stream has invalid recordtype" ) );
1173
1174 // Subrecord 1
1175 aReader.ReadAndSetSubrecordLength();
1176
1177 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1178
1179 uint8_t flags1 = aReader.Read<uint8_t>();
1180 is_locked = ( flags1 & 0x04 ) == 0;
1181
1182 uint8_t flags2 = aReader.Read<uint8_t>();
1183 is_keepout = flags2 == 2;
1184
1185 net = aReader.Read<uint16_t>();
1186 polygon = aReader.Read<uint16_t>();
1187 component = aReader.Read<uint16_t>();
1188 aReader.Skip( 5 );
1189 holecount = aReader.Read<uint16_t>();
1190 aReader.Skip( 2 );
1191
1192 std::map<wxString, wxString> properties = aReader.ReadProperties();
1193
1194 if( properties.empty() )
1195 THROW_IO_ERROR( wxT( "Regions6 stream has empty properties" ) );
1196
1197 int pkind = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KIND" ), 0 );
1198 bool is_cutout = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "ISBOARDCUTOUT" ), false );
1199
1200 is_shapebased = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "ISSHAPEBASED" ), false );
1201 keepoutrestrictions = static_cast<uint8_t>(
1202 ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KEEPOUTRESTRIC" ), 0x1F ) );
1203
1204 // TODO: this can differ from the other subpolyindex?!
1205 // Note: "the other subpolyindex" is "polygon"
1206 subpolyindex = static_cast<uint16_t>(
1207 ALTIUM_PROPS_UTILS::ReadInt( properties, "SUBPOLYINDEX", ALTIUM_POLYGON_NONE ) );
1208
1209 switch( pkind )
1210 {
1211 case 0:
1212 if( is_cutout )
1213 {
1214 kind = ALTIUM_REGION_KIND::BOARD_CUTOUT;
1215 }
1216 else
1217 {
1218 kind = ALTIUM_REGION_KIND::COPPER;
1219 }
1220 break;
1221 case 1:
1222 kind = ALTIUM_REGION_KIND::POLYGON_CUTOUT;
1223 break;
1224 case 2:
1225 kind = ALTIUM_REGION_KIND::DASHED_OUTLINE;
1226 break;
1227 case 3:
1228 kind = ALTIUM_REGION_KIND::UNKNOWN_3; // TODO: what kind is this?
1229 break;
1230 case 4:
1231 kind = ALTIUM_REGION_KIND::CAVITY_DEFINITION;
1232 break;
1233 default:
1234 kind = ALTIUM_REGION_KIND::UNKNOWN;
1235 break;
1236 }
1237
1238 uint32_t num_outline_vertices = aReader.Read<uint32_t>();
1239
1240 if( aExtendedVertices )
1241 num_outline_vertices++; // Has a closing vertex
1242
1243 for( uint32_t i = 0; i < num_outline_vertices; i++ )
1244 {
1245 if( aExtendedVertices )
1246 {
1247 bool isRound = aReader.Read<uint8_t>() != 0;
1248 VECTOR2I position = aReader.ReadVector2IPos();
1249 VECTOR2I center = aReader.ReadVector2IPos();
1250 int32_t radius = aReader.ReadKicadUnit();
1251 double angle1 = aReader.Read<double>();
1252 double angle2 = aReader.Read<double>();
1253 outline.emplace_back( isRound, radius, angle1, angle2, position, center );
1254 }
1255 else
1256 {
1257 // For some regions the coordinates are stored as double and not as int32_t
1258 int32_t x = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( aReader.Read<double>() );
1259 int32_t y = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( -aReader.Read<double>() );
1260 outline.emplace_back( VECTOR2I( x, y ) );
1261 }
1262 }
1263
1264 holes.resize( holecount );
1265 for( uint16_t k = 0; k < holecount; k++ )
1266 {
1267 uint32_t num_hole_vertices = aReader.Read<uint32_t>();
1268 holes.at( k ).reserve( num_hole_vertices );
1269
1270 for( uint32_t i = 0; i < num_hole_vertices; i++ )
1271 {
1272 int32_t x = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( aReader.Read<double>() );
1273 int32_t y = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( -aReader.Read<double>() );
1274 holes.at( k ).emplace_back( VECTOR2I( x, y ) );
1275 }
1276 }
1277
1278 aReader.SkipSubrecord();
1279
1280 if( aReader.HasParsingError() )
1281 THROW_IO_ERROR( wxT( "Regions6 stream was not parsed correctly" ) );
1282}
void altium_parse_polygons(std::map< wxString, wxString > &aProps, std::vector< ALTIUM_VERTICE > &aVertices)
static void ExpectSubrecordLengthAtLeast(const std::string &aStreamType, const std::string &aSubrecordName, size_t aExpectedLength, size_t aActualLength)
Throw an IO_ERROR if the actual length is less than the expected length.
ALTIUM_LAYER altium_layer_from_name(const wxString &aName)
static AEXTENDED_PRIMITIVE_INFORMATION_TYPE ReadAltiumExtendedPrimitiveInformationTypeFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
static ALTIUM_MODE ReadAltiumModeFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
static ALTIUM_RECORD ReadAltiumRecordFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
ALTIUM_PAD_SHAPE_ALT
ALTIUM_TEXT_POSITION
ALTIUM_PAD_MODE
ALTIUM_TEXT_TYPE
ALTIUM_PAD_SHAPE
ALTIUM_DIMENSION_KIND
ALTIUM_PAD_HOLE_SHAPE
const uint16_t ALTIUM_NET_UNCONNECTED
ALTIUM_CLASS_KIND
ALTIUM_MODE
const uint16_t ALTIUM_POLYGON_NONE
ALTIUM_LAYER
AEXTENDED_PRIMITIVE_INFORMATION_TYPE
ALTIUM_RECORD
void Skip(size_t aLength)
size_t GetRemainingSubrecordBytes() const
std::map< wxString, wxString > ReadProperties(std::function< std::map< wxString, wxString >(const std::string &)> handleBinaryData=[](const std::string &) { return std::map< wxString, wxString >();})
int ReadBytes(char *aOut, size_t aSize)
static int ReadInt(const std::map< wxString, wxString > &aProps, const wxString &aKey, int aDefault)
static int32_t ReadKicadUnit(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static bool ReadBool(const std::map< wxString, wxString > &aProps, const wxString &aKey, bool aDefault)
static wxString ReadUnicodeString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static wxString ReadString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static double ReadDouble(const std::map< wxString, wxString > &aProps, const wxString &aKey, double aDefault)
static int32_t ConvertToKicadUnit(const double aValue)
T y
Definition: vector3.h:64
T z
Definition: vector3.h:65
T x
Definition: vector3.h:63
#define _(s)
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
double startangle
uint16_t component
bool is_keepout
uint32_t width
ALTIUM_LAYER layer
AARC6(ALTIUM_BINARY_PARSER &aReader)
uint8_t keepoutrestrictions
uint16_t polygon
VECTOR2I center
uint32_t radius
uint16_t net
bool is_locked
bool is_polygonoutline
double endangle
uint16_t subpolyindex
VECTOR2I sheetpos
std::set< wxString > layerNames
wxSize sheetsize
ABOARD6(ALTIUM_BINARY_PARSER &aReader)
std::vector< ABOARD6_LAYER_STACKUP > stackup
std::vector< ALTIUM_VERTICE > board_vertices
wxString uniqueid
std::vector< wxString > names
ALTIUM_CLASS_KIND kind
wxString name
ACLASS6(ALTIUM_BINARY_PARSER &aReader)
ALTIUM_TEXT_POSITION commentautoposition
ALTIUM_TEXT_POSITION nameautoposition
ACOMPONENT6(ALTIUM_BINARY_PARSER &aReader)
wxString sourcefootprintlibrary
ALTIUM_LAYER layer
wxString sourcelibreference
wxString sourcedesignator
wxString sourcecomponentlibrary
ACOMPONENTBODY6(ALTIUM_BINARY_PARSER &aReader)
int32_t textprecision
ALTIUM_UNIT textunit
wxString textsuffix
uint32_t textlinewidth
wxString textformat
ALTIUM_LAYER layer
std::vector< VECTOR2I > textPoint
wxString textprefix
uint32_t linewidth
ALTIUM_DIMENSION_KIND kind
uint32_t textheight
ADIMENSION6(ALTIUM_BINARY_PARSER &aReader)
std::vector< VECTOR2I > referencePoint
AEXTENDED_PRIMITIVE_INFORMATION_TYPE type
AEXTENDED_PRIMITIVE_INFORMATION(ALTIUM_BINARY_PARSER &aReader)
VECTOR2I pos2
ALTIUM_LAYER layer
uint16_t net
VECTOR2I pos1
double rotation
uint8_t keepoutrestrictions
AFILL6(ALTIUM_BINARY_PARSER &aReader)
uint16_t component
double z_offset
int32_t checksum
wxString name
VECTOR3D rotation
AMODEL(ALTIUM_BINARY_PARSER &aReader)
ANET6(ALTIUM_BINARY_PARSER &aReader)
wxString name
double holerotation
int32_t soldermaskexpansionmanual
uint16_t net
ALTIUM_LAYER layer
APAD6(ALTIUM_BINARY_PARSER &aReader)
std::unique_ptr< APAD6_SIZE_AND_SHAPE > sizeAndShape
ALTIUM_LAYER tolayer
ALTIUM_PAD_SHAPE topshape
ALTIUM_PAD_MODE padmode
ALTIUM_MODE pastemaskexpansionmode
uint32_t holesize
double direction
ALTIUM_MODE soldermaskexpansionmode
wxString name
bool is_test_fab_bottom
bool is_tent_bottom
VECTOR2I botsize
ALTIUM_PAD_SHAPE botshape
uint16_t component
VECTOR2I midsize
ALTIUM_PAD_SHAPE midshape
int32_t pastemaskexpansionmanual
bool is_tent_top
ALTIUM_LAYER fromlayer
VECTOR2I position
bool is_locked
VECTOR2I topsize
bool is_test_fab_top
int32_t minprimlength
std::vector< ALTIUM_VERTICE > vertices
APOLYGON6(ALTIUM_BINARY_PARSER &aReader)
ALTIUM_POLYGON_HATCHSTYLE hatchstyle
int32_t pourindex
int32_t trackwidth
ALTIUM_LAYER layer
int32_t gridsize
uint8_t keepoutrestrictions
ALTIUM_LAYER layer
AREGION6(ALTIUM_BINARY_PARSER &aReader, bool aExtendedVertices)
uint16_t holecount
std::vector< ALTIUM_VERTICE > outline
uint16_t subpolyindex
std::vector< std::vector< ALTIUM_VERTICE > > holes
uint16_t component
uint16_t net
uint16_t polygon
ALTIUM_REGION_KIND kind
ALTIUM_RULE_KIND kind
ALTIUM_CONNECT_STYLE polygonconnectStyle
wxString scope1expr
int preferredWidth
wxString name
int planeclearanceClearance
int32_t polygonconnectReliefconductorwidth
int pastemaskExpansion
wxString scope2expr
int soldermaskExpansion
ARULE6(ALTIUM_BINARY_PARSER &aReader)
int32_t polygonconnectAirgapwidth
int polygonconnectReliefentries
uint32_t text_offset_width
uint32_t textbox_rect_height
uint16_t component
ALTIUM_TEXT_POSITION textbox_rect_justification
bool isInvertedRect
wxString text
uint32_t widestring_index
uint32_t textbox_rect_width
double rotation
uint32_t margin_border_width
uint32_t height
wxString fontname
bool isJustificationValid
ALTIUM_LAYER layer
VECTOR2I position
ALTIUM_TEXT_TYPE fonttype
STROKE_FONT_TYPE strokefonttype
bool isDesignator
bool isOffsetBorder
ATEXT6(ALTIUM_BINARY_PARSER &aReader, std::map< uint32_t, wxString > &aStringTable)
uint32_t strokewidth
VECTOR2I end
ATRACK6(ALTIUM_BINARY_PARSER &aReader)
uint32_t width
bool is_polygonoutline
uint16_t net
uint16_t polygon
uint16_t subpolyindex
uint8_t keepoutrestrictions
VECTOR2I start
ALTIUM_LAYER layer
uint16_t component
bool soldermask_expansion_linked
uint32_t thermal_relief_conductorcount
uint32_t diameter
uint32_t neg_tolerance
uint16_t net
VECTOR2I position
int32_t thermal_relief_airgap
bool is_locked
bool is_tent_top
bool is_test_fab_top
int32_t soldermask_expansion_front
uint32_t pos_tolerance
bool is_tent_bottom
bool is_test_fab_bottom
bool soldermask_expansion_manual
ALTIUM_PAD_MODE viamode
AVIA6(ALTIUM_BINARY_PARSER &aReader)
uint32_t thermal_relief_conductorwidth
int32_t soldermask_expansion_back
uint32_t diameter_by_layer[32]
ALTIUM_LAYER layer_start
ALTIUM_LAYER layer_end
uint32_t holesize
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:691