sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Layer;
51  class BIMRelationship;
53  class BIMType;
54  class Sheet;
56  class TranslationNotifier;
57  class TranslationOptionsKit;
58 #if !defined(TARGET_OS_ANDROID)
60 #endif
61  class ReloadNotifier;
62 
63  typedef std::vector<Component, HPS::Allocator<Component>> ComponentArray;
64  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
65  typedef std::vector<Layer, HPS::Allocator<Layer>> LayerArray;
66  typedef std::vector<BIMRelationship, HPS::Allocator<BIMRelationship>> BIMRelationshipArray;
67  typedef std::vector<BIMRelationshipEntity, HPS::Allocator<BIMRelationshipEntity>> BIMRelationshipEntityArray;
68  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
69  typedef HPS::IntArray ParasolidEntityArray;
70  typedef std::vector<BIMType, HPS::Allocator<BIMType>> BIMTypeArray;
71 
74  enum class Units
75  {
76  Unknown,
77  Point,
78  Inch,
79  Millimeter,
80  Centimeter,
81  Pica,
82  Foot,
83  Yard,
84  Meter,
85  Kilometer,
86  Mile
87  };
88 
91  enum class UnloadMode
92  {
95  ExchangeAndVisualization,
96 
101  ExchangeOnly,
102  };
103 
106  enum class LoadStatus
107  {
109  Unknown,
111  Loaded,
113  VisualizationOnly,
115  PartiallyLoaded,
117  NotLoaded
118  };
119 
123  enum class BIMRelationshipType : uint32_t
124  {
125  ContainedInSpatialStructure = 0,
126  Aggregates,
127  VoidsElement,
128  FillsElement,
129  SpaceBoundary,
130  ConnectsPathElements,
131  };
132 
135  class EXCHANGE_API Component : public HPS::Component
136  {
137  public:
139  Component();
140 
144  Component(HPS::Component const & in_that);
145 
148  Component(Exchange::Component const & in_that);
149 
152  Component(Exchange::Component && in_that);
153 
154  virtual ~Component();
155 
156  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
157  HPS::Type ObjectType() const { return staticType; }
158 
159 #if !defined(_MSC_VER) || _MSC_VER >= 1900
160  Component & operator=(Component const & in_that) = default;
161 #endif
162 
166  Component & operator=(Exchange::Component && in_that);
167 
168 
171  A3DEntity * GetExchangeEntity() const;
172 
173 
179  void Tessellate(TessellationOptionsKit const & in_options);
180 
187  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
188 
195  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
196 
201  bool SetTransform(MatrixKit const & in_transform);
202 
207  bool AddTransform(MatrixKit const & in_transform);
208 
217  HPS::Component CopyTo(HPS::Component const & in_new_owner);
218 
222  bool SetName(char const * in_new_name);
223  };
224 
225  class EXCHANGE_API ProductOccurrence : public Exchange::Component
226  {
227  public:
230 
234  ProductOccurrence(HPS::Component const & in_that);
235 
239  ProductOccurrence(Component const & in_that);
240 
243  ProductOccurrence(ProductOccurrence const & in_sheet);
244 
249 
253  ProductOccurrence & operator=(ProductOccurrence && in_that);
254 
255  virtual ~ProductOccurrence();
256 
257  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
258  HPS::Type ObjectType() const { return staticType; }
259 
263  bool Equals(ProductOccurrence const & in_kit) const;
264 
268  bool operator==(ProductOccurrence const & in_kit) const;
269 
273  bool operator!=(ProductOccurrence const & in_kit) const;
274 
280  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
281 
287  LoadStatus GetLoadStatus() const;
288 
292  bool IsExternalData() const;
293 
296  LayerArray GetLayers() const;
297  };
298 
302  class EXCHANGE_API BIMRelationshipEntity : public HPS::Sprocket
303  {
304  public:
305  static const HPS::Type staticType = HPS::Type::ExchangeBIMRelationshipEntity;
306  HPS::Type ObjectType() const { return staticType; }
307 
310 
314 
319 
323  BIMRelationshipEntity & operator=(BIMRelationshipEntity const& in_that);
324 
328  BIMRelationshipEntity & operator=(BIMRelationshipEntity && in_that);
329 
333  bool Equals(BIMRelationshipEntity const & in_relationshipEntity) const;
334 
338  bool operator==(BIMRelationshipEntity const & in_relationshipEntity) const;
339 
343  bool operator!=(BIMRelationshipEntity const & in_relationshipEntity) const;
344 
345  virtual ~BIMRelationshipEntity();
346 
350  HPS::UTF8 GetName(bool use_generated_if_needed = false) const;
351 
354  HPS::Exchange::Component const& GetComponent() const;
355  };
356 
360  class EXCHANGE_API BIMRelationship : public HPS::Sprocket
361  {
362  public:
363  static const HPS::Type staticType = HPS::Type::ExchangeBIMRelationship;
364  HPS::Type ObjectType() const { return staticType; }
365 
367  BIMRelationship();
368 
371  BIMRelationship(BIMRelationship const & in_relationship);
372 
376  BIMRelationship(BIMRelationship && in_relationship);
377 
381  BIMRelationship & operator=(BIMRelationship && in_relationship);
382 
386  bool Equals(BIMRelationship const & in_relationship) const;
387 
391  bool operator==(BIMRelationship const & in_relationship) const;
392 
396  bool operator!=(BIMRelationship const & in_relationship) const;
397 
398  virtual ~BIMRelationship();
399 
402  BIMRelationshipType GetType() const;
403 
406  BIMRelationshipEntity GetRelatingEntity() const;
407 
410  BIMRelationshipEntityArray GetRelatedEntities() const;
411  };
412 
416  class EXCHANGE_API BIMType : public HPS::Sprocket
417  {
418  public:
419  static const HPS::Type staticType = HPS::Type::ExchangeBIMType;
420  HPS::Type ObjectType() const { return staticType; }
421 
423  BIMType();
424 
427  BIMType(BIMType const & in_bim_type);
428 
432  BIMType(BIMType && in_bim_type);
433 
437  BIMType & operator=(BIMType const& in_bim_type);
438 
442  BIMType & operator=(BIMType && in_bim_type);
443 
447  bool Equals(BIMType const & in_bim_type) const;
448 
452  bool operator==(BIMType const & in_bim_type) const;
453 
457  bool operator!=(BIMType const & in_bim_type) const;
458 
459  virtual ~BIMType();
460 
463  HPS::UTF8 GetName() const;
464 
467  ComponentArray GetComponents() const;
468  };
469 
473  class EXCHANGE_API BIMData : public HPS::Sprocket
474  {
475  public:
476  static const HPS::Type staticType = HPS::Type::ExchangeBIMData;
477  HPS::Type ObjectType() const { return staticType; }
478 
480  BIMData();
481 
484  BIMData(BIMData const & in_bim_data);
485 
489  BIMData(BIMData && in_bim_data);
490 
494  BIMData & operator=(BIMData const& in_that);
495 
499  BIMData & operator=(BIMData && in_bim_data);
500 
504  bool Equals(BIMData const & in_bim_data) const;
505 
509  bool operator==(BIMData const & in_bim_data) const;
510 
514  bool operator!=(BIMData const & in_bim_data) const;
515 
516  virtual ~BIMData();
517 
521  BIMRelationshipArray GetRelationships(HPS::Exchange::Component const& in_component) const;
522 
527  BIMRelationshipEntityArray GetRelatingEntities(HPS::Exchange::Component const & in_component, BIMRelationshipType in_relationship_type) const;
528 
533  BIMRelationshipEntityArray GetRelatedEntities(HPS::Exchange::Component const & in_component, BIMRelationshipType in_relationship_type) const;
534 
537  BIMTypeArray GetTypes() const;
538  };
539 
541  class EXCHANGE_API Sheet : public Exchange::Component
542  {
543  public:
545  Sheet();
546 
550  Sheet(HPS::Component const & in_that);
551 
555  Sheet(Component const & in_that);
556 
559  Sheet(Sheet const & in_sheet);
560 
564  Sheet(Sheet && in_that);
565 
569  Sheet & operator=(Sheet && in_that);
570 
571  virtual ~Sheet();
572 
573  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
574  HPS::Type ObjectType() const { return staticType; }
575 
579  bool Equals(Sheet const & in_kit) const;
580 
581 #if !defined(_MSC_VER) || _MSC_VER >= 1900
582  Sheet & operator=(Sheet const & in_that) = default;
583 #endif
584 
588  bool operator==(Sheet const & in_kit) const;
589 
593  bool operator!=(Sheet const & in_kit) const;
594 
597  HPS::View Activate();
598  };
599 
602  class EXCHANGE_API CADModel : public HPS::CADModel
603  {
604  public:
606  CADModel();
607 
611  CADModel(Component const & in_that);
612 
616  CADModel(HPS::CADModel const & in_that);
617 
620  CADModel(Exchange::CADModel const & in_that);
621 
624  CADModel(Exchange::CADModel && in_that);
625 
626  virtual ~CADModel();
627 
628  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
629  HPS::Type ObjectType() const { return staticType; }
630 
631 #if !defined(_MSC_VER) || _MSC_VER >= 1900
632  CADModel & operator=(Exchange::CADModel const & in_that) = default;
633 #endif
634 
638  CADModel & operator=(Exchange::CADModel && in_that);
639 
640 
643  A3DEntity * GetExchangeEntity() const;
644 
648  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
649 
655  bool GetEntityOwnership() const;
656 
657 
661  UTF8Array GetCurrentConfiguration() const;
662 
666  ConfigurationArray GetConfigurations() const;
667 
670  SheetArray GetSheets() const;
671 
674  HPS::Exchange::BIMData GetBIMData() const;
675 
681  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
682 
687  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
688 
694  void ShowAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
695 
701  void SetAllPMIInFront(bool in_enable, Canvas const & in_canvas, size_t in_layer = 0);
702 
708  void HideAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
709 
714  void Tessellate(TessellationOptionsKit const & in_options);
715 
722  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
723 
726  LayerArray GetAllLayers() const;
727  };
728 
731  class EXCHANGE_API Capture : public HPS::Capture
732  {
733  public:
735  Capture();
736 
740  Capture(Component const & in_that);
741 
745  Capture(HPS::Capture const & in_that);
746 
749  Capture(Exchange::Capture const & in_that);
750 
753  Capture(Exchange::Capture && in_that);
754 
755  virtual ~Capture();
756 
757  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
758  HPS::Type ObjectType() const { return staticType; }
759 
760 #if !defined(_MSC_VER) || _MSC_VER >= 1900
761  Capture & operator=(Exchange::Capture const & in_that) = default;
762 #endif
763 
767  Capture & operator=(Exchange::Capture && in_that);
768 
769 
772  A3DEntity * GetExchangeEntity() const;
773 
777  HPS::View Activate(HPS::ComponentPath const & in_capture_path = HPS::ComponentPath());
778  };
779 
782  class EXCHANGE_API Filter : public HPS::Filter
783  {
784  public:
786  Filter();
787 
791  Filter(Component const & in_that);
792 
796  Filter(HPS::Filter const & in_that);
797 
800  Filter(Exchange::Filter const & in_that);
801 
804  Filter(Exchange::Filter && in_that);
805 
806  virtual ~Filter();
807 
808  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
809  HPS::Type ObjectType() const { return staticType; }
810 
811 #if !defined(_MSC_VER) || _MSC_VER >= 1900
812  Filter & operator=(Exchange::Filter const & in_that) = default;
813 #endif
814 
818  Filter & operator=(Exchange::Filter && in_that);
819 
820 
823  A3DEntity * GetExchangeEntity() const;
824  };
825 
828  class EXCHANGE_API Layer : public Sprocket
829  {
830  public:
832  Layer();
833 
836  Layer(Layer const & in_that);
837 
840  Layer(Layer && in_that);
841 
842  virtual ~Layer();
843 
844  static const HPS::Type staticType = HPS::Type::ExchangeLayer;
845  HPS::Type ObjectType() const { return staticType; }
846 
850  Layer & operator=(Layer const& in_that);
851 
855  Layer & operator=(Layer && in_that);
856 
859  HPS::UTF8 GetName() const;
860 
863  unsigned int GetIdentifier() const;
864 
867  ProductOccurrence GetProductOccurrence() const;
868 
871  ComponentArray GetComponents() const;
872  };
873 
875  class EXCHANGE_API Factory : public Sprocket
876  {
877  public:
882  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
883 
889  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
890 
894  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
895 
902  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
903 
907  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
908 
913  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
914 
915  private:
917  Factory();
918  };
919 
921  class EXCHANGE_API ImportNotifier : public IONotifier
922  {
923  public:
925  ImportNotifier();
926 
929  ImportNotifier(ImportNotifier const & in_that);
930 
935  ImportNotifier(IONotifier const & in_that);
936 
940  ImportNotifier(ImportNotifier && in_that);
941 
945  ImportNotifier & operator=(ImportNotifier && in_that);
946 
947  virtual ~ImportNotifier();
948 
949  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
950  HPS::Type ObjectType() const { return staticType; };
951 
955  ImportNotifier & operator=(ImportNotifier const & in_that);
956 
959  void Assign(ImportNotifier const & in_that);
960 
963  Exchange::CADModel GetCADModel() const;
964 
970  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
971 
974  Time GetImportTime() const;
975 
978  Time GetParseTime() const;
979  };
980 
982  class EXCHANGE_API TranslationNotifier : public IONotifier
983  {
984  public:
987 
990  TranslationNotifier(TranslationNotifier const & in_that);
991 
996  TranslationNotifier(IONotifier const & in_that);
997 
1002 
1006  TranslationNotifier & operator=(TranslationNotifier && in_that);
1007 
1008  virtual ~TranslationNotifier();
1009 
1010  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
1011  HPS::Type ObjectType() const { return staticType; };
1012 
1016  TranslationNotifier & operator=(TranslationNotifier const & in_that);
1017 
1020  void Assign(TranslationNotifier const & in_that);
1021 
1024  Exchange::ParasolidEntityArray GetParasolidParts() const;
1025 
1028  HPS::Time GetImportTime() const;
1029 
1032  HPS::Time GetTranslationTime() const;
1033  };
1034 
1036  class EXCHANGE_API ExportNotifier : public IONotifier
1037  {
1038  public:
1040  ExportNotifier();
1041 
1044  ExportNotifier(ExportNotifier const & in_that);
1045 
1050  ExportNotifier(IONotifier const & in_that);
1051 
1055  ExportNotifier(ExportNotifier && in_that);
1056 
1060  ExportNotifier & operator=(ExportNotifier && in_that);
1061 
1062  virtual ~ExportNotifier();
1063 
1064  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
1065  HPS::Type ObjectType() const { return staticType; };
1066 
1070  ExportNotifier & operator=(ExportNotifier const & in_that);
1071 
1074  void Assign(ExportNotifier const & in_that);
1075 
1079  A3DAsmModelFile * GetModelFile() const;
1080  };
1081 
1083  class EXCHANGE_API ReloadNotifier : public IONotifier
1084  {
1085  public:
1087  ReloadNotifier();
1088 
1091  ReloadNotifier(ReloadNotifier const & in_that);
1092 
1097  ReloadNotifier(IONotifier const & in_that);
1098 
1102  ReloadNotifier(ReloadNotifier && in_that);
1103 
1107  ReloadNotifier & operator=(ReloadNotifier && in_that);
1108 
1109  virtual ~ReloadNotifier();
1110 
1111  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
1112  HPS::Type ObjectType() const { return staticType; };
1113 
1117  ReloadNotifier & operator=(ReloadNotifier const & in_that);
1118 
1121  void Assign(ReloadNotifier const & in_that);
1122  };
1123 
1124 
1125  class ImportOptionsKit;
1126  class ModelFileImportOptionsKit;
1127 
1128 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1129  class Export3MFOptionsKit;
1130  class ExportFBXOptionsKit;
1131  class ExportACISOptionsKit;
1132  class ExportJTOptionsKit;
1133  class ExportPRCOptionsKit;
1134  class ExportSTLOptionsKit;
1135  class ExportOBJOptionsKit;
1136  class ExportU3DOptionsKit;
1137  class ExportXMLOptionsKit;
1138  class ExportGLTFOptionsKit;
1139 #endif
1140 
1141 #if !defined(TARGET_OS_ANDROID)
1142  class ExportSTEPOptionsKit;
1143  class ExportIGESOptionsKit;
1144 #endif
1145 
1148  enum class BRepMode
1149  {
1152  TessellationOnly,
1155  BRepOnly,
1158  BRepAndTessellation,
1159  };
1160 
1163  enum class ImportMode
1164  {
1167  Complete,
1170  Incremental,
1171  };
1172 
1175  enum class SurfaceType
1176  {
1177  Blend01,
1178  Blend02,
1179  Blend03,
1180  Blend04,
1181  NURBS,
1182  Cone,
1183  Cylinder,
1184  Offset,
1185  Pipe,
1186  Plane,
1187  Ruled,
1188  Sphere,
1189  Revolution,
1190  Extrusion,
1191  FromCurve,
1192  Torus,
1193  Transform,
1194  };
1195 
1198  enum class CurveType
1199  {
1200  Blend,
1201  NURBS,
1202  Circle,
1203  Composite,
1204  CurveOnSurface,
1205  Ellipse,
1206  Equation,
1207  Helix,
1208  Hyperbola,
1209  Intersection,
1210  Line,
1211  Offset,
1212  Parabola,
1213  Polyline,
1214  Transform,
1215  };
1216 
1217  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
1218  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
1219 
1223  {
1224  PMIOnly,
1225  ModelAndPMI
1226  };
1227 
1229  class EXCHANGE_API Tessellation
1230  {
1231  public:
1234  enum class Type
1235  {
1236  Standard,
1237  Custom
1238  };
1239 
1240 
1243  enum class Level
1244  {
1245  ExtraLow,
1246  Low,
1247  Medium,
1248  High,
1249  ExtraHigh,
1250  };
1251 
1253  class EXCHANGE_API Chord
1254  {
1255  public:
1258  enum class Limit
1259  {
1262  Ratio,
1265  Height
1266  };
1267 
1268  private:
1270  Chord();
1271  };
1272 
1275  enum class Accuracy
1276  {
1279  Standard,
1282  Accurate,
1284  GridAccurate
1285  };
1286 
1287  private:
1289  Tessellation();
1290  };
1291 
1293  class EXCHANGE_API JT
1294  {
1295  public:
1298  enum class Content
1299  {
1300  Geometry,
1301  Tessellation,
1302  GeometryAndTessellation
1303  };
1304 
1308  {
1309  Low,
1310  Medium,
1311  High,
1312  };
1313 
1316  enum class Version
1317  {
1318  JT81,
1319  JT95,
1320  JT100,
1321  };
1322 
1323  private:
1325  JT();
1326  };
1327 
1329  class EXCHANGE_API STEP
1330  {
1331  public:
1334  enum class Field
1335  {
1336  ProductName,
1337  NextAssemblyUsageOccurrenceID,
1338  NextAssemblyUsageOccurrenceName,
1339  NextAssemblyUsageOccurrenceDescription
1340  };
1341 
1344  enum class Format
1345  {
1346  AP203,
1347  AP214,
1348  AP242,
1349  };
1350 
1351  private:
1353  STEP();
1354  };
1355 
1357  class EXCHANGE_API PRC
1358  {
1359  public:
1362  enum class BRepCompression
1363  {
1364  None,
1365  Low,
1366  Medium,
1367  High
1368  };
1369 
1370  private:
1372  PRC();
1373  };
1374 
1376  class EXCHANGE_API ProE
1377  {
1378  public:
1381  enum class SessionColor
1382  {
1384  LastCreoVersion,
1386  ExchangeDefault,
1389  UserDefined
1390  };
1391 
1394  enum class FamilyTable
1395  {
1397  BRepOnly,
1399  BRepOrTessellation,
1401  BRepOrTessellationOrGeneric
1402  };
1403 
1407  {
1409  On,
1411  Off,
1413  AsDatum,
1414  };
1415 
1416  private:
1418  ProE();
1419  };
1420 
1422  class EXCHANGE_API U3D
1423  {
1424  public:
1427  enum class Version
1428  {
1429  ECMA1,
1430  ECMA3
1431  };
1432 
1433  private:
1435  U3D();
1436  };
1437 
1439  class EXCHANGE_API Revit
1440  {
1441  public:
1443  {
1445  NotComputed,
1447  Computed
1448  };
1449 
1450  private:
1452  Revit();
1453  };
1454 
1456  class EXCHANGE_API Configuration : public HPS::Sprocket
1457  {
1458  public:
1460  Configuration();
1461 
1464  Configuration(char const * in_name);
1465 
1470  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1471 
1475  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1476 
1479  Configuration(Configuration const & in_configuration);
1480 
1484  Configuration(Configuration && in_that);
1485 
1489  Configuration & operator=(Configuration && in_that);
1490 
1491  virtual ~Configuration();
1492 
1493  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1494  HPS::Type ObjectType() const { return staticType; }
1495 
1496 
1499  void Set(Configuration const & in_kit);
1500 
1503  void Show(Configuration & out_kit) const;
1504 
1508  Configuration & operator=(Configuration const & in_kit);
1509 
1512  bool Empty() const;
1513 
1517  bool Equals(Configuration const & in_kit) const;
1518 
1522  bool operator==(Configuration const & in_kit) const;
1523 
1527  bool operator!=(Configuration const & in_kit) const;
1528 
1529 
1532  HPS::UTF8 GetName() const;
1533 
1536  ConfigurationArray GetSubconfigurations() const;
1537  };
1538 
1540  class EXCHANGE_API File
1541  {
1542  public:
1545  enum class Format
1546  {
1547  Unsupported,
1548  ACIS,
1549  CADDS,
1550  CATIAV4,
1551  CATIAV5,
1552  CGR,
1553  COLLADA,
1554  CreoProE,
1555  DWG,
1556  DXF,
1557  IDEAS,
1558  IFC,
1559  IGES,
1560  Inventor,
1561  JT,
1562  KeyholeMarkupLanguage,
1563  LatticeXVL,
1564  OneSpaceDesigner,
1565  Parasolid,
1566  PDF,
1567  PRC,
1568  Rhino,
1569  NXUnigraphics,
1570  SolidEdge,
1571  SolidWorks,
1572  STEP,
1573  StereoLithography,
1574  ThreeDStudioMax,
1575  ThreeDXML,
1576  Universal3D,
1577  VDAFS,
1578  VRML,
1579  WavefrontObject,
1580  Revit,
1581  GLTF,
1582  DWF,
1583  FBX,
1584  STEPXML,
1585  ThreeMF,
1586  Navisworks,
1587  };
1588 
1590  static Format GetFormat(char const * in_file_name);
1591 
1595  static ConfigurationArray GetConfigurations(char const * in_file_name);
1596 
1608  static void GetInformation(const char * in_file_name, Format & out_format, UTF8 & out_model_name, UTF8 & out_version, UTF8 & out_author, UTF8 & out_organization, UTF8 & out_time_stamp);
1609 
1615  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1616 
1623  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1624 
1631  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1632 
1640  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1641 
1648  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1649 
1650 
1657  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1658 
1659 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1660 
1664  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1665 
1671  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1672 
1679  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1680 
1686  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1687 
1692  static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);
1693 
1698  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1699 
1704  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1705 
1711  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1712 
1718  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1719 
1726  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1727 
1733  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1734 
1738  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1739 
1744  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1745 
1749  static ExportNotifier ExportPRC(KeyPath const & in_source);
1750 
1755  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1756 
1761  static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);
1762 
1767  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1768 
1772  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1773 
1778  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1779 
1784  static void ExportGLTF(CADModel const & in_cad_model, char const * in_file_name, ExportGLTFOptionsKit const & in_options);
1785 
1786 #endif
1787 
1788 #if TARGET_OS_ANDROID == 0
1789 
1793  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1794 
1799  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1800 
1805  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1806 #endif
1807 
1808  private:
1810  File();
1811  };
1812 
1814  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1815  {
1816  public:
1819 
1823 
1828 
1832  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1833 
1834  virtual ~NURBSConversionOptionsKit();
1835 
1836  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1837  HPS::Type ObjectType() const { return staticType; }
1838 
1841  void Set(NURBSConversionOptionsKit const & in_kit);
1842 
1845  void Show(NURBSConversionOptionsKit & out_kit) const;
1846 
1850  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1851 
1854  bool Empty() const;
1855 
1859  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1860 
1864  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1865 
1869  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1870 
1874  static NURBSConversionOptionsKit GetDefault();
1875 
1880  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1881 
1886  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1887 
1892  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1893 
1898  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1899 
1904  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1905 
1910  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1911 
1916  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1917 
1923  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1924 
1931  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1932 
1938  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1939 
1946  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1947 
1948 
1951  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1952 
1955  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1956 
1959  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1960 
1963  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1964 
1967  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1968 
1971  NURBSConversionOptionsKit & UnsetParameterization();
1972 
1975  NURBSConversionOptionsKit & UnsetTolerance();
1976 
1979  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1980 
1983  NURBSConversionOptionsKit & UnsetAllowedCurves();
1984 
1987  NURBSConversionOptionsKit & UnsetEverything();
1988 
1989 
1990 
1994  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1995 
1999  bool Show3DCurvesComputation(bool & out_state) const;
2000 
2005  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
2006 
2010  bool ShowClosedFaceSplitting(bool & out_state) const;
2011 
2015  bool ShowPeriodicFaceSplitting(bool & out_state) const;
2016 
2020  bool ShowParameterization(bool & out_state) const;
2021 
2025  bool ShowTolerance(double & out_tolerance) const;
2026 
2030  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
2031 
2035  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
2036  };
2037 
2039  class EXCHANGE_API ImportOptionsKit : public SprocketKit
2040  {
2041  public:
2043  ImportOptionsKit();
2044 
2047  ImportOptionsKit(ImportOptionsKit const & in_kit);
2048 
2052  ImportOptionsKit(ImportOptionsKit && in_that);
2053 
2057  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
2058 
2059  virtual ~ImportOptionsKit();
2060 
2061  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
2062  HPS::Type ObjectType() const { return staticType; }
2063 
2067  static ImportOptionsKit GetDefault();
2068 
2071  void Set(ImportOptionsKit const & in_kit);
2072 
2075  void Show(ImportOptionsKit & out_kit) const;
2076 
2080  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
2081 
2084  bool Empty() const;
2085 
2089  bool Equals(ImportOptionsKit const & in_kit) const;
2090 
2094  bool operator==(ImportOptionsKit const & in_kit) const;
2095 
2099  bool operator!=(ImportOptionsKit const & in_kit) const;
2100 
2101 
2107  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
2108 
2114  ImportOptionsKit & SetSolids(bool in_state);
2115 
2121  ImportOptionsKit & SetSurfaces(bool in_state);
2122 
2128  ImportOptionsKit & SetWireframes(bool in_state);
2129 
2135  ImportOptionsKit & SetPMI(bool in_state);
2136 
2143  ImportOptionsKit & SetAttributes(bool in_state);
2144 
2150  ImportOptionsKit & SetHiddenObjects(bool in_state);
2151 
2157  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
2158 
2164  ImportOptionsKit & SetActiveFilter(bool in_state);
2165 
2172  ImportOptionsKit& SetConstraintsInfo(bool in_state);
2173 
2181  ImportOptionsKit & SetFeatureTrees(bool in_state);
2182 
2188  ImportOptionsKit & SetDrawings(bool in_state);
2189 
2195  ImportOptionsKit & SetDefaultUnits(Units in_units);
2196 
2202  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
2203 
2209  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
2210 
2217  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
2218 
2225  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
2226 
2232  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
2233 
2239  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
2240 
2248  ImportOptionsKit & SetPMIFlipping(bool in_flip);
2249 
2256  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
2257 
2265  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
2266 
2274  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
2275 
2281  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
2282 
2288  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
2289 
2297  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
2298 
2310  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
2311 
2317  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
2318 
2324  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
2325 
2331  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
2332 
2337  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
2338 
2345  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
2346 
2352  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
2353 
2362  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2363 
2372  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2373 
2379  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2380 
2385  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2386 
2393  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2394 
2399  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2400 
2406  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2407 
2412  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2413 
2419  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2420 
2427  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2428 
2435  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2436 
2442  ImportOptionsKit & SetCatiaV5MaterialRendering(bool in_active);
2443 
2451  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2452 
2459  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2460 
2466  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2467 
2473  ImportOptionsKit & SetProECodePageName(char const * in_name);
2474 
2480  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2481 
2487  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2488 
2494  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2495 
2502  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2503 
2510  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2511 
2518  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2519 
2526  ImportOptionsKit & SetProEHomeView(bool in_source);
2527 
2534  ImportOptionsKit & SetProEExplodedViews(bool in_source);
2535 
2542  ImportOptionsKit & SetProEDatum(bool in_source);
2543 
2544 
2551  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2552 
2559  ImportOptionsKit & SetProESkeletons(bool in_state);
2560 
2567  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2568 
2574  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2575 
2581  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2582 
2588  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2589 
2595  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2596 
2602  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2603 
2609  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2610 
2617  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2618 
2624  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2625 
2631  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2632 
2639  ImportOptionsKit & SetIFCEdges(bool in_state);
2640 
2646  ImportOptionsKit & SetIFCMetadata(bool in_state);
2647 
2653  ImportOptionsKit & SetIFCRelationships(bool in_state);
2654 
2660  ImportOptionsKit & SetIFCOpenings(bool in_state);
2661 
2667  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2668 
2674  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2675 
2681  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2682 
2688  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2689 
2695  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2696 
2703  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2704 
2711  ImportOptionsKit & SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);
2712 
2716  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2717 
2729  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2730 
2742  ImportOptionsKit & SetMode(ImportMode in_mode);
2743 
2753  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2754 
2762  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2763 
2770  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2771 
2775  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2776 
2781  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2782 
2794  ImportOptionsKit & SetLargeTranslationExtraction(bool in_state, intptr_t in_data_index = 1);
2795 
2798  ImportOptionsKit & UnsetBRepMode();
2799 
2802  ImportOptionsKit & UnsetSolids();
2803 
2806  ImportOptionsKit & UnsetSurfaces();
2807 
2810  ImportOptionsKit & UnsetWireframes();
2811 
2814  ImportOptionsKit & UnsetPMI();
2815 
2818  ImportOptionsKit & UnsetAttributes();
2819 
2822  ImportOptionsKit & UnsetHiddenObjects();
2823 
2826  ImportOptionsKit & UnsetConstructionAndReferences();
2827 
2830  ImportOptionsKit & UnsetActiveFilter();
2831 
2834  ImportOptionsKit & UnsetDrawings();
2835 
2838  ImportOptionsKit& UnsetConstraintsInfo();
2839 
2842  ImportOptionsKit & UnsetFeatureTrees();
2843 
2846  ImportOptionsKit & UnsetSewingTolerance();
2847 
2850  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2851 
2854  ImportOptionsKit & UnsetDefaultUnits();
2855 
2858  ImportOptionsKit & UnsetMultiProcessCount();
2859 
2862  ImportOptionsKit & UnsetPMISubstitutionFont();
2863 
2866  ImportOptionsKit & UnsetPMIPrecision();
2867 
2870  ImportOptionsKit & UnsetPMIDefaultUnits();
2871 
2874  ImportOptionsKit & UnsetPMIDefaultColor();
2875 
2878  ImportOptionsKit & UnsetTessellationLevel();
2879 
2882  ImportOptionsKit & UnsetTessellationAccuracy();
2883 
2886  ImportOptionsKit & UnsetTessellationCleanup();
2887 
2890  ImportOptionsKit & UnsetPMIFlipping();
2891 
2894  ImportOptionsKit & UnsetRemovedViews();
2895 
2898  ImportOptionsKit & UnsetExternalProductOccurrence();
2899 
2902  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2903 
2906  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2907 
2910  ImportOptionsKit & UnsetTextureDirectories();
2911 
2914  ImportOptionsKit & UnsetSearchDirectories();
2915 
2918  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2919 
2922  ImportOptionsKit & UnsetSearchRootDirectory();
2923 
2926  ImportOptionsKit & UnsetConfiguration();
2927 
2930  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2931 
2934  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2935 
2938  ImportOptionsKit & UnsetCatiaV5Cache();
2939 
2942  ImportOptionsKit & UnsetCatiaV5MaterialRendering();
2943 
2946  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2947 
2950  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2951 
2954  ImportOptionsKit & UnsetProECodePageName();
2955 
2958  ImportOptionsKit & UnsetProEDimensionTolerance();
2959 
2962  ImportOptionsKit & UnsetProESubpartPMI();
2963 
2966  ImportOptionsKit & UnsetProESessionColor();
2967 
2970  ImportOptionsKit & UnsetProEDatum();
2971 
2974  ImportOptionsKit & UnsetProEHomeView();
2975 
2978  ImportOptionsKit & UnsetProEExplodedViews();
2979 
2982  ImportOptionsKit & UnsetProEMissingBoolean();
2983 
2986  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2987 
2990  ImportOptionsKit & UnsetProEFamilyTreeSource();
2991 
2994  ImportOptionsKit & UnsetProEConstructionEntities();
2995 
2998  ImportOptionsKit & UnsetProESkeletons();
2999 
3002  ImportOptionsKit & UnsetSTEPNamePreference();
3003 
3006  ImportOptionsKit & UnsetSTEPFirstColorPreference();
3007 
3010  ImportOptionsKit & UnsetSTEPCodePageName();
3011 
3014  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
3015 
3018  ImportOptionsKit & UnsetSTEPOrientationHealing();
3019 
3022  ImportOptionsKit & UnsetSTEPValidationProperties();
3023 
3026  ImportOptionsKit & UnsetIFCCodePageName();
3027 
3030  ImportOptionsKit & UnsetIFCAttributeXMLFile();
3031 
3034  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
3035 
3038  ImportOptionsKit & UnsetIFCFaceOptimization();
3039 
3042  ImportOptionsKit & UnsetIFCEdges();
3043 
3046  ImportOptionsKit & UnsetIFCMetadata();
3047 
3050  ImportOptionsKit & UnsetIFCRelationships();
3051 
3054  ImportOptionsKit & UnsetIFCOpenings();
3055 
3058  ImportOptionsKit & UnsetPDF3DStreamIndex();
3059 
3062  ImportOptionsKit & UnsetJTTessellationLevel();
3063 
3066  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
3067 
3070  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
3071 
3074  ImportOptionsKit & UnsetPRCReadHelper();
3075 
3078  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
3079 
3082  ImportOptionsKit & UnsetRevitPhysicalProperties();
3083 
3086  ImportOptionsKit & UnsetAnnotationCaptureFitting();
3087 
3090  ImportOptionsKit & UnsetLocation();
3091 
3094  ImportOptionsKit & UnsetMode();
3095 
3098  ImportOptionsKit & UnsetIncrementalComponentPaths();
3099 
3102  ImportOptionsKit & UnsetNURBSConversion();
3103 
3106  ImportOptionsKit & UnsetGeometryDefaultColor();
3107 
3110  ImportOptionsKit & UnsetLargeTranslationExtraction();
3111 
3114  ImportOptionsKit & UnsetEverything();
3115 
3119  bool ShowBRepMode(BRepMode & out_mode) const;
3120 
3124  bool ShowSolids(bool & out_state) const;
3125 
3129  bool ShowSurfaces(bool & out_state) const;
3130 
3134  bool ShowWireframes(bool & out_state) const;
3135 
3139  bool ShowPMI(bool & out_state) const;
3140 
3144  bool ShowAttributes(bool & out_state) const;
3145 
3149  bool ShowHiddenObjects(bool & out_state) const;
3150 
3154  bool ShowConstructionAndReferences(bool & out_state) const;
3155 
3159  bool ShowActiveFilter(bool & out_state) const;
3160 
3164  bool ShowDrawings(bool & out_state) const;
3165 
3169  bool ShowConstraintsInfo(bool& out_state) const;
3170 
3174  bool ShowFeatureTrees(bool & out_state) const;
3175 
3179  bool ShowSewingTolerance(double & out_tolerance) const;
3180 
3184  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3185 
3189  bool ShowDefaultUnits(Units & out_units) const;
3190 
3194  bool ShowMultiProcessCount(unsigned int & out_count) const;
3195 
3200  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
3201 
3205  bool ShowPMIPrecision(size_t & out_precision) const;
3206 
3210  bool ShowPMIDefaultUnits(Units & out_units) const;
3211 
3216  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
3217 
3225  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3226 
3233  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3234 
3238  bool ShowTessellationCleanup(bool & out_cleanup) const;
3239 
3243  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3244 
3248  bool ShowRemovedViews(bool & out_read_removed_views) const;
3249 
3253  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
3254 
3258  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3259 
3263  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3264 
3268  bool ShowTextureDirectories(UTF8Array & out_directories) const;
3269 
3275  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
3276 
3280  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
3281 
3286  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
3287 
3291  bool ShowConfiguration(UTF8Array & out_configuration) const;
3292 
3296  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
3297 
3301  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
3302 
3307  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
3308 
3312  bool ShowCatiaV5MaterialRendering(bool & out_active) const;
3313 
3318  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
3319 
3323  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
3324 
3328  bool ShowProECodePageName(UTF8 & out_name) const;
3329 
3333  bool ShowProEDimensionTolerance(bool & out_state) const;
3334 
3338  bool ShowProESubpartPMI(bool & out_state) const;
3339 
3343  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
3344 
3348  bool ShowProEDatum(bool & out_state) const;
3349 
3353  bool ShowProEHomeView(bool & out_state) const;
3354 
3358  bool ShowProEExplodedViews(bool & out_state) const;
3359 
3363  bool ShowProEMissingBoolean(bool & out_state) const;
3364 
3368  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
3369 
3373  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
3374 
3378  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
3379 
3383  bool ShowProESkeletons(bool & out_state) const;
3384 
3388  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
3389 
3393  bool ShowSTEPFirstColorPreference(bool & out_state) const;
3394 
3398  bool ShowSTEPCodePageName(UTF8 & out_name) const;
3399 
3403  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
3404 
3408  bool ShowSTEPOrientationHealing(bool & out_state) const;
3409 
3413  bool ShowSTEPValidationProperties(bool & out_state) const;
3414 
3418  bool ShowIFCCodePageName(UTF8 & out_name) const;
3419 
3423  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
3424 
3428  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
3429 
3433  bool ShowIFCFaceOptimization(bool & out_state) const;
3434 
3438  bool ShowIFCEdges(bool & out_state) const;
3439 
3443  bool ShowIFCMetadata(bool & out_state) const;
3444 
3448  bool ShowIFCRelationships(bool & out_state) const;
3449 
3453  bool ShowIFCOpenings(bool & out_state) const;
3454 
3458  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3459 
3463  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3464 
3468  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3469 
3473  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3474 
3478  bool ShowPRCReadHelper(bool & out_use_helper) const;
3479 
3483  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3484 
3488  bool ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;
3489 
3493  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3494 
3499  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3500 
3504  bool ShowMode(ImportMode & out_mode) const;
3505 
3509  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3510 
3514  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3515 
3519  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3520 
3525  bool ShowLargeTranslationExtraction(bool & out_state, intptr_t & out_data_index) const;
3526  };
3527 
3529  class EXCHANGE_API Translation
3530  {
3531  public:
3534  enum class Healing
3535  {
3536  Off,
3537  On,
3538  OnlyIfNotParasolid,
3539  };
3540 
3543  enum class AccurateEdges
3544  {
3545  Off,
3546  On,
3547  OnlyIfNotParasolid,
3548  };
3549 
3552  enum class Simplification
3553  {
3554  Off,
3555  On,
3556  OnlyIfNotParasolid,
3557  };
3558 
3561  enum class Merging
3562  {
3563  Off,
3564  On,
3565  OnlyIfNotParasolid,
3566  };
3567 
3568  private:
3570  Translation();
3571  };
3572 
3574  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3575  {
3576  public:
3579 
3583 
3588 
3592  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3593 
3594  virtual ~TranslationOptionsKit();
3595 
3596  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3597  HPS::Type ObjectType() const { return staticType; }
3598 
3602  static TranslationOptionsKit GetDefault();
3603 
3606  void Set(TranslationOptionsKit const & in_kit);
3607 
3610  void Show(TranslationOptionsKit & out_kit) const;
3611 
3615  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3616 
3619  bool Empty() const;
3620 
3624  bool Equals(TranslationOptionsKit const & in_kit) const;
3625 
3629  bool operator==(TranslationOptionsKit const & in_kit) const;
3630 
3634  bool operator!=(TranslationOptionsKit const & in_kit) const;
3635 
3641  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3642 
3648  TranslationOptionsKit & SetTessellation(bool in_state);
3649 
3655  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3656 
3660  TranslationOptionsKit & SetApplication(char const * in_name);
3661 
3665  TranslationOptionsKit & SetVersion(char const * in_version);
3666 
3672  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3673 
3677  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3678 
3682  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3683 
3687  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3688 
3692  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3693 
3698  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3699 
3703  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3704 
3707  TranslationOptionsKit & UnsetSolidsAsFaces();
3708 
3711  TranslationOptionsKit & UnsetTessellation();
3712 
3715  TranslationOptionsKit & UnsetHiddenObjects();
3716 
3719  TranslationOptionsKit & UnsetApplication();
3720 
3723  TranslationOptionsKit & UnsetVersion();
3724 
3727  TranslationOptionsKit & UnsetHealing();
3728 
3731  TranslationOptionsKit & UnsetAccurateEdges();
3732 
3735  TranslationOptionsKit & UnsetSimplification();
3736 
3739  TranslationOptionsKit & UnsetEntityMerging();
3740 
3743  TranslationOptionsKit & UnsetSewing();
3744 
3747  TranslationOptionsKit & UnsetDisjointFaces();
3748 
3751  TranslationOptionsKit& UnsetExplodeMultiBodies();
3752 
3755  TranslationOptionsKit & UnsetEverything();
3756 
3757 
3761  bool ShowSolidsAsFaces(bool & out_state) const;
3762 
3766  bool ShowTessellation(bool & out_state) const;
3767 
3771  bool ShowHiddenObjects(bool & out_state) const;
3772 
3776  bool ShowApplication(UTF8 & out_name) const;
3777 
3781  bool ShowVersion(UTF8 & out_version) const;
3782 
3786  bool ShowExplodeMultiBodies(bool& out_state) const;
3787 
3791  bool ShowHealing(Translation::Healing & out_healing) const;
3792 
3796  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3797 
3801  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3802 
3806  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3807 
3812  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3813 
3817  bool ShowDisjointFaces(bool & out_state) const;
3818 
3823  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3824 
3827  TranslationOptionsKit & UnsetMultiProcessCount();
3828 
3832  bool ShowMultiProcessCount(unsigned int & out_count) const;
3833  };
3834 
3835 
3836 
3841  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3842  {
3843  public:
3846 
3850 
3855 
3859  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3860 
3861  virtual ~ModelFileImportOptionsKit();
3862 
3863  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3864  HPS::Type ObjectType() const { return staticType; }
3865 
3869  static ModelFileImportOptionsKit GetDefault();
3870 
3873  void Set(ModelFileImportOptionsKit const & in_kit);
3874 
3877  void Show(ModelFileImportOptionsKit & out_kit) const;
3878 
3882  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3883 
3886  bool Empty() const;
3887 
3891  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3892 
3896  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3897 
3901  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3902 
3903 
3911  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3912 
3918  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3919 
3927  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3928 
3940  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double accurate_grid_maximum_stitch_length = 0.0);
3941 
3947  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3948 
3954  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3955 
3961  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3962 
3969  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3970 
3974  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3975 
3988  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3989 
3995  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3996 
4003  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
4004 
4008  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
4009 
4014  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
4015 
4021  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
4022 
4025  ModelFileImportOptionsKit & UnsetTessellationLevel();
4026 
4029  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
4030 
4033  ModelFileImportOptionsKit & UnsetTessellationCleanup();
4034 
4037  ModelFileImportOptionsKit & UnsetPMIFlipping();
4038 
4041  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
4042 
4045  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
4046 
4049  ModelFileImportOptionsKit & UnsetIFCEdges();
4050 
4053  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
4054 
4057  ModelFileImportOptionsKit & UnsetLocation();
4058 
4061  ModelFileImportOptionsKit & UnsetSewingTolerance();
4062 
4065  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
4066 
4069  ModelFileImportOptionsKit & UnsetNURBSConversion();
4070 
4073  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
4074 
4077  ModelFileImportOptionsKit & UnsetHiddenObjects();
4078 
4081  ModelFileImportOptionsKit & UnsetEverything();
4082 
4083 
4091  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4092 
4099  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
4100 
4104  bool ShowTessellationCleanup(bool & out_cleanup) const;
4105 
4109  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
4110 
4114  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
4115 
4119  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
4120 
4124  bool ShowIFCEdges(bool & out_state) const;
4125 
4129  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
4130 
4135  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
4136 
4140  bool ShowSewingTolerance(double & out_tolerance) const;
4141 
4142 
4146  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
4147 
4151  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
4152 
4156  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
4157 
4161  bool ShowHiddenObjects(bool & out_state) const;
4162  };
4163 
4164 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
4165 
4166  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
4167  {
4168  public:
4171 
4174  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
4175 
4179 
4180  virtual ~Export3MFOptionsKit();
4181 
4182  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
4183  HPS::Type ObjectType() const { return staticType; }
4184 
4188  static Export3MFOptionsKit GetDefault();
4189 
4192  void Set(Export3MFOptionsKit const & in_kit);
4193 
4196  void Show(Export3MFOptionsKit& out_kit) const;
4197 
4201  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
4202 
4206  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
4207 
4210  bool Empty() const;
4211 
4215  bool Equals(Export3MFOptionsKit const & in_kit) const;
4216 
4220  bool operator==(Export3MFOptionsKit const & in_kit) const;
4221 
4225  bool operator!=(Export3MFOptionsKit const & in_kit) const;
4226 
4231  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4232 
4238  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
4239 
4242  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
4243 
4247  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4248 
4253  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
4254 
4257  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
4258 
4263  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
4264 
4268  Export3MFOptionsKit & SetDescription(char const * in_description);
4269 
4272  Export3MFOptionsKit & UnsetDescription();
4273 
4277  bool ShowDescription(HPS::UTF8 & out_description) const;
4278 
4282  Export3MFOptionsKit & SetCopyright(char const * in_copyright);
4283 
4286  Export3MFOptionsKit & UnsetCopyright();
4287 
4291  bool ShowCopyright(HPS::UTF8 & out_copyright) const;
4292 
4296  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
4297 
4300  Export3MFOptionsKit & UnsetLicenseTerms();
4301 
4305  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
4306 
4309  Export3MFOptionsKit & UnsetEverything();
4310  };
4311 
4313  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
4314  {
4315  public:
4318 
4321  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
4322 
4326 
4327  virtual ~ExportFBXOptionsKit();
4328 
4329  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
4330  HPS::Type ObjectType() const { return staticType; }
4331 
4335  static ExportFBXOptionsKit GetDefault();
4336 
4339  void Set(ExportFBXOptionsKit const & in_kit);
4340 
4343  void Show(ExportFBXOptionsKit & out_kit) const;
4344 
4348  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
4349 
4353  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
4354 
4357  bool Empty() const;
4358 
4362  bool Equals(ExportFBXOptionsKit const & in_kit) const;
4363 
4367  bool operator==(ExportFBXOptionsKit const & in_kit) const;
4368 
4372  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
4373 
4374 
4382  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
4383 
4384 
4390  ExportFBXOptionsKit & SetAscii(bool in_state);
4391 
4392 
4395  ExportFBXOptionsKit & UnsetTextureFolder();
4396 
4399  ExportFBXOptionsKit & UnsetAscii();
4400 
4403  ExportFBXOptionsKit & UnsetEverything();
4404 
4405 
4409  bool ShowTextureFolder(UTF8 & out_path) const;
4410 
4414  bool ShowAscii(bool & out_state) const;
4415  };
4416 
4418  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
4419  {
4420  public:
4423 
4427 
4431 
4432  virtual ~ExportACISOptionsKit();
4433 
4434  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
4435  HPS::Type ObjectType() const { return staticType; }
4436 
4440  static ExportACISOptionsKit GetDefault();
4441 
4444  void Set(ExportACISOptionsKit const & in_kit);
4445 
4448  void Show(ExportACISOptionsKit & out_kit) const;
4449 
4453  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
4454 
4458  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
4459 
4462  bool Empty() const;
4463 
4467  bool Equals(ExportACISOptionsKit const & in_kit) const;
4468 
4472  bool operator==(ExportACISOptionsKit const & in_kit) const;
4473 
4477  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4478 
4479 
4485  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4486 
4492  ExportACISOptionsKit & SetBinary(bool in_state);
4493 
4494 
4497  ExportACISOptionsKit & UnsetMillimeterUnits();
4498 
4501  ExportACISOptionsKit & UnsetBinary();
4502 
4505  ExportACISOptionsKit & UnsetEverything();
4506 
4507 
4511  bool ShowMillimeterUnits(bool & out_state) const;
4512 
4516  bool ShowBinary(bool & out_state) const;
4517  };
4518 
4520  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4521  {
4522  public:
4525 
4528  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4529 
4533 
4534  virtual ~ExportJTOptionsKit();
4535 
4536  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4537  HPS::Type ObjectType() const { return staticType; }
4538 
4542  static ExportJTOptionsKit GetDefault();
4543 
4546  void Set(ExportJTOptionsKit const & in_kit);
4547 
4550  void Show(ExportJTOptionsKit & out_kit) const;
4551 
4555  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4556 
4560  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4561 
4564  bool Empty() const;
4565 
4569  bool Equals(ExportJTOptionsKit const & in_kit) const;
4570 
4574  bool operator==(ExportJTOptionsKit const & in_kit) const;
4575 
4579  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4580 
4581 
4587  ExportJTOptionsKit & SetContent(JT::Content in_content);
4588 
4594  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4595 
4601  ExportJTOptionsKit & SetPMI(bool in_state);
4602 
4608  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4609 
4610 
4613  ExportJTOptionsKit & UnsetContent();
4614 
4617  ExportJTOptionsKit & UnsetHiddenObjects();
4618 
4621  ExportJTOptionsKit & UnsetPMI();
4622 
4625  ExportJTOptionsKit & UnsetVersion();
4626 
4629  ExportJTOptionsKit & UnsetEverything();
4630 
4631 
4635  bool ShowContent(JT::Content & out_content) const;
4636 
4640  bool ShowHiddenObjects(bool & out_state) const;
4641 
4645  bool ShowPMI(bool & out_state) const;
4646 
4650  bool ShowVersion(JT::Version & out_version) const;
4651  };
4652 
4654  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4655  {
4656  public:
4659 
4662  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4663 
4667 
4668  virtual ~ExportPRCOptionsKit();
4669 
4670  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4671  HPS::Type ObjectType() const { return staticType; }
4672 
4676  static ExportPRCOptionsKit GetDefault();
4677 
4680  void Set(ExportPRCOptionsKit const & in_kit);
4681 
4684  void Show(ExportPRCOptionsKit & out_kit) const;
4685 
4689  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4690 
4694  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4695 
4698  bool Empty() const;
4699 
4703  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4704 
4708  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4709 
4713  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4714 
4715 
4721  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4722 
4729  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4730 
4736  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4737 
4743  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4744 
4749  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4750 
4756  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4757 
4758 
4761  ExportPRCOptionsKit & UnsetTessellationCompression();
4762 
4765  ExportPRCOptionsKit & UnsetBRepCompression();
4766 
4769  ExportPRCOptionsKit & UnsetBRepRemoval();
4770 
4773  ExportPRCOptionsKit & UnsetAttributeRemoval();
4774 
4777  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4778 
4781  ExportPRCOptionsKit & UnsetEverything();
4782 
4783 
4787  bool ShowTessellationCompression(bool & out_state) const;
4788 
4792  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4793 
4797  bool ShowBRepRemoval(bool & out_state) const;
4798 
4802  bool ShowAttributeRemoval(bool & out_state) const;
4803 
4807  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4808  };
4809 
4811  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4812  {
4813  public:
4816 
4819  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4820 
4824 
4825  virtual ~ExportSTLOptionsKit();
4826 
4827  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4828  HPS::Type ObjectType() const { return staticType; }
4829 
4833  static ExportSTLOptionsKit GetDefault();
4834 
4837  void Set(ExportSTLOptionsKit const & in_kit);
4838 
4841  void Show(ExportSTLOptionsKit & out_kit) const;
4842 
4846  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4847 
4851  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4852 
4855  bool Empty() const;
4856 
4860  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4861 
4865  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4866 
4870  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4871 
4872 
4878  ExportSTLOptionsKit & SetBinary(bool in_state);
4879 
4885  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4886 
4894  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4895 
4901  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4902 
4908  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4909 
4916  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4917 
4927  ExportSTLOptionsKit & SetUnits(Units in_units);
4928 
4929 
4932  ExportSTLOptionsKit & UnsetBinary();
4933 
4936  ExportSTLOptionsKit & UnsetTessellationLevel();
4937 
4940  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4941 
4944  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4945 
4948  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4949 
4952  ExportSTLOptionsKit & UnsetUnits();
4953 
4956  ExportSTLOptionsKit & UnsetEverything();
4957 
4958 
4962  bool ShowBinary(bool & out_state) const;
4963 
4971  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4972 
4976  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4977 
4981  bool ShowCurrentTessellationRetention(bool & out_state) const;
4982 
4986  bool ShowMaximumEdgeLength(double & out_length) const;
4987 
4991  bool ShowUnits(Units & out_units) const;
4992  };
4993 
4995  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4996  {
4997  public:
5000 
5003  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
5004 
5008 
5009  virtual ~ExportOBJOptionsKit();
5010 
5011  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
5012  HPS::Type ObjectType() const { return staticType; }
5013 
5017  static ExportOBJOptionsKit GetDefault();
5018 
5021  void Set(ExportOBJOptionsKit const & in_kit);
5022 
5025  void Show(ExportOBJOptionsKit & out_kit) const;
5026 
5030  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
5031 
5035  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
5036 
5039  bool Empty() const;
5040 
5044  bool Equals(ExportOBJOptionsKit const & in_kit) const;
5045 
5049  bool operator==(ExportOBJOptionsKit const & in_kit) const;
5050 
5054  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
5055 
5060  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
5061 
5065  bool ShowTextureFolder(UTF8 & out_path) const;
5066 
5069  ExportOBJOptionsKit & UnsetTextureFolder();
5070 
5073  ExportOBJOptionsKit & UnsetEverything();
5074  };
5075 
5077  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
5078  {
5079  public:
5082 
5085  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
5086 
5090 
5091  virtual ~ExportU3DOptionsKit();
5092 
5093  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
5094  HPS::Type ObjectType() const { return staticType; }
5095 
5099  static ExportU3DOptionsKit GetDefault();
5100 
5103  void Set(ExportU3DOptionsKit const & in_kit);
5104 
5107  void Show(ExportU3DOptionsKit & out_kit) const;
5108 
5112  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
5113 
5117  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
5118 
5121  bool Empty() const;
5122 
5126  bool Equals(ExportU3DOptionsKit const & in_kit) const;
5127 
5131  bool operator==(ExportU3DOptionsKit const & in_kit) const;
5132 
5136  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
5137 
5138 
5144  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
5145 
5150  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
5151 
5152 
5155  ExportU3DOptionsKit & UnsetVersion();
5156 
5159  ExportU3DOptionsKit & UnsetCompression();
5160 
5163  ExportU3DOptionsKit & UnsetEverything();
5164 
5165 
5169  bool ShowVersion(U3D::Version & out_version) const;
5170 
5174  bool ShowCompression(unsigned char & out_level) const;
5175  };
5176 
5178  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
5179  {
5180  public:
5183 
5186  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
5187 
5191 
5192  virtual ~ExportXMLOptionsKit();
5193 
5194  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
5195  HPS::Type ObjectType() const { return staticType; }
5196 
5200  static ExportXMLOptionsKit GetDefault();
5201 
5204  void Set(ExportXMLOptionsKit const & in_kit);
5205 
5208  void Show(ExportXMLOptionsKit & out_kit) const;
5209 
5213  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
5214 
5218  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
5219 
5222  bool Empty() const;
5223 
5227  bool Equals(ExportXMLOptionsKit const & in_kit) const;
5228 
5232  bool operator==(ExportXMLOptionsKit const & in_kit) const;
5233 
5237  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
5238 
5239 
5245  ExportXMLOptionsKit & SetMetadata(bool in_state);
5246 
5252  ExportXMLOptionsKit & SetTransformations(bool in_state);
5253 
5259  ExportXMLOptionsKit & SetMaterials(bool in_state);
5260 
5261 
5264  ExportXMLOptionsKit & UnsetMetadata();
5265 
5268  ExportXMLOptionsKit & UnsetTransformations();
5269 
5272  ExportXMLOptionsKit & UnsetMaterials();
5273 
5276  ExportXMLOptionsKit & UnsetEverything();
5277 
5278 
5282  bool ShowMetadata(bool & out_state) const;
5283 
5287  bool ShowTransformations(bool & out_state) const;
5288 
5292  bool ShowMaterials(bool & out_state) const;
5293  };
5294 #endif
5295 
5296 #if !defined(TARGET_OS_ANDROID)
5297 
5298  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
5299  {
5300  public:
5303 
5307 
5311 
5312  virtual ~ExportIGESOptionsKit();
5313 
5314  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
5315  HPS::Type ObjectType() const { return staticType; }
5316 
5320  static ExportIGESOptionsKit GetDefault();
5321 
5324  void Set(ExportIGESOptionsKit const & in_kit);
5325 
5328  void Show(ExportIGESOptionsKit & out_kit) const;
5329 
5333  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
5334 
5338  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
5339 
5342  bool Empty() const;
5343 
5347  bool Equals(ExportIGESOptionsKit const & in_kit) const;
5348 
5352  bool operator==(ExportIGESOptionsKit const & in_kit) const;
5353 
5357  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
5358 
5359 
5365  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5366 
5372  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
5373 
5379  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
5380 
5386  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
5387 
5393  ExportIGESOptionsKit & SetTessellation(bool in_state);
5394 
5398  ExportIGESOptionsKit & SetApplication(char const * in_name);
5399 
5403  ExportIGESOptionsKit & SetVersion(char const * in_version);
5404 
5405 
5408  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
5409 
5412  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
5413 
5416  ExportIGESOptionsKit & UnsetSolidsAsFaces();
5417 
5420  ExportIGESOptionsKit & UnsetHiddenObjects();
5421 
5424  ExportIGESOptionsKit & UnsetTessellation();
5425 
5428  ExportIGESOptionsKit & UnsetApplication();
5429 
5432  ExportIGESOptionsKit & UnsetVersion();
5433 
5436  ExportIGESOptionsKit & UnsetEverything();
5437 
5438 
5442  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5443 
5447  bool ShowFacetedAsWireframe(bool & out_state) const;
5448 
5452  bool ShowSolidsAsFaces(bool & out_state) const;
5453 
5457  bool ShowHiddenObjects(bool & out_state) const;
5458 
5462  bool ShowTessellation(bool & out_state) const;
5463 
5467  bool ShowApplication(UTF8 & out_name) const;
5468 
5472  bool ShowVersion(UTF8 & out_version) const;
5473  };
5474 
5476  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5477  {
5478  public:
5481 
5485 
5489 
5490  virtual ~ExportParasolidOptionsKit();
5491 
5492  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5493  HPS::Type ObjectType() const { return staticType; }
5494 
5498  static ExportParasolidOptionsKit GetDefault();
5499 
5502  void Set(ExportParasolidOptionsKit const & in_kit);
5503 
5506  void Show(ExportParasolidOptionsKit & out_kit) const;
5507 
5511  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5512 
5516  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5517 
5520  bool Empty() const;
5521 
5525  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5526 
5530  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5531 
5535  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5536 
5537 
5543  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5544 
5550  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5551 
5557  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5558 
5562  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5563 
5567  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5568 
5574  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5575 
5578  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5579 
5582  ExportParasolidOptionsKit & UnsetTessellation();
5583 
5586  ExportParasolidOptionsKit & UnsetHiddenObjects();
5587 
5590  ExportParasolidOptionsKit & UnsetApplication();
5591 
5594  ExportParasolidOptionsKit & UnsetVersion();
5595 
5598  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5599 
5602  ExportParasolidOptionsKit & UnsetEverything();
5603 
5604 
5608  bool ShowSolidsAsFaces(bool & out_state) const;
5609 
5613  bool ShowTessellation(bool & out_state) const;
5614 
5618  bool ShowHiddenObjects(bool & out_state) const;
5619 
5623  bool ShowApplication(UTF8 & out_name) const;
5624 
5628  bool ShowVersion(UTF8 & out_version) const;
5629 
5633  bool ShowExplodeMultiBodies(bool& out_state) const;
5634  };
5635 
5637  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5638  {
5639  public:
5642 
5646 
5650 
5651  virtual ~ExportSTEPOptionsKit();
5652 
5653  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5654  HPS::Type ObjectType() const { return staticType; }
5655 
5659  static ExportSTEPOptionsKit GetDefault();
5660 
5663  void Set(ExportSTEPOptionsKit const & in_kit);
5664 
5667  void Show(ExportSTEPOptionsKit & out_kit) const;
5668 
5672  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5673 
5677  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5678 
5681  bool Empty() const;
5682 
5686  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5687 
5691  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5692 
5696  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5697 
5698 
5704  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5705 
5711  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5712 
5718  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5719 
5725  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5726 
5730  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5731 
5735  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5736 
5740  ExportSTEPOptionsKit & SetPMI(bool in_state);
5741 
5745  ExportSTEPOptionsKit & SetCurves(bool in_state);
5746 
5750  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5751 
5755  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5756 
5760  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5761 
5764  ExportSTEPOptionsKit & UnsetFormat();
5765 
5768  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5769 
5772  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5773 
5776  ExportSTEPOptionsKit & UnsetNameShortening();
5777 
5780  ExportSTEPOptionsKit & UnsetApplication();
5781 
5784  ExportSTEPOptionsKit & UnsetVersion();
5785 
5788  ExportSTEPOptionsKit & UnsetPMI();
5789 
5792  ExportSTEPOptionsKit & UnsetCurves();
5793 
5796  ExportSTEPOptionsKit & UnsetAttributes();
5797 
5800  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5801 
5804  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5805 
5808  ExportSTEPOptionsKit & UnsetEverything();
5809 
5810 
5814  bool ShowFormat(STEP::Format & out_format) const;
5815 
5819  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5820 
5824  bool ShowFacetedAsWireframe(bool & out_state) const;
5825 
5829  bool ShowNameShortening(bool & out_state) const;
5830 
5834  bool ShowApplication(UTF8 & out_name) const;
5835 
5839  bool ShowVersion(UTF8 & out_version) const;
5840 
5844  bool ShowPMI(bool & out_state) const;
5845 
5849  bool ShowCurves(bool & out_state) const;
5850 
5854  bool ShowAttributes(bool & out_state) const;
5855 
5859  bool ShowPMIWithSemantic(bool & out_state) const;
5860 
5864  bool ShowPMIAsTessellated(bool & out_state) const;
5865  };
5866 
5868  class EXCHANGE_API ExportGLTFOptionsKit : public SprocketKit
5869  {
5870  public:
5873 
5877 
5881 
5882  virtual ~ExportGLTFOptionsKit();
5883 
5884  static const HPS::Type staticType = HPS::Type::ExchangeExportGLTFOptionsKit;
5885  HPS::Type ObjectType() const { return staticType; }
5886 
5890  static ExportGLTFOptionsKit GetDefault();
5891 
5894  void Set(ExportGLTFOptionsKit const & in_kit);
5895 
5898  void Show(ExportGLTFOptionsKit & out_kit) const;
5899 
5903  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit const & in_kit);
5904 
5908  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit && in_that);
5909 
5912  bool Empty() const;
5913 
5917  bool Equals(ExportGLTFOptionsKit const & in_kit) const;
5918 
5922  bool operator==(ExportGLTFOptionsKit const & in_kit) const;
5923 
5927  bool operator!=(ExportGLTFOptionsKit const & in_kit) const;
5928 
5929 
5937  ExportGLTFOptionsKit & SetTextureFolder(char const * in_name);
5938 
5939 
5945  ExportGLTFOptionsKit & SetAscii(bool in_state);
5946 
5947 
5950  ExportGLTFOptionsKit & UnsetTextureFolder();
5951 
5954  ExportGLTFOptionsKit & UnsetAscii();
5955 
5958  ExportGLTFOptionsKit & UnsetEverything();
5959 
5960 
5964  bool ShowTextureFolder(UTF8 & out_path) const;
5965 
5969  bool ShowAscii(bool & out_state) const;
5970  };
5971 #endif
5972 
5974  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5975  {
5976  public:
5979 
5983 
5987 
5988  virtual ~TessellationOptionsKit();
5989 
5990  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5991  HPS::Type ObjectType() const { return staticType; }
5992 
5996  static TessellationOptionsKit GetDefault();
5997 
6000  void Set(TessellationOptionsKit const & in_kit);
6001 
6004  void Show(TessellationOptionsKit & out_kit) const;
6005 
6009  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
6010 
6014  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
6015 
6018  bool Empty() const;
6019 
6023  bool Equals(TessellationOptionsKit const & in_kit) const;
6024 
6028  bool operator==(TessellationOptionsKit const & in_kit) const;
6029 
6034  bool operator!=(TessellationOptionsKit const & in_kit) const;
6035 
6036 
6041  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
6042 
6050  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
6051 
6062  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
6063 
6068  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
6069 
6073  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
6074 
6075 
6078  TessellationOptionsKit & UnsetLevel();
6079 
6082  TessellationOptionsKit & UnsetAccuracy();
6083 
6086  TessellationOptionsKit & UnsetUVPointPreservation();
6087 
6090  TessellationOptionsKit & UnsetMaximumEdgeLength();
6091 
6094  TessellationOptionsKit & UnsetEverything();
6095 
6096 
6104  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
6105 
6112  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
6113 
6117  bool ShowUVPointPreservation(bool & out_state) const;
6118 
6122  bool ShowMaximumEdgeLength(double & out_length) const;
6123  };
6124 
6130  class EXCHANGE_API CommonMeasurementOperator : public Operator
6131  {
6132  public:
6133  enum class Tags
6134  {
6135  Name = 0,
6136  MeasurementType,
6137  Radius,
6138  Inverted,
6139  VectorX,
6140  VectorY,
6141  VectorZ,
6142  };
6143 
6145 
6146  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
6147 
6149  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
6150 
6151  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
6152  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
6153 
6154  Exchange::CADModel GetCADModel() const;
6155  void SetCADModel(Exchange::CADModel const & in_cad_model);
6156 
6158  size_t GetPrecision() const;
6159 
6162  void SetPrecision(size_t in_precision);
6163 
6165  MaterialMappingKit GetMaterial() const;
6166 
6169  void SetMaterial(MaterialMappingKit const & in_material_mapping);
6170 
6172  TextAttributeKit GetTextAttributes() const;
6173 
6176  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
6177 
6179  SegmentKey GetMeasurementSegment() const;
6180 
6182  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
6183 
6185  void DeleteMeasurements();
6186 
6187  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
6188  {
6189  public:
6192  {
6193  channel = GetClassID();
6194  consumable = false;
6195  }
6196 
6197  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
6198  {
6199  channel = GetClassID();
6200  consumable = false;
6201  measurement_key = in_measurement_key;
6202  view = in_view;
6203  }
6204 
6207  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
6208  {
6209  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
6210  {
6211  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
6212  measurement_key = that.measurement_key;
6213  view = that.view;
6214  }
6215  else
6216  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
6217  }
6218 
6220 
6223  Event * Clone() const
6224  {
6225  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
6226  return new_event;
6227  }
6228 
6229  Key measurement_key;
6230  View view;
6231  };
6232 
6233  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
6234  {
6235  public:
6238  {
6239  channel = GetClassID();
6240  consumable = false;
6241  }
6242 
6243  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
6244  {
6245  channel = GetClassID();
6246  consumable = false;
6247  measurement_name = in_measurement_name;
6248  view = in_view;
6249  }
6250 
6253  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
6254  {
6255  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
6256  {
6257  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
6258  measurement_name = that.measurement_name;
6259  view = that.view;
6260  }
6261  else
6262  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
6263  }
6264 
6266 
6269  Event * Clone() const
6270  {
6271  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
6272  return new_event;
6273  }
6274 
6275  UTF8 measurement_name;
6276  View view;
6277  };
6278 
6279  protected:
6280  Exchange::CADModel cad_model;
6281  size_t measurement_precision;
6282  UTF8 units;
6283  MaterialMappingKit materials;
6284  TextAttributeKit text_attributes;
6285  SegmentKey measurement_segment;
6286  GlyphDefinition left_arrow;
6287  GlyphDefinition right_arrow;
6288  SelectionOptionsKit selection_options;
6289  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
6290  Vector camera_direction;
6291  PortfolioKey portfolio;
6292  SegmentKey style_segment;
6293  HighlightOptionsKit highlight_options;
6294 
6295  static size_t length_measurement_index;
6296  static size_t radius_measurement_index;
6297  static size_t distance_measurement_index;
6298  static size_t angle_measurement_index;
6299 
6300  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
6301  void GetUnits();
6302  void SetGlyphColor();
6303  void GetCameraDirection();
6304  void SetupConstructionSegment();
6305  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
6306  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
6307  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
6308  float GetModelScale(Exchange::Component const & component);
6309  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
6310  };
6311 
6365  {
6366  public:
6367  enum class MeasurementType
6368  {
6369  PointToPoint,
6370  EdgeAndRadius,
6371  FeatureToFeature,
6372  FaceAngle,
6373  };
6374 
6376 
6377  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
6378 
6380  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
6381 
6382  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
6383  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
6384 
6389  virtual bool OnMouseDown(MouseState const & in_state) override;
6390 
6394  virtual bool OnMouseUp(MouseState const & in_state) override;
6395 
6401  virtual bool OnMouseMove(MouseState const & in_state) override;
6402 
6407  virtual bool OnTouchDown(TouchState const & in_state) override;
6408 
6412  virtual bool OnTouchUp(TouchState const & in_state) override;
6413 
6419  virtual bool OnTouchMove(TouchState const & in_state) override;
6420 
6424  virtual bool OnKeyDown(KeyboardState const & in_state) override;
6425 
6428  void SetMeasurementType(MeasurementType in_measurement_type);
6429 
6432  MeasurementType GetMeasurementType();
6433 
6436  void SetMouseOverHighlighting(bool in_highlighting);
6437 
6441  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
6442 
6445  bool GetMouseOverHighlighting();
6446 
6449  HighlightOptionsKit GetHighlightOptions();
6450 
6453  bool IsMeasurementActive();
6454 
6456  void DeleteLastMeasurement();
6457 
6458  private:
6459  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
6460  {
6461  Circle,
6462  Line,
6463  Generic,
6464  };
6465 
6466  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
6467  {
6468  public:
6469  Surface();
6470 
6471  enum class SurfaceType
6472  {
6473  Plane,
6474  ConeOrCylinder,
6475  Unsupported,
6476  };
6477 
6478  SurfaceType surface_type; //the type of surface being measured
6479  Point center; //the center point of the surface
6480  Vector normal; //the center line of surfaces of type Cylinder or Cone
6481  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
6482  ComponentPath path; //the ComponentPath to this surface
6483  };
6484 
6485  //bookkeeping
6486  MeasurementType measurement_type; //the type of measurement to be inserted
6487  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
6488  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
6489  TouchID current_touch_id; //the ID of the touch being processed
6490  SegmentKey current_measurement; //segment of the measurement being inserted / edited
6491  bool operator_active; //whether a measurement is in progress
6492  bool end_measurement; //whether we should end the current measurement
6493  CanvasArray canvases; //canvases related to the view where this operator is attached
6494 
6495  //measurement anchors
6496  size_t anchors; //valid for point-to-point and face-angle measurements
6497  bool anchors_in_place; //true if all the anchors have been placed
6498  Point first_click_position; //position of the first anchor
6499  Point second_click_position; //position of the second anchor
6500 
6501  //geometry for linear measurements
6502  MarkerKey anchor_one; //marker corresponding to the start of the measurement
6503  MarkerKey anchor_two; //marker corresponding to the end of the measurement
6504  LineKey distance_line; //a line representing the distance measured
6505  LineKey leader_line_one; //line connecting the first anchor point to the distance line
6506  LineKey leader_line_two; //line connecting the second anchor point to the distance line
6507  Point distance_point_one; //intersection of leader_line_one and distance_line
6508  Point distance_point_two; //intersection of leader_line_two and distance_line
6509  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
6510  TextKey text; //text representing the measurement and units
6511  UTF8 text_string; //the contents of the text
6512  Vector measurement_direction; //the direction of the measurement
6513  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
6514  Vector explicit_direction; //used if use_explicit_direction is true
6515 
6516  //geometry for radius measurement
6517  MarkerKey center_marker; //marker representing the center of the circle
6518  Point circle_center; //circle center
6519  float radius; //circle radius
6520 
6521  //edge specific data
6522  LineKey edge_line; //the edge being measured
6523  double edge_length; //length of the measured edge
6524  EdgeType edge_type; //the type of edge being measured
6525 
6526  //feature-to-feature specific data
6527  Surface surface_one; //data related to first selected surface
6528  Surface surface_two; //data related to second selected surface
6529  Plane measurement_plane; //the measurement plane
6530  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
6531 
6532  //angle specific data
6533  Vector leader_line_one_direction; //the direction of the first leader line
6534  Vector leader_line_two_direction; //the direction of the second leader line
6535  Vector first_face_normal; //the normal of the first selected face
6536  Vector second_face_normal; //the normal of the second selected face
6537  bool inverted_measurement; //the smallest of the two possible angles is always chosen. If the user wants the other angle, the measurement is marked as 'inverted'
6538  CircularArcKey measurement_arc; //an arc representing the measured angle
6539  LineKey line_to_leader_line; //line extending from one anchor to a leader line
6540  Vector mid_point_direction;
6541 
6542  //selection kits
6543  SelectionOptionsKit point_to_point_selection;
6544  SelectionOptionsKit edge_radius_selection;
6545  SelectionOptionsKit feature_to_feature_selection;
6546  SelectionOptionsKit angle_selection;
6547 
6548  //highlighting
6549  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
6550  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
6551  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
6552  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
6553  KeyPath highlighted_path; //highlighted_path
6554  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
6555  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
6556 
6557  //input handling
6558  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
6559  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
6560  bool InputUp(WindowKey & in_window);
6561  void ResetMeasurement();
6562 
6563  //inserting measurements
6564  void InsertPointToPointMeasurement(Point const & in_world_point);
6565  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
6566  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
6567  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
6568  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
6569  void InvertMeasuredAngle(WindowKey & in_window);
6570  void AdjustLineToCursor(Point const & cursor_position);
6571 
6572  //saving measurements
6573  void TagMeasurement();
6574  void TagPointToPointMeasurement();
6575  void TagEdgeMeasurement();
6576  void TagRadiusMeasurement();
6577  void TagGenericEdgeMeasurement();
6578  void TagFeatureToFeatureMeasurement();
6579  void TagAngleMeasurement();
6580 
6581  //restoring measurements
6582  void RestoreMeasurement(SegmentKey const & measurement_segment);
6583  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6584  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6585  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6586  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6587  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6588  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6589 
6590  //topology functions
6591  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6592  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6593  void PlaneToCenterLineDistance();
6594  void PlaneToPlaneDistance();
6595  void LineToLineDistance();
6596  float LineSegmentDistance(Point & p0, Point & p1, Point & q0, Point & q1, LineKey & normal_one, LineKey & normal_two, Point & out_point_on_edge, Point & out_point_on_center_line, bool clamp = true);
6597  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6598  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6599  bool IsPlane(Exchange::Component const & face_component);
6600  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6601  };
6602 
6603 private:
6605  Exchange();
6606 };
6607 
6608 }
6609 
6610 #endif
Definition: hps.h:6514
Definition: hps.h:85
Definition: sprk_exchange.h:4654
Level
Definition: sprk_exchange.h:1243
ConstructionEntities
Definition: sprk_exchange.h:1406
HPS::Type ObjectType() const
Definition: sprk_exchange.h:364
HPS::Type ObjectType() const
Definition: sprk_exchange.h:845
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1357
Definition: sprk.h:1102
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5654
Definition: sprk_exchange.h:1540
Definition: sprk_exchange.h:6130
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5012
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5315
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:6118
Units
Definition: sprk_exchange.h:74
Definition: sprk.h:68
Simplification
Definition: sprk_exchange.h:3552
Definition: sprk.h:936
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:6149
Definition: sprk_exchange.h:982
Version
Definition: sprk_exchange.h:1427
Definition: sprk_exchange.h:3841
Definition: sprk_exchange.h:1253
intptr_t GetChannel() const
Definition: hps.h:6631
Definition: sprk_exchange.h:1083
SurfaceType
Definition: sprk_exchange.h:1175
Definition: hps.h:1838
Format
Definition: sprk_exchange.h:1344
Definition: sprk_exchange.h:5178
Definition: sprk.h:1071
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5991
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6980
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6956
Definition: hps.h:49288
Format
Definition: sprk_exchange.h:1545
Definition: hps.h:8044
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6950
Type
Definition: sprk_exchange.h:1234
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4183
Definition: hps.h:16810
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1494
Definition: sprk_exchange.h:782
Definition: sprk_exchange.h:921
Definition: sprk_exchange.h:602
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1837
HPS::Type ObjectType() const
Definition: sprk_exchange.h:809
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5195
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5094
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4330
HPS::Type ObjectType() const
Definition: sprk_exchange.h:258
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1112
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:6207
Definition: sprk_exchange.h:5868
Definition: sprk_exchange.h:1814
Definition: sprk_exchange.h:541
HPS::Type ObjectType() const
Definition: sprk_exchange.h:420
HPS::Type ObjectType() const
Definition: sprk_exchange.h:950
Definition: sprk_exchange.h:4520
Merging
Definition: sprk_exchange.h:3561
Definition: sprk_exchange.h:1439
Field
Definition: sprk_exchange.h:1334
Definition: sprk_exchange.h:4995
Definition: hps.h:49186
Definition: hps.h:42550
Definition: sprk_exchange.h:4418
Definition: sprk_exchange.h:3574
Definition: sprk_exchange.h:360
Event * Clone() const
Definition: sprk_exchange.h:6269
Limit
Definition: sprk_exchange.h:1258
Definition: hps.h:4697
Definition: sprk_exchange.h:473
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3864
TessellationLevel
Definition: sprk_exchange.h:1307
Definition: sprk_exchange.h:1229
Definition: sprk_exchange.h:4811
Definition: sprk_exchange.h:135
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5885
Definition: sprk_exchange.h:1329
Definition: sprk_exchange.h:4313
Definition: hps.h:4636
HPS::Type ObjectType() const
Definition: sprk_exchange.h:306
Definition: hps.h:7396
Definition: hps.h:48657
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4435
Definition: sprk_exchange.h:731
UnloadMode
Definition: sprk_exchange.h:91
Definition: hps.h:44563
Definition: hps.h:49073
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:1222
Definition: sprk_exchange.h:5077
Definition: sprk_exchange.h:1293
Definition: hps.h:16183
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6936
Definition: sprk_exchange.h:1422
HPS::Type ObjectType() const
Definition: sprk_exchange.h:477
SessionColor
Definition: sprk_exchange.h:1381
Definition: sprk.h:2654
Definition: hps.h:49395
LoadStatus
Definition: sprk_exchange.h:106
Definition: hps.h:45771
Definition: hps.h:48164
CurveType
Definition: sprk_exchange.h:1198
Definition: sprk_exchange.h:875
Definition: hps.h:6598
Definition: hps.h:14431
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6948
Definition: sprk_exchange.h:6364
Definition: sprk.h:1317
BRepCompression
Definition: sprk_exchange.h:1362
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5493
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:1148
Definition: sprk.h:3026
ComponentType
Definition: sprk.h:2660
Accuracy
Definition: sprk_exchange.h:1275
Definition: sprk_exchange.h:4166
Definition: sprk_exchange.h:5298
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:6253
Definition: sprk_exchange.h:828
Definition: sprk.h:3732
FamilyTable
Definition: sprk_exchange.h:1394
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4828
Content
Definition: sprk_exchange.h:1298
Definition: sprk_exchange.h:2039
Definition: sprk.h:3832
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4537
Definition: sprk_exchange.h:302
static MouseButtons ButtonLeft()
Definition: hps.h:48775
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:6380
Event * Clone() const
Definition: sprk_exchange.h:6223
Definition: hps.h:7962
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1011
BIMRelationshipType
Definition: sprk_exchange.h:123
Definition: sprk_exchange.h:1376
AccurateEdges
Definition: sprk_exchange.h:3543
HPS::Type ObjectType() const
Definition: sprk_exchange.h:629
HPS::Type ObjectType() const
Definition: sprk_exchange.h:157
Definition: hps.h:9675
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1065
Definition: sprk_exchange.h:1036
Definition: hps.h:25090
Healing
Definition: sprk_exchange.h:3534
Definition: sprk.h:3919
Definition: hps.h:31523
PhysicalProperties
Definition: sprk_exchange.h:1442
HPS::Type ObjectType() const
Definition: sprk_exchange.h:574
ImportMode
Definition: sprk_exchange.h:1163
Definition: sprk_exchange.h:1456
Definition: hps.h:586
Definition: sprk.h:1945
Definition: sprk_exchange.h:3529
HPS::Type ObjectType() const
Definition: sprk_exchange.h:758
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:5476
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2062
Definition: sprk_exchange.h:225
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3597
Definition: hps.h:42046
Version
Definition: sprk_exchange.h:1316
Definition: sprk_exchange.h:5974
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4671
Definition: hps.h:43181
Definition: sprk_exchange.h:416
Definition: sprk_exchange.h:5637