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 Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas const & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
437 
442  void Tessellate(TessellationOptionsKit const & in_options);
443 
450  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
451  };
452 
455  class EXCHANGE_API Capture : public HPS::Capture
456  {
457  public:
459  Capture();
460 
464  Capture(Component const & in_that);
465 
469  Capture(HPS::Capture const & in_that);
470 
473  Capture(Exchange::Capture const & in_that);
474 
477  Capture(Exchange::Capture && in_that);
478 
479  virtual ~Capture();
480 
481  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
482  HPS::Type ObjectType() const { return staticType; }
483 
484 #if !defined(_MSC_VER) || _MSC_VER >= 1900
485  Capture & operator=(Exchange::Capture const & in_that) = default;
486 #endif
487 
491  Capture & operator=(Exchange::Capture && in_that);
492 
493 
496  A3DEntity * GetExchangeEntity() const;
497 
498  /* Activates this capture */
499  HPS::View Activate(HPS::ComponentPath const & in_capture_path = HPS::ComponentPath());
500  };
501 
504  class EXCHANGE_API Filter : public HPS::Filter
505  {
506  public:
508  Filter();
509 
513  Filter(Component const & in_that);
514 
518  Filter(HPS::Filter const & in_that);
519 
522  Filter(Exchange::Filter const & in_that);
523 
526  Filter(Exchange::Filter && in_that);
527 
528  virtual ~Filter();
529 
530  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
531  HPS::Type ObjectType() const { return staticType; }
532 
533 #if !defined(_MSC_VER) || _MSC_VER >= 1900
534  Filter & operator=(Exchange::Filter const & in_that) = default;
535 #endif
536 
540  Filter & operator=(Exchange::Filter && in_that);
541 
542 
545  A3DEntity * GetExchangeEntity() const;
546  };
547 
549  class EXCHANGE_API Factory : public Sprocket
550  {
551  public:
556  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
557 
563  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
564 
568  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
569 
576  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
577 
581  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
582 
587  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
588 
589  private:
591  Factory();
592  };
593 
595  class EXCHANGE_API ImportNotifier : public IONotifier
596  {
597  public:
599  ImportNotifier();
600 
603  ImportNotifier(ImportNotifier const & in_that);
604 
609  ImportNotifier(IONotifier const & in_that);
610 
614  ImportNotifier(ImportNotifier && in_that);
615 
619  ImportNotifier & operator=(ImportNotifier && in_that);
620 
621  virtual ~ImportNotifier();
622 
623  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
624  HPS::Type ObjectType() const { return staticType; };
625 
629  ImportNotifier & operator=(ImportNotifier const & in_that);
630 
633  void Assign(ImportNotifier const & in_that);
634 
637  Exchange::CADModel GetCADModel() const;
638 
644  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
645 
648  Time GetImportTime() const;
649 
652  Time GetParseTime() const;
653  };
654 
656  class EXCHANGE_API TranslationNotifier : public IONotifier
657  {
658  public:
661 
664  TranslationNotifier(TranslationNotifier const & in_that);
665 
670  TranslationNotifier(IONotifier const & in_that);
671 
676 
680  TranslationNotifier & operator=(TranslationNotifier && in_that);
681 
682  virtual ~TranslationNotifier();
683 
684  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
685  HPS::Type ObjectType() const { return staticType; };
686 
690  TranslationNotifier & operator=(TranslationNotifier const & in_that);
691 
694  void Assign(TranslationNotifier const & in_that);
695 
698  Exchange::ParasolidEntityArray GetParasolidParts() const;
699 
702  HPS::Time GetImportTime() const;
703 
706  HPS::Time GetTranslationTime() const;
707  };
708 
710  class EXCHANGE_API ExportNotifier : public IONotifier
711  {
712  public:
714  ExportNotifier();
715 
718  ExportNotifier(ExportNotifier const & in_that);
719 
724  ExportNotifier(IONotifier const & in_that);
725 
729  ExportNotifier(ExportNotifier && in_that);
730 
734  ExportNotifier & operator=(ExportNotifier && in_that);
735 
736  virtual ~ExportNotifier();
737 
738  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
739  HPS::Type ObjectType() const { return staticType; };
740 
744  ExportNotifier & operator=(ExportNotifier const & in_that);
745 
748  void Assign(ExportNotifier const & in_that);
749 
753  A3DAsmModelFile * GetModelFile() const;
754  };
755 
757  class EXCHANGE_API ReloadNotifier : public IONotifier
758  {
759  public:
761  ReloadNotifier();
762 
765  ReloadNotifier(ReloadNotifier const & in_that);
766 
771  ReloadNotifier(IONotifier const & in_that);
772 
776  ReloadNotifier(ReloadNotifier && in_that);
777 
781  ReloadNotifier & operator=(ReloadNotifier && in_that);
782 
783  virtual ~ReloadNotifier();
784 
785  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
786  HPS::Type ObjectType() const { return staticType; };
787 
791  ReloadNotifier & operator=(ReloadNotifier const & in_that);
792 
795  void Assign(ReloadNotifier const & in_that);
796  };
797 
798 
799  class ImportOptionsKit;
800  class ModelFileImportOptionsKit;
801 
802 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
803  class Export3MFOptionsKit;
804  class ExportFBXOptionsKit;
805  class ExportACISOptionsKit;
806  class ExportJTOptionsKit;
807  class ExportPRCOptionsKit;
808  class ExportSTLOptionsKit;
809  class ExportOBJOptionsKit;
810  class ExportU3DOptionsKit;
811  class ExportXMLOptionsKit;
812  class ExportGLTFOptionsKit;
813 #endif
814 
815 #if !defined(TARGET_OS_ANDROID)
816  class ExportSTEPOptionsKit;
817  class ExportIGESOptionsKit;
818 #endif
819 
822  enum class BRepMode
823  {
826  TessellationOnly,
829  BRepOnly,
832  BRepAndTessellation,
833  };
834 
837  enum class ImportMode
838  {
841  Complete,
844  Incremental,
845  };
846 
849  enum class SurfaceType
850  {
851  Blend01,
852  Blend02,
853  Blend03,
854  Blend04,
855  NURBS,
856  Cone,
857  Cylinder,
858  Offset,
859  Pipe,
860  Plane,
861  Ruled,
862  Sphere,
863  Revolution,
864  Extrusion,
865  FromCurve,
866  Torus,
867  Transform,
868  };
869 
872  enum class CurveType
873  {
874  Blend,
875  NURBS,
876  Circle,
877  Composite,
878  CurveOnSurface,
879  Ellipse,
880  Equation,
881  Helix,
882  Hyperbola,
883  Intersection,
884  Line,
885  Offset,
886  Parabola,
887  Polyline,
888  Transform,
889  };
890 
891  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
892  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
893 
897  {
898  PMIOnly,
899  ModelAndPMI
900  };
901 
903  class EXCHANGE_API Tessellation
904  {
905  public:
908  enum class Type
909  {
910  Standard,
911  Custom
912  };
913 
914 
917  enum class Level
918  {
919  ExtraLow,
920  Low,
921  Medium,
922  High,
923  ExtraHigh,
924  };
925 
927  class EXCHANGE_API Chord
928  {
929  public:
932  enum class Limit
933  {
936  Ratio,
939  Height
940  };
941 
942  private:
944  Chord();
945  };
946 
949  enum class Accuracy
950  {
953  Standard,
956  Accurate,
958  GridAccurate
959  };
960 
961  private:
963  Tessellation();
964  };
965 
967  class EXCHANGE_API JT
968  {
969  public:
972  enum class Content
973  {
974  Geometry,
975  Tessellation,
976  GeometryAndTessellation
977  };
978 
981  enum class TessellationLevel
982  {
983  Low,
984  Medium,
985  High,
986  };
987 
990  enum class Version
991  {
992  JT81,
993  JT95,
994  JT100,
995  };
996 
997  private:
999  JT();
1000  };
1001 
1003  class EXCHANGE_API STEP
1004  {
1005  public:
1008  enum class Field
1009  {
1010  ProductName,
1011  NextAssemblyUsageOccurrenceID,
1012  NextAssemblyUsageOccurrenceName,
1013  NextAssemblyUsageOccurrenceDescription
1014  };
1015 
1018  enum class Format
1019  {
1020  AP203,
1021  AP214,
1022  AP242,
1023  };
1024 
1025  private:
1027  STEP();
1028  };
1029 
1031  class EXCHANGE_API PRC
1032  {
1033  public:
1036  enum class BRepCompression
1037  {
1038  None,
1039  Low,
1040  Medium,
1041  High
1042  };
1043 
1044  private:
1046  PRC();
1047  };
1048 
1050  class EXCHANGE_API ProE
1051  {
1052  public:
1055  enum class SessionColor
1056  {
1058  LastCreoVersion,
1060  ExchangeDefault,
1063  UserDefined
1064  };
1065 
1068  enum class FamilyTable
1069  {
1071  BRepOnly,
1073  BRepOrTessellation,
1075  BRepOrTessellationOrGeneric
1076  };
1077 
1081  {
1083  On,
1085  Off,
1087  AsDatum,
1088  };
1089 
1090  private:
1092  ProE();
1093  };
1094 
1096  class EXCHANGE_API U3D
1097  {
1098  public:
1101  enum class Version
1102  {
1103  ECMA1,
1104  ECMA3
1105  };
1106 
1107  private:
1109  U3D();
1110  };
1111 
1113  class EXCHANGE_API Revit
1114  {
1115  public:
1117  {
1119  NotComputed,
1121  Computed
1122  };
1123 
1124  private:
1126  Revit();
1127  };
1128 
1130  class EXCHANGE_API Configuration : public HPS::Sprocket
1131  {
1132  public:
1134  Configuration();
1135 
1138  Configuration(char const * in_name);
1139 
1144  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1145 
1149  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1150 
1153  Configuration(Configuration const & in_configuration);
1154 
1158  Configuration(Configuration && in_that);
1159 
1163  Configuration & operator=(Configuration && in_that);
1164 
1165  virtual ~Configuration();
1166 
1167  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1168  HPS::Type ObjectType() const { return staticType; }
1169 
1170 
1173  void Set(Configuration const & in_kit);
1174 
1177  void Show(Configuration & out_kit) const;
1178 
1182  Configuration & operator=(Configuration const & in_kit);
1183 
1186  bool Empty() const;
1187 
1191  bool Equals(Configuration const & in_kit) const;
1192 
1196  bool operator==(Configuration const & in_kit) const;
1197 
1201  bool operator!=(Configuration const & in_kit) const;
1202 
1203 
1206  HPS::UTF8 GetName() const;
1207 
1210  ConfigurationArray GetSubconfigurations() const;
1211  };
1212 
1214  class EXCHANGE_API File
1215  {
1216  public:
1219  enum class Format
1220  {
1221  Unsupported,
1222  ACIS,
1223  CADDS,
1224  CATIAV4,
1225  CATIAV5,
1226  CGR,
1227  COLLADA,
1228  CreoProE,
1229  DWG,
1230  DXF,
1231  IDEAS,
1232  IFC,
1233  IGES,
1234  Inventor,
1235  JT,
1236  KeyholeMarkupLanguage,
1237  LatticeXVL,
1238  OneSpaceDesigner,
1239  Parasolid,
1240  PDF,
1241  PRC,
1242  Rhino,
1243  NXUnigraphics,
1244  SolidEdge,
1245  SolidWorks,
1246  STEP,
1247  StereoLithography,
1248  ThreeDStudioMax,
1249  ThreeDXML,
1250  Universal3D,
1251  VDAFS,
1252  VRML,
1253  WavefrontObject,
1254  Revit,
1255  GLTF,
1256  DWF,
1257  FBX,
1258  STEPXML,
1259  ThreeMF,
1260  Navisworks,
1261  };
1262 
1264  static Format GetFormat(char const * in_file_name);
1265 
1269  static ConfigurationArray GetConfigurations(char const * in_file_name);
1270 
1282  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);
1283 
1289  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1290 
1297  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1298 
1305  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1306 
1314  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1315 
1322  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1323 
1324 
1331  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1332 
1333 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1334 
1338  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1339 
1345  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1346 
1353  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1354 
1360  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1361 
1366  static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);
1367 
1372  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1373 
1378  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1379 
1385  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1386 
1392  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1393 
1400  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1401 
1408  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1409 
1413  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1414 
1419  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1420 
1424  static ExportNotifier ExportPRC(KeyPath const & in_source);
1425 
1430  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1431 
1436  static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);
1437 
1442  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1443 
1447  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1448 
1453  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1454 
1459  static void ExportGLTF(CADModel const & in_cad_model, char const * in_file_name, ExportGLTFOptionsKit const & in_options);
1460 
1461 #endif
1462 
1463 #if TARGET_OS_ANDROID == 0
1464 
1468  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1469 
1474  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1475 
1480  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1481 #endif
1482 
1483  private:
1485  File();
1486  };
1487 
1489  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1490  {
1491  public:
1494 
1498 
1503 
1507  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1508 
1509  virtual ~NURBSConversionOptionsKit();
1510 
1511  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1512  HPS::Type ObjectType() const { return staticType; }
1513 
1516  void Set(NURBSConversionOptionsKit const & in_kit);
1517 
1520  void Show(NURBSConversionOptionsKit & out_kit) const;
1521 
1525  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1526 
1529  bool Empty() const;
1530 
1534  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1535 
1539  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1540 
1544  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1545 
1549  static NURBSConversionOptionsKit GetDefault();
1550 
1555  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1556 
1561  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1562 
1567  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1568 
1573  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1574 
1579  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1580 
1585  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1586 
1591  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1592 
1598  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1599 
1606  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1607 
1613  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1614 
1621  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1622 
1623 
1626  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1627 
1630  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1631 
1634  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1635 
1638  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1639 
1642  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1643 
1646  NURBSConversionOptionsKit & UnsetParameterization();
1647 
1650  NURBSConversionOptionsKit & UnsetTolerance();
1651 
1654  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1655 
1658  NURBSConversionOptionsKit & UnsetAllowedCurves();
1659 
1662  NURBSConversionOptionsKit & UnsetEverything();
1663 
1664 
1665 
1669  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1670 
1674  bool Show3DCurvesComputation(bool & out_state) const;
1675 
1680  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1681 
1685  bool ShowClosedFaceSplitting(bool & out_state) const;
1686 
1690  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1691 
1695  bool ShowParameterization(bool & out_state) const;
1696 
1700  bool ShowTolerance(double & out_tolerance) const;
1701 
1705  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1706 
1710  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1711  };
1712 
1714  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1715  {
1716  public:
1718  ImportOptionsKit();
1719 
1722  ImportOptionsKit(ImportOptionsKit const & in_kit);
1723 
1727  ImportOptionsKit(ImportOptionsKit && in_that);
1728 
1732  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1733 
1734  virtual ~ImportOptionsKit();
1735 
1736  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1737  HPS::Type ObjectType() const { return staticType; }
1738 
1742  static ImportOptionsKit GetDefault();
1743 
1746  void Set(ImportOptionsKit const & in_kit);
1747 
1750  void Show(ImportOptionsKit & out_kit) const;
1751 
1755  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1756 
1759  bool Empty() const;
1760 
1764  bool Equals(ImportOptionsKit const & in_kit) const;
1765 
1769  bool operator==(ImportOptionsKit const & in_kit) const;
1770 
1774  bool operator!=(ImportOptionsKit const & in_kit) const;
1775 
1776 
1782  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1783 
1789  ImportOptionsKit & SetSolids(bool in_state);
1790 
1796  ImportOptionsKit & SetSurfaces(bool in_state);
1797 
1803  ImportOptionsKit & SetWireframes(bool in_state);
1804 
1810  ImportOptionsKit & SetPMI(bool in_state);
1811 
1818  ImportOptionsKit & SetAttributes(bool in_state);
1819 
1825  ImportOptionsKit & SetHiddenObjects(bool in_state);
1826 
1832  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1833 
1839  ImportOptionsKit & SetActiveFilter(bool in_state);
1840 
1847  ImportOptionsKit& SetConstraintsInfo(bool in_state);
1848 
1856  ImportOptionsKit & SetFeatureTrees(bool in_state);
1857 
1863  ImportOptionsKit & SetDrawings(bool in_state);
1864 
1870  ImportOptionsKit & SetDefaultUnits(Units in_units);
1871 
1877  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1878 
1884  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1885 
1892  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1893 
1900  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1901 
1907  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1908 
1914  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1915 
1923  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1924 
1931  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1932 
1940  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1941 
1949  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1950 
1956  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1957 
1963  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1964 
1971  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1972 
1984  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);
1985 
1991  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1992 
1998  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1999 
2005  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
2006 
2011  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
2012 
2019  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
2020 
2026  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
2027 
2036  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2037 
2046  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2047 
2053  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2054 
2059  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2060 
2067  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2068 
2073  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2074 
2080  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2081 
2086  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2087 
2093  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2094 
2101  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2102 
2109  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2110 
2116  ImportOptionsKit & SetCatiaV5MaterialRendering(bool in_active);
2117 
2125  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2126 
2133  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2134 
2140  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2141 
2147  ImportOptionsKit & SetProECodePageName(char const * in_name);
2148 
2154  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2155 
2161  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2162 
2168  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2169 
2176  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2177 
2184  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2185 
2192  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2193 
2200  ImportOptionsKit & SetProEHomeView(bool in_state);
2201 
2208  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2209 
2216  ImportOptionsKit & SetProEDatum(bool in_state);
2217 
2218 
2225  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2226 
2233  ImportOptionsKit & SetProESkeletons(bool in_state);
2234 
2241  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2242 
2248  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2249 
2255  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2256 
2262  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2263 
2269  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2270 
2276  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2277 
2283  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2284 
2291  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2292 
2298  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2299 
2305  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2306 
2313  ImportOptionsKit & SetIFCEdges(bool in_state);
2314 
2320  ImportOptionsKit & SetIFCMetadata(bool in_state);
2321 
2327  ImportOptionsKit & SetIFCRelationships(bool in_state);
2328 
2334  ImportOptionsKit & SetIFCOpenings(bool in_state);
2335 
2341  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2342 
2348  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2349 
2355  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2356 
2362  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2363 
2369  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2370 
2377  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2378 
2385  ImportOptionsKit & SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);
2386 
2390  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2391 
2403  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2404 
2416  ImportOptionsKit & SetMode(ImportMode in_mode);
2417 
2427  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2428 
2436  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2437 
2444  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2445 
2449  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2450 
2455  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2456 
2457  /* When this option is enabled, translations that are deemed to be especially large compared to the model size are removed from the
2458  * scene graph and instead imported as user data, at the index specified, on the segment where the translation would have been.
2459  * Removing very large translation is useful to avoid visual artifacts due to loss in precision.
2460  * Note that only part of a translation might be extracted.
2461  * If you are adding a model to an existing scene through the SetLocation feature, and the original model was loaded using the
2462  * SetLargeTranslationExtraction setting, the same data_index value should be used for the model being added to the existing scene,
2463  * so that any translations previously extracted from the model can be taken into account during import.
2464  * \param in_state Whether to enable large translation extraction
2465  * \param in_data_index The index at which the user data representing the extracted translation will be stored
2466  * \return A reference to this ImportOptionsKit. */
2467  ImportOptionsKit & SetLargeTranslationExtraction(bool in_state, intptr_t in_data_index = 1);
2468 
2471  ImportOptionsKit & UnsetBRepMode();
2472 
2475  ImportOptionsKit & UnsetSolids();
2476 
2479  ImportOptionsKit & UnsetSurfaces();
2480 
2483  ImportOptionsKit & UnsetWireframes();
2484 
2487  ImportOptionsKit & UnsetPMI();
2488 
2491  ImportOptionsKit & UnsetAttributes();
2492 
2495  ImportOptionsKit & UnsetHiddenObjects();
2496 
2499  ImportOptionsKit & UnsetConstructionAndReferences();
2500 
2503  ImportOptionsKit & UnsetActiveFilter();
2504 
2507  ImportOptionsKit & UnsetDrawings();
2508 
2511  ImportOptionsKit& UnsetConstraintsInfo();
2512 
2515  ImportOptionsKit & UnsetFeatureTrees();
2516 
2519  ImportOptionsKit & UnsetSewingTolerance();
2520 
2523  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2524 
2527  ImportOptionsKit & UnsetDefaultUnits();
2528 
2531  ImportOptionsKit & UnsetMultiProcessCount();
2532 
2535  ImportOptionsKit & UnsetPMISubstitutionFont();
2536 
2539  ImportOptionsKit & UnsetPMIPrecision();
2540 
2543  ImportOptionsKit & UnsetPMIDefaultUnits();
2544 
2547  ImportOptionsKit & UnsetPMIDefaultColor();
2548 
2551  ImportOptionsKit & UnsetTessellationLevel();
2552 
2555  ImportOptionsKit & UnsetTessellationAccuracy();
2556 
2559  ImportOptionsKit & UnsetTessellationCleanup();
2560 
2563  ImportOptionsKit & UnsetPMIFlipping();
2564 
2567  ImportOptionsKit & UnsetRemovedViews();
2568 
2571  ImportOptionsKit & UnsetExternalProductOccurrence();
2572 
2575  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2576 
2579  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2580 
2583  ImportOptionsKit & UnsetTextureDirectories();
2584 
2587  ImportOptionsKit & UnsetSearchDirectories();
2588 
2591  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2592 
2595  ImportOptionsKit & UnsetSearchRootDirectory();
2596 
2599  ImportOptionsKit & UnsetConfiguration();
2600 
2603  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2604 
2607  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2608 
2611  ImportOptionsKit & UnsetCatiaV5Cache();
2612 
2615  ImportOptionsKit & UnsetCatiaV5MaterialRendering();
2616 
2619  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2620 
2623  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2624 
2627  ImportOptionsKit & UnsetProECodePageName();
2628 
2631  ImportOptionsKit & UnsetProEDimensionTolerance();
2632 
2635  ImportOptionsKit & UnsetProESubpartPMI();
2636 
2639  ImportOptionsKit & UnsetProESessionColor();
2640 
2643  ImportOptionsKit & UnsetProEDatum();
2644 
2647  ImportOptionsKit & UnsetProEHomeView();
2648 
2651  ImportOptionsKit & UnsetProEExplodedViews();
2652 
2655  ImportOptionsKit & UnsetProEMissingBoolean();
2656 
2659  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2660 
2663  ImportOptionsKit & UnsetProEFamilyTreeSource();
2664 
2667  ImportOptionsKit & UnsetProEConstructionEntities();
2668 
2671  ImportOptionsKit & UnsetProESkeletons();
2672 
2675  ImportOptionsKit & UnsetSTEPNamePreference();
2676 
2679  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2680 
2683  ImportOptionsKit & UnsetSTEPCodePageName();
2684 
2687  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2688 
2691  ImportOptionsKit & UnsetSTEPOrientationHealing();
2692 
2695  ImportOptionsKit & UnsetSTEPValidationProperties();
2696 
2699  ImportOptionsKit & UnsetIFCCodePageName();
2700 
2703  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2704 
2707  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2708 
2711  ImportOptionsKit & UnsetIFCFaceOptimization();
2712 
2715  ImportOptionsKit & UnsetIFCEdges();
2716 
2719  ImportOptionsKit & UnsetIFCMetadata();
2720 
2723  ImportOptionsKit & UnsetIFCRelationships();
2724 
2727  ImportOptionsKit & UnsetIFCOpenings();
2728 
2731  ImportOptionsKit & UnsetPDF3DStreamIndex();
2732 
2735  ImportOptionsKit & UnsetJTTessellationLevel();
2736 
2739  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2740 
2743  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2744 
2747  ImportOptionsKit & UnsetPRCReadHelper();
2748 
2751  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2752 
2755  ImportOptionsKit & UnsetRevitPhysicalProperties();
2756 
2759  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2760 
2763  ImportOptionsKit & UnsetLocation();
2764 
2767  ImportOptionsKit & UnsetMode();
2768 
2771  ImportOptionsKit & UnsetIncrementalComponentPaths();
2772 
2775  ImportOptionsKit & UnsetNURBSConversion();
2776 
2779  ImportOptionsKit & UnsetGeometryDefaultColor();
2780 
2781  /* Removes the large translation extraction setting.
2782  * \return A reference to this ImportOptionsKit. */
2783  ImportOptionsKit & UnsetLargeTranslationExtraction();
2784 
2787  ImportOptionsKit & UnsetEverything();
2788 
2792  bool ShowBRepMode(BRepMode & out_mode) const;
2793 
2797  bool ShowSolids(bool & out_state) const;
2798 
2802  bool ShowSurfaces(bool & out_state) const;
2803 
2807  bool ShowWireframes(bool & out_state) const;
2808 
2812  bool ShowPMI(bool & out_state) const;
2813 
2817  bool ShowAttributes(bool & out_state) const;
2818 
2822  bool ShowHiddenObjects(bool & out_state) const;
2823 
2827  bool ShowConstructionAndReferences(bool & out_state) const;
2828 
2832  bool ShowActiveFilter(bool & out_state) const;
2833 
2837  bool ShowDrawings(bool & out_state) const;
2838 
2842  bool ShowConstraintsInfo(bool& out_state) const;
2843 
2847  bool ShowFeatureTrees(bool & out_state) const;
2848 
2852  bool ShowSewingTolerance(double & out_tolerance) const;
2853 
2857  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2858 
2862  bool ShowDefaultUnits(Units & out_units) const;
2863 
2867  bool ShowMultiProcessCount(unsigned int & out_count) const;
2868 
2873  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2874 
2878  bool ShowPMIPrecision(size_t & out_precision) const;
2879 
2883  bool ShowPMIDefaultUnits(Units & out_units) const;
2884 
2889  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2890 
2898  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2899 
2906  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2907 
2911  bool ShowTessellationCleanup(bool & out_cleanup) const;
2912 
2916  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2917 
2921  bool ShowRemovedViews(bool & out_read_removed_views) const;
2922 
2926  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2927 
2931  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2932 
2936  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2937 
2941  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2942 
2948  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2949 
2953  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2954 
2959  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2960 
2964  bool ShowConfiguration(UTF8Array & out_configuration) const;
2965 
2969  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2970 
2974  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2975 
2980  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2981 
2985  bool ShowCatiaV5MaterialRendering(bool & out_active) const;
2986 
2991  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2992 
2996  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2997 
3001  bool ShowProECodePageName(UTF8 & out_name) const;
3002 
3006  bool ShowProEDimensionTolerance(bool & out_state) const;
3007 
3011  bool ShowProESubpartPMI(bool & out_state) const;
3012 
3016  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
3017 
3021  bool ShowProEDatum(bool & out_state) const;
3022 
3026  bool ShowProEHomeView(bool & out_state) const;
3027 
3031  bool ShowProEExplodedViews(bool & out_state) const;
3032 
3036  bool ShowProEMissingBoolean(bool & out_state) const;
3037 
3041  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
3042 
3046  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
3047 
3051  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
3052 
3056  bool ShowProESkeletons(bool & out_state) const;
3057 
3061  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
3062 
3066  bool ShowSTEPFirstColorPreference(bool & out_state) const;
3067 
3071  bool ShowSTEPCodePageName(UTF8 & out_name) const;
3072 
3076  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
3077 
3081  bool ShowSTEPOrientationHealing(bool & out_state) const;
3082 
3086  bool ShowSTEPValidationProperties(bool & out_state) const;
3087 
3091  bool ShowIFCCodePageName(UTF8 & out_name) const;
3092 
3096  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
3097 
3101  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
3102 
3106  bool ShowIFCFaceOptimization(bool & out_state) const;
3107 
3111  bool ShowIFCEdges(bool & out_state) const;
3112 
3116  bool ShowIFCMetadata(bool & out_state) const;
3117 
3121  bool ShowIFCRelationships(bool & out_state) const;
3122 
3126  bool ShowIFCOpenings(bool & out_state) const;
3127 
3131  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3132 
3136  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3137 
3141  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3142 
3146  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3147 
3151  bool ShowPRCReadHelper(bool & out_use_helper) const;
3152 
3156  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3157 
3161  bool ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;
3162 
3166  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3167 
3172  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3173 
3177  bool ShowMode(ImportMode & out_mode) const;
3178 
3182  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3183 
3187  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3188 
3192  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3193 
3194  /* Shows the large translation extraction setting.
3195  * \param out_state Whether to extract large translations during an import.
3196  * \param out_data_index The index at which the user data representing the extracted translation will be stored
3197  * \return <span class='code'>true</span> if a large translation extraction setting was specified, <span class='code'>false</span> otherwise. */
3198  bool ShowLargeTranslationExtraction(bool & out_state, intptr_t & out_data_index) const;
3199  };
3200 
3202  class EXCHANGE_API Translation
3203  {
3204  public:
3207  enum class Healing
3208  {
3209  Off,
3210  On,
3211  OnlyIfNotParasolid,
3212  };
3213 
3216  enum class AccurateEdges
3217  {
3218  Off,
3219  On,
3220  OnlyIfNotParasolid,
3221  };
3222 
3225  enum class Simplification
3226  {
3227  Off,
3228  On,
3229  OnlyIfNotParasolid,
3230  };
3231 
3234  enum class Merging
3235  {
3236  Off,
3237  On,
3238  OnlyIfNotParasolid,
3239  };
3240 
3241  private:
3243  Translation();
3244  };
3245 
3247  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3248  {
3249  public:
3252 
3256 
3261 
3265  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3266 
3267  virtual ~TranslationOptionsKit();
3268 
3269  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3270  HPS::Type ObjectType() const { return staticType; }
3271 
3275  static TranslationOptionsKit GetDefault();
3276 
3279  void Set(TranslationOptionsKit const & in_kit);
3280 
3283  void Show(TranslationOptionsKit & out_kit) const;
3284 
3288  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3289 
3292  bool Empty() const;
3293 
3297  bool Equals(TranslationOptionsKit const & in_kit) const;
3298 
3302  bool operator==(TranslationOptionsKit const & in_kit) const;
3303 
3307  bool operator!=(TranslationOptionsKit const & in_kit) const;
3308 
3314  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3315 
3321  TranslationOptionsKit & SetTessellation(bool in_state);
3322 
3328  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3329 
3333  TranslationOptionsKit & SetApplication(char const * in_name);
3334 
3338  TranslationOptionsKit & SetVersion(char const * in_version);
3339 
3345  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3346 
3350  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3351 
3355  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3356 
3360  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3361 
3365  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3366 
3371  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3372 
3376  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3377 
3380  TranslationOptionsKit & UnsetSolidsAsFaces();
3381 
3384  TranslationOptionsKit & UnsetTessellation();
3385 
3388  TranslationOptionsKit & UnsetHiddenObjects();
3389 
3392  TranslationOptionsKit & UnsetApplication();
3393 
3396  TranslationOptionsKit & UnsetVersion();
3397 
3400  TranslationOptionsKit & UnsetHealing();
3401 
3404  TranslationOptionsKit & UnsetAccurateEdges();
3405 
3408  TranslationOptionsKit & UnsetSimplification();
3409 
3412  TranslationOptionsKit & UnsetEntityMerging();
3413 
3416  TranslationOptionsKit & UnsetSewing();
3417 
3420  TranslationOptionsKit & UnsetDisjointFaces();
3421 
3424  TranslationOptionsKit& UnsetExplodeMultiBodies();
3425 
3428  TranslationOptionsKit & UnsetEverything();
3429 
3430 
3434  bool ShowSolidsAsFaces(bool & out_state) const;
3435 
3439  bool ShowTessellation(bool & out_state) const;
3440 
3444  bool ShowHiddenObjects(bool & out_state) const;
3445 
3449  bool ShowApplication(UTF8 & out_name) const;
3450 
3454  bool ShowVersion(UTF8 & out_version) const;
3455 
3459  bool ShowExplodeMultiBodies(bool& out_state) const;
3460 
3464  bool ShowHealing(Translation::Healing & out_healing) const;
3465 
3469  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3470 
3474  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3475 
3479  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3480 
3485  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3486 
3490  bool ShowDisjointFaces(bool & out_state) const;
3491 
3496  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3497 
3500  TranslationOptionsKit & UnsetMultiProcessCount();
3501 
3505  bool ShowMultiProcessCount(unsigned int & out_count) const;
3506  };
3507 
3508 
3509 
3514  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3515  {
3516  public:
3519 
3523 
3528 
3532  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3533 
3534  virtual ~ModelFileImportOptionsKit();
3535 
3536  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3537  HPS::Type ObjectType() const { return staticType; }
3538 
3542  static ModelFileImportOptionsKit GetDefault();
3543 
3546  void Set(ModelFileImportOptionsKit const & in_kit);
3547 
3550  void Show(ModelFileImportOptionsKit & out_kit) const;
3551 
3555  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3556 
3559  bool Empty() const;
3560 
3564  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3565 
3569  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3570 
3574  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3575 
3576 
3577  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3578  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3579  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3580  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3581  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3582  * \return A reference to this ModelFileImportOptionsKit.
3583  */
3584  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3585 
3591  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3592 
3599  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3600 
3612  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);
3613 
3614  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3615  * \warning Setting this option to true will cause future exports to output without tessellation data.
3616  * \param in_cleanup Whether to clean up tessellation data from representation items.
3617  * \return A reference to this ImportOptionsKit.
3618  */
3619  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3620 
3626  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3627 
3633  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3634 
3641  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3642 
3646  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3647 
3660  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3661 
3667  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3668 
3675  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3676 
3680  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3681 
3686  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3687 
3693  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
3694 
3697  ModelFileImportOptionsKit & UnsetTessellationLevel();
3698 
3701  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3702 
3705  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3706 
3709  ModelFileImportOptionsKit & UnsetPMIFlipping();
3710 
3713  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3714 
3717  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3718 
3721  ModelFileImportOptionsKit & UnsetIFCEdges();
3722 
3725  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3726 
3729  ModelFileImportOptionsKit & UnsetLocation();
3730 
3733  ModelFileImportOptionsKit & UnsetSewingTolerance();
3734 
3737  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3738 
3741  ModelFileImportOptionsKit & UnsetNURBSConversion();
3742 
3745  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3746 
3749  ModelFileImportOptionsKit & UnsetHiddenObjects();
3750 
3753  ModelFileImportOptionsKit & UnsetEverything();
3754 
3755 
3763  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3764 
3771  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3772 
3776  bool ShowTessellationCleanup(bool & out_cleanup) const;
3777 
3781  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3782 
3786  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3787 
3791  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3792 
3796  bool ShowIFCEdges(bool & out_state) const;
3797 
3801  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3802 
3807  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3808 
3812  bool ShowSewingTolerance(double & out_tolerance) const;
3813 
3814 
3818  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3819 
3823  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3824 
3828  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3829 
3833  bool ShowHiddenObjects(bool & out_state) const;
3834  };
3835 
3836 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3837 
3838  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3839  {
3840  public:
3843 
3846  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3847 
3851 
3852  virtual ~Export3MFOptionsKit();
3853 
3854  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3855  HPS::Type ObjectType() const { return staticType; }
3856 
3860  static Export3MFOptionsKit GetDefault();
3861 
3864  void Set(Export3MFOptionsKit const & in_kit);
3865 
3868  void Show(Export3MFOptionsKit& out_kit) const;
3869 
3873  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3874 
3878  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3879 
3882  bool Empty() const;
3883 
3887  bool Equals(Export3MFOptionsKit const & in_kit) const;
3888 
3892  bool operator==(Export3MFOptionsKit const & in_kit) const;
3893 
3897  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3898 
3903  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3904 
3910  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3911 
3914  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3915 
3919  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3920 
3925  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3926 
3929  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3930 
3935  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3936 
3940  Export3MFOptionsKit & SetDescription(char const * in_description);
3941 
3944  Export3MFOptionsKit & UnsetDescription();
3945 
3949  bool ShowDescription(HPS::UTF8 & out_state) const;
3950 
3954  Export3MFOptionsKit & SetCopyright(char const * in_state);
3955 
3958  Export3MFOptionsKit & UnsetCopyright();
3959 
3963  bool ShowCopyright(HPS::UTF8 & out_state) const;
3964 
3968  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3969 
3972  Export3MFOptionsKit & UnsetLicenseTerms();
3973 
3977  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3978 
3981  Export3MFOptionsKit & UnsetEverything();
3982  };
3983 
3985  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
3986  {
3987  public:
3990 
3993  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
3994 
3998 
3999  virtual ~ExportFBXOptionsKit();
4000 
4001  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
4002  HPS::Type ObjectType() const { return staticType; }
4003 
4007  static ExportFBXOptionsKit GetDefault();
4008 
4011  void Set(ExportFBXOptionsKit const & in_kit);
4012 
4015  void Show(ExportFBXOptionsKit & out_kit) const;
4016 
4020  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
4021 
4025  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
4026 
4029  bool Empty() const;
4030 
4034  bool Equals(ExportFBXOptionsKit const & in_kit) const;
4035 
4039  bool operator==(ExportFBXOptionsKit const & in_kit) const;
4040 
4044  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
4045 
4046 
4054  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
4055 
4056 
4062  ExportFBXOptionsKit & SetAscii(bool in_state);
4063 
4064 
4067  ExportFBXOptionsKit & UnsetTextureFolder();
4068 
4071  ExportFBXOptionsKit & UnsetAscii();
4072 
4075  ExportFBXOptionsKit & UnsetEverything();
4076 
4077 
4081  bool ShowTextureFolder(UTF8 & out_path) const;
4082 
4086  bool ShowAscii(bool & out_state) const;
4087  };
4088 
4090  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
4091  {
4092  public:
4095 
4099 
4103 
4104  virtual ~ExportACISOptionsKit();
4105 
4106  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
4107  HPS::Type ObjectType() const { return staticType; }
4108 
4112  static ExportACISOptionsKit GetDefault();
4113 
4116  void Set(ExportACISOptionsKit const & in_kit);
4117 
4120  void Show(ExportACISOptionsKit & out_kit) const;
4121 
4125  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
4126 
4130  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
4131 
4134  bool Empty() const;
4135 
4139  bool Equals(ExportACISOptionsKit const & in_kit) const;
4140 
4144  bool operator==(ExportACISOptionsKit const & in_kit) const;
4145 
4149  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4150 
4151 
4157  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4158 
4164  ExportACISOptionsKit & SetBinary(bool in_state);
4165 
4166 
4169  ExportACISOptionsKit & UnsetMillimeterUnits();
4170 
4173  ExportACISOptionsKit & UnsetBinary();
4174 
4177  ExportACISOptionsKit & UnsetEverything();
4178 
4179 
4183  bool ShowMillimeterUnits(bool & out_state) const;
4184 
4188  bool ShowBinary(bool & out_state) const;
4189  };
4190 
4192  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4193  {
4194  public:
4197 
4200  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4201 
4205 
4206  virtual ~ExportJTOptionsKit();
4207 
4208  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4209  HPS::Type ObjectType() const { return staticType; }
4210 
4214  static ExportJTOptionsKit GetDefault();
4215 
4218  void Set(ExportJTOptionsKit const & in_kit);
4219 
4222  void Show(ExportJTOptionsKit & out_kit) const;
4223 
4227  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4228 
4232  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4233 
4236  bool Empty() const;
4237 
4241  bool Equals(ExportJTOptionsKit const & in_kit) const;
4242 
4246  bool operator==(ExportJTOptionsKit const & in_kit) const;
4247 
4251  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4252 
4253 
4259  ExportJTOptionsKit & SetContent(JT::Content in_content);
4260 
4266  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4267 
4273  ExportJTOptionsKit & SetPMI(bool in_state);
4274 
4280  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4281 
4282 
4285  ExportJTOptionsKit & UnsetContent();
4286 
4289  ExportJTOptionsKit & UnsetHiddenObjects();
4290 
4293  ExportJTOptionsKit & UnsetPMI();
4294 
4297  ExportJTOptionsKit & UnsetVersion();
4298 
4301  ExportJTOptionsKit & UnsetEverything();
4302 
4303 
4307  bool ShowContent(JT::Content & out_content) const;
4308 
4312  bool ShowHiddenObjects(bool & out_state) const;
4313 
4317  bool ShowPMI(bool & out_state) const;
4318 
4322  bool ShowVersion(JT::Version & out_version) const;
4323  };
4324 
4326  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4327  {
4328  public:
4331 
4334  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4335 
4339 
4340  virtual ~ExportPRCOptionsKit();
4341 
4342  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4343  HPS::Type ObjectType() const { return staticType; }
4344 
4348  static ExportPRCOptionsKit GetDefault();
4349 
4352  void Set(ExportPRCOptionsKit const & in_kit);
4353 
4356  void Show(ExportPRCOptionsKit & out_kit) const;
4357 
4361  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4362 
4366  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4367 
4370  bool Empty() const;
4371 
4375  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4376 
4380  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4381 
4385  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4386 
4387 
4393  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4394 
4401  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4402 
4408  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4409 
4415  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4416 
4421  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4422 
4428  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4429 
4430 
4433  ExportPRCOptionsKit & UnsetTessellationCompression();
4434 
4437  ExportPRCOptionsKit & UnsetBRepCompression();
4438 
4441  ExportPRCOptionsKit & UnsetBRepRemoval();
4442 
4445  ExportPRCOptionsKit & UnsetAttributeRemoval();
4446 
4449  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4450 
4453  ExportPRCOptionsKit & UnsetEverything();
4454 
4455 
4459  bool ShowTessellationCompression(bool & out_state) const;
4460 
4464  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4465 
4469  bool ShowBRepRemoval(bool & out_state) const;
4470 
4474  bool ShowAttributeRemoval(bool & out_state) const;
4475 
4479  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4480  };
4481 
4483  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4484  {
4485  public:
4488 
4491  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4492 
4496 
4497  virtual ~ExportSTLOptionsKit();
4498 
4499  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4500  HPS::Type ObjectType() const { return staticType; }
4501 
4505  static ExportSTLOptionsKit GetDefault();
4506 
4509  void Set(ExportSTLOptionsKit const & in_kit);
4510 
4513  void Show(ExportSTLOptionsKit & out_kit) const;
4514 
4518  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4519 
4523  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4524 
4527  bool Empty() const;
4528 
4532  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4533 
4537  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4538 
4542  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4543 
4544 
4550  ExportSTLOptionsKit & SetBinary(bool in_state);
4551 
4557  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4558 
4565  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4566 
4572  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4573 
4579  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4580 
4587  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4588 
4598  ExportSTLOptionsKit & SetUnits(Units in_units);
4599 
4600 
4603  ExportSTLOptionsKit & UnsetBinary();
4604 
4607  ExportSTLOptionsKit & UnsetTessellationLevel();
4608 
4611  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4612 
4615  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4616 
4619  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4620 
4623  ExportSTLOptionsKit & UnsetUnits();
4624 
4627  ExportSTLOptionsKit & UnsetEverything();
4628 
4629 
4633  bool ShowBinary(bool & out_state) const;
4634 
4642  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4643 
4647  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4648 
4652  bool ShowCurrentTessellationRetention(bool & out_state) const;
4653 
4657  bool ShowMaximumEdgeLength(double & out_length) const;
4658 
4662  bool ShowUnits(Units & out_units) const;
4663  };
4664 
4666  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4667  {
4668  public:
4671 
4674  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
4675 
4679 
4680  virtual ~ExportOBJOptionsKit();
4681 
4682  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
4683  HPS::Type ObjectType() const { return staticType; }
4684 
4688  static ExportOBJOptionsKit GetDefault();
4689 
4692  void Set(ExportOBJOptionsKit const & in_kit);
4693 
4696  void Show(ExportOBJOptionsKit & out_kit) const;
4697 
4701  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
4702 
4706  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
4707 
4710  bool Empty() const;
4711 
4715  bool Equals(ExportOBJOptionsKit const & in_kit) const;
4716 
4720  bool operator==(ExportOBJOptionsKit const & in_kit) const;
4721 
4725  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
4726 
4731  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
4732 
4736  bool ShowTextureFolder(UTF8 & out_path) const;
4737 
4740  ExportOBJOptionsKit & UnsetTextureFolder();
4741 
4744  ExportOBJOptionsKit & UnsetEverything();
4745  };
4746 
4748  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4749  {
4750  public:
4753 
4756  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4757 
4761 
4762  virtual ~ExportU3DOptionsKit();
4763 
4764  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4765  HPS::Type ObjectType() const { return staticType; }
4766 
4770  static ExportU3DOptionsKit GetDefault();
4771 
4774  void Set(ExportU3DOptionsKit const & in_kit);
4775 
4778  void Show(ExportU3DOptionsKit & out_kit) const;
4779 
4783  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4784 
4788  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4789 
4792  bool Empty() const;
4793 
4797  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4798 
4802  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4803 
4807  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4808 
4809 
4815  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4816 
4821  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4822 
4823 
4826  ExportU3DOptionsKit & UnsetVersion();
4827 
4830  ExportU3DOptionsKit & UnsetCompression();
4831 
4834  ExportU3DOptionsKit & UnsetEverything();
4835 
4836 
4840  bool ShowVersion(U3D::Version & out_version) const;
4841 
4845  bool ShowCompression(unsigned char & out_level) const;
4846  };
4847 
4849  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4850  {
4851  public:
4854 
4857  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4858 
4862 
4863  virtual ~ExportXMLOptionsKit();
4864 
4865  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4866  HPS::Type ObjectType() const { return staticType; }
4867 
4871  static ExportXMLOptionsKit GetDefault();
4872 
4875  void Set(ExportXMLOptionsKit const & in_kit);
4876 
4879  void Show(ExportXMLOptionsKit & out_kit) const;
4880 
4884  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4885 
4889  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4890 
4893  bool Empty() const;
4894 
4898  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4899 
4903  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4904 
4908  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4909 
4910 
4916  ExportXMLOptionsKit & SetMetadata(bool in_state);
4917 
4923  ExportXMLOptionsKit & SetTransformations(bool in_state);
4924 
4930  ExportXMLOptionsKit & SetMaterials(bool in_state);
4931 
4932 
4935  ExportXMLOptionsKit & UnsetMetadata();
4936 
4939  ExportXMLOptionsKit & UnsetTransformations();
4940 
4943  ExportXMLOptionsKit & UnsetMaterials();
4944 
4947  ExportXMLOptionsKit & UnsetEverything();
4948 
4949 
4953  bool ShowMetadata(bool & out_state) const;
4954 
4958  bool ShowTransformations(bool & out_state) const;
4959 
4963  bool ShowMaterials(bool & out_state) const;
4964  };
4965 #endif
4966 
4967 #if !defined(TARGET_OS_ANDROID)
4968 
4969  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4970  {
4971  public:
4974 
4978 
4982 
4983  virtual ~ExportIGESOptionsKit();
4984 
4985  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4986  HPS::Type ObjectType() const { return staticType; }
4987 
4991  static ExportIGESOptionsKit GetDefault();
4992 
4995  void Set(ExportIGESOptionsKit const & in_kit);
4996 
4999  void Show(ExportIGESOptionsKit & out_kit) const;
5000 
5004  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
5005 
5009  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
5010 
5013  bool Empty() const;
5014 
5018  bool Equals(ExportIGESOptionsKit const & in_kit) const;
5019 
5023  bool operator==(ExportIGESOptionsKit const & in_kit) const;
5024 
5028  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
5029 
5030 
5036  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5037 
5043  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
5044 
5050  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
5051 
5057  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
5058 
5064  ExportIGESOptionsKit & SetTessellation(bool in_state);
5065 
5069  ExportIGESOptionsKit & SetApplication(char const * in_name);
5070 
5074  ExportIGESOptionsKit & SetVersion(char const * in_version);
5075 
5076 
5079  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
5080 
5083  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
5084 
5087  ExportIGESOptionsKit & UnsetSolidsAsFaces();
5088 
5091  ExportIGESOptionsKit & UnsetHiddenObjects();
5092 
5095  ExportIGESOptionsKit & UnsetTessellation();
5096 
5099  ExportIGESOptionsKit & UnsetApplication();
5100 
5103  ExportIGESOptionsKit & UnsetVersion();
5104 
5107  ExportIGESOptionsKit & UnsetEverything();
5108 
5109 
5113  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5114 
5118  bool ShowFacetedAsWireframe(bool & out_state) const;
5119 
5123  bool ShowSolidsAsFaces(bool & out_state) const;
5124 
5128  bool ShowHiddenObjects(bool & out_state) const;
5129 
5133  bool ShowTessellation(bool & out_state) const;
5134 
5138  bool ShowApplication(UTF8 & out_name) const;
5139 
5143  bool ShowVersion(UTF8 & out_version) const;
5144  };
5145 
5147  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5148  {
5149  public:
5152 
5156 
5160 
5161  virtual ~ExportParasolidOptionsKit();
5162 
5163  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5164  HPS::Type ObjectType() const { return staticType; }
5165 
5169  static ExportParasolidOptionsKit GetDefault();
5170 
5173  void Set(ExportParasolidOptionsKit const & in_kit);
5174 
5177  void Show(ExportParasolidOptionsKit & out_kit) const;
5178 
5182  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5183 
5187  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5188 
5191  bool Empty() const;
5192 
5196  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5197 
5201  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5202 
5206  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5207 
5208 
5214  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5215 
5221  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5222 
5228  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5229 
5233  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5234 
5238  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5239 
5245  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5246 
5249  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5250 
5253  ExportParasolidOptionsKit & UnsetTessellation();
5254 
5257  ExportParasolidOptionsKit & UnsetHiddenObjects();
5258 
5261  ExportParasolidOptionsKit & UnsetApplication();
5262 
5265  ExportParasolidOptionsKit & UnsetVersion();
5266 
5269  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5270 
5273  ExportParasolidOptionsKit & UnsetEverything();
5274 
5275 
5279  bool ShowSolidsAsFaces(bool & out_state) const;
5280 
5284  bool ShowTessellation(bool & out_state) const;
5285 
5289  bool ShowHiddenObjects(bool & out_state) const;
5290 
5294  bool ShowApplication(UTF8 & out_name) const;
5295 
5299  bool ShowVersion(UTF8 & out_version) const;
5300 
5304  bool ShowExplodeMultiBodies(bool& out_state) const;
5305  };
5306 
5308  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5309  {
5310  public:
5313 
5317 
5321 
5322  virtual ~ExportSTEPOptionsKit();
5323 
5324  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5325  HPS::Type ObjectType() const { return staticType; }
5326 
5330  static ExportSTEPOptionsKit GetDefault();
5331 
5334  void Set(ExportSTEPOptionsKit const & in_kit);
5335 
5338  void Show(ExportSTEPOptionsKit & out_kit) const;
5339 
5343  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5344 
5348  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5349 
5352  bool Empty() const;
5353 
5357  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5358 
5362  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5363 
5367  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5368 
5369 
5375  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5376 
5382  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5383 
5389  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5390 
5396  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5397 
5401  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5402 
5406  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5407 
5411  ExportSTEPOptionsKit & SetPMI(bool in_state);
5412 
5416  ExportSTEPOptionsKit & SetCurves(bool in_state);
5417 
5421  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5422 
5426  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5427 
5431  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5432 
5435  ExportSTEPOptionsKit & UnsetFormat();
5436 
5439  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5440 
5443  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5444 
5447  ExportSTEPOptionsKit & UnsetNameShortening();
5448 
5451  ExportSTEPOptionsKit & UnsetApplication();
5452 
5455  ExportSTEPOptionsKit & UnsetVersion();
5456 
5459  ExportSTEPOptionsKit & UnsetPMI();
5460 
5463  ExportSTEPOptionsKit & UnsetCurves();
5464 
5467  ExportSTEPOptionsKit & UnsetAttributes();
5468 
5471  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5472 
5475  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5476 
5479  ExportSTEPOptionsKit & UnsetEverything();
5480 
5481 
5485  bool ShowFormat(STEP::Format & out_format) const;
5486 
5490  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5491 
5495  bool ShowFacetedAsWireframe(bool & out_state) const;
5496 
5500  bool ShowNameShortening(bool & out_state) const;
5501 
5505  bool ShowApplication(UTF8 & out_name) const;
5506 
5510  bool ShowVersion(UTF8 & out_version) const;
5511 
5515  bool ShowPMI(bool & out_state) const;
5516 
5520  bool ShowCurves(bool & out_state) const;
5521 
5525  bool ShowAttributes(bool & out_state) const;
5526 
5530  bool ShowPMIWithSemantic(bool & out_state) const;
5531 
5535  bool ShowPMIAsTessellated(bool & out_state) const;
5536  };
5537 
5539  class EXCHANGE_API ExportGLTFOptionsKit : public SprocketKit
5540  {
5541  public:
5544 
5548 
5552 
5553  virtual ~ExportGLTFOptionsKit();
5554 
5555  static const HPS::Type staticType = HPS::Type::ExchangeExportGLTFOptionsKit;
5556  HPS::Type ObjectType() const { return staticType; }
5557 
5561  static ExportGLTFOptionsKit GetDefault();
5562 
5565  void Set(ExportGLTFOptionsKit const & in_kit);
5566 
5569  void Show(ExportGLTFOptionsKit & out_kit) const;
5570 
5574  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit const & in_kit);
5575 
5579  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit && in_that);
5580 
5583  bool Empty() const;
5584 
5588  bool Equals(ExportGLTFOptionsKit const & in_kit) const;
5589 
5593  bool operator==(ExportGLTFOptionsKit const & in_kit) const;
5594 
5598  bool operator!=(ExportGLTFOptionsKit const & in_kit) const;
5599 
5600 
5608  ExportGLTFOptionsKit & SetTextureFolder(char const * in_name);
5609 
5610 
5616  ExportGLTFOptionsKit & SetAscii(bool in_state);
5617 
5618 
5621  ExportGLTFOptionsKit & UnsetTextureFolder();
5622 
5625  ExportGLTFOptionsKit & UnsetAscii();
5626 
5629  ExportGLTFOptionsKit & UnsetEverything();
5630 
5631 
5635  bool ShowTextureFolder(UTF8 & out_path) const;
5636 
5640  bool ShowAscii(bool & out_state) const;
5641  };
5642 #endif
5643 
5645  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5646  {
5647  public:
5650 
5654 
5658 
5659  virtual ~TessellationOptionsKit();
5660 
5661  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5662  HPS::Type ObjectType() const { return staticType; }
5663 
5667  static TessellationOptionsKit GetDefault();
5668 
5671  void Set(TessellationOptionsKit const & in_kit);
5672 
5675  void Show(TessellationOptionsKit & out_kit) const;
5676 
5680  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5681 
5685  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5686 
5689  bool Empty() const;
5690 
5694  bool Equals(TessellationOptionsKit const & in_kit) const;
5695 
5699  bool operator==(TessellationOptionsKit const & in_kit) const;
5700 
5704  bool operator!=(TessellationOptionsKit const & in_kit) const;
5705 
5706 
5710  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5711 
5718  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5719 
5729  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);
5730 
5734  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5735 
5739  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5740 
5741 
5744  TessellationOptionsKit & UnsetLevel();
5745 
5748  TessellationOptionsKit & UnsetAccuracy();
5749 
5752  TessellationOptionsKit & UnsetUVPointPreservation();
5753 
5756  TessellationOptionsKit & UnsetMaximumEdgeLength();
5757 
5760  TessellationOptionsKit & UnsetEverything();
5761 
5762 
5770  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5771 
5778  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5779 
5783  bool ShowUVPointPreservation(bool & out_state) const;
5784 
5788  bool ShowMaximumEdgeLength(double & out_length) const;
5789  };
5790 
5796  class EXCHANGE_API CommonMeasurementOperator : public Operator
5797  {
5798  public:
5799  enum class Tags
5800  {
5801  Name = 0,
5802  MeasurementType,
5803  Radius,
5804  Inverted,
5805  VectorX,
5806  VectorY,
5807  VectorZ,
5808  };
5809 
5811 
5812  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5813 
5815  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5816 
5817  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5818  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5819 
5820  Exchange::CADModel GetCADModel() const;
5821  void SetCADModel(Exchange::CADModel const & in_cad_model);
5822 
5824  size_t GetPrecision() const;
5825 
5828  void SetPrecision(size_t in_precision);
5829 
5831  MaterialMappingKit GetMaterial() const;
5832 
5835  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5836 
5838  TextAttributeKit GetTextAttributes() const;
5839 
5842  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5843 
5845  SegmentKey GetMeasurementSegment() const;
5846 
5848  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5849 
5850  /* Deletes all measurements */
5851  void DeleteMeasurements();
5852 
5853  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5854  {
5855  public:
5858  {
5859  channel = GetClassID();
5860  consumable = false;
5861  }
5862 
5863  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5864  {
5865  channel = GetClassID();
5866  consumable = false;
5867  measurement_key = in_measurement_key;
5868  view = in_view;
5869  }
5870 
5873  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5874  {
5875  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5876  {
5877  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5878  measurement_key = that.measurement_key;
5879  view = that.view;
5880  }
5881  else
5882  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5883  }
5884 
5886 
5889  Event * Clone() const
5890  {
5891  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5892  return new_event;
5893  }
5894 
5895  Key measurement_key;
5896  View view;
5897  };
5898 
5899  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5900  {
5901  public:
5904  {
5905  channel = GetClassID();
5906  consumable = false;
5907  }
5908 
5909  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5910  {
5911  channel = GetClassID();
5912  consumable = false;
5913  measurement_name = in_measurement_name;
5914  view = in_view;
5915  }
5916 
5919  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5920  {
5921  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5922  {
5923  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5924  measurement_name = that.measurement_name;
5925  view = that.view;
5926  }
5927  else
5928  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5929  }
5930 
5932 
5935  Event * Clone() const
5936  {
5937  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5938  return new_event;
5939  }
5940 
5941  UTF8 measurement_name;
5942  View view;
5943  };
5944 
5945  protected:
5946  Exchange::CADModel cad_model;
5947  size_t measurement_precision;
5948  UTF8 units;
5949  MaterialMappingKit materials;
5950  TextAttributeKit text_attributes;
5951  SegmentKey measurement_segment;
5952  GlyphDefinition left_arrow;
5953  GlyphDefinition right_arrow;
5954  SelectionOptionsKit selection_options;
5955  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5956  Vector camera_direction;
5957  PortfolioKey portfolio;
5958  SegmentKey style_segment;
5959  HighlightOptionsKit highlight_options;
5960 
5961  static size_t length_measurement_index;
5962  static size_t radius_measurement_index;
5963  static size_t distance_measurement_index;
5964  static size_t angle_measurement_index;
5965 
5966  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5967  void GetUnits();
5968  void SetGlyphColor();
5969  void GetCameraDirection();
5970  void SetupConstructionSegment();
5971  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5972  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5973  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5974  float GetModelScale(Exchange::Component const & component);
5975  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5976  };
5977 
6031  {
6032  public:
6033  enum class MeasurementType
6034  {
6035  PointToPoint,
6036  EdgeAndRadius,
6037  FeatureToFeature,
6038  FaceAngle,
6039  };
6040 
6042 
6043  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
6044 
6046  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
6047 
6048  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
6049  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
6050 
6055  virtual bool OnMouseDown(MouseState const & in_state) override;
6056 
6060  virtual bool OnMouseUp(MouseState const & in_state) override;
6061 
6067  virtual bool OnMouseMove(MouseState const & in_state) override;
6068 
6073  virtual bool OnTouchDown(TouchState const & in_state) override;
6074 
6078  virtual bool OnTouchUp(TouchState const & in_state) override;
6079 
6085  virtual bool OnTouchMove(TouchState const & in_state) override;
6086 
6090  virtual bool OnKeyDown(KeyboardState const & in_state) override;
6091 
6094  void SetMeasurementType(MeasurementType in_measurement_type);
6095 
6098  MeasurementType GetMeasurementType();
6099 
6102  void SetMouseOverHighlighting(bool in_highlighting);
6103 
6107  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
6108 
6111  bool GetMouseOverHighlighting();
6112 
6115  HighlightOptionsKit GetHighlightOptions();
6116 
6119  bool IsMeasurementActive();
6120 
6122  void DeleteLastMeasurement();
6123 
6124  private:
6125  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
6126  {
6127  Circle,
6128  Line,
6129  Generic,
6130  };
6131 
6132  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
6133  {
6134  public:
6135  Surface();
6136 
6137  enum class SurfaceType
6138  {
6139  Plane,
6140  ConeOrCylinder,
6141  Unsupported,
6142  };
6143 
6144  SurfaceType surface_type; //the type of surface being measured
6145  Point center; //the center point of the surface
6146  Vector normal; //the center line of surfaces of type Cylinder or Cone
6147  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
6148  ComponentPath path; //the ComponentPath to this surface
6149  };
6150 
6151  //bookkeeping
6152  MeasurementType measurement_type; //the type of measurement to be inserted
6153  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
6154  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
6155  TouchID current_touch_id; //the ID of the touch being processed
6156  SegmentKey current_measurement; //segment of the measurement being inserted / edited
6157  bool operator_active; //whether a measurement is in progress
6158  bool end_measurement; //whether we should end the current measurement
6159  CanvasArray canvases; //canvases related to the view where this operator is attached
6160 
6161  //measurement anchors
6162  size_t anchors; //valid for point-to-point and face-angle measurements
6163  bool anchors_in_place; //true if all the anchors have been placed
6164  Point first_click_position; //position of the first anchor
6165  Point second_click_position; //position of the second anchor
6166 
6167  //geometry for linear measurements
6168  MarkerKey anchor_one; //marker corresponding to the start of the measurement
6169  MarkerKey anchor_two; //marker corresponding to the end of the measurement
6170  LineKey distance_line; //a line representing the distance measured
6171  LineKey leader_line_one; //line connecting the first anchor point to the distance line
6172  LineKey leader_line_two; //line connecting the second anchor point to the distance line
6173  Point distance_point_one; //intersection of leader_line_one and distance_line
6174  Point distance_point_two; //intersection of leader_line_two and distance_line
6175  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
6176  TextKey text; //text representing the measurement and units
6177  UTF8 text_string; //the contents of the text
6178  Vector measurement_direction; //the direction of the measurement
6179  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
6180  Vector explicit_direction; //used if use_explicit_direction is true
6181 
6182  //geometry for radius measurement
6183  MarkerKey center_marker; //marker representing the center of the circle
6184  Point circle_center; //circle center
6185  float radius; //circle radius
6186 
6187  //edge specific data
6188  LineKey edge_line; //the edge being measured
6189  double edge_length; //length of the measured edge
6190  EdgeType edge_type; //the type of edge being measured
6191 
6192  //feature-to-feature specific data
6193  Surface surface_one; //data related to first selected surface
6194  Surface surface_two; //data related to second selected surface
6195  Plane measurement_plane; //the measurement plane
6196  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
6197 
6198  //angle specific data
6199  Vector leader_line_one_direction; //the direction of the first leader line
6200  Vector leader_line_two_direction; //the direction of the second leader line
6201  Vector first_face_normal; //the normal of the first selected face
6202  Vector second_face_normal; //the normal of the second selected face
6203  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'
6204  CircularArcKey measurement_arc; //an arc representing the measured angle
6205  LineKey line_to_leader_line; //line extending from one anchor to a leader line
6206  Vector mid_point_direction;
6207 
6208  //selection kits
6209  SelectionOptionsKit point_to_point_selection;
6210  SelectionOptionsKit edge_radius_selection;
6211  SelectionOptionsKit feature_to_feature_selection;
6212  SelectionOptionsKit angle_selection;
6213 
6214  //highlighting
6215  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
6216  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
6217  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
6218  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
6219  KeyPath highlighted_path; //highlighted_path
6220  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
6221  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
6222 
6223  //input handling
6224  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
6225  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
6226  bool InputUp(WindowKey & in_window);
6227  void ResetMeasurement();
6228 
6229  //inserting measurements
6230  void InsertPointToPointMeasurement(Point const & in_world_point);
6231  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
6232  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
6233  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
6234  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
6235  void InvertMeasuredAngle(WindowKey & in_window);
6236  void AdjustLineToCursor(Point const & cursor_position);
6237 
6238  //saving measurements
6239  void TagMeasurement();
6240  void TagPointToPointMeasurement();
6241  void TagEdgeMeasurement();
6242  void TagRadiusMeasurement();
6243  void TagGenericEdgeMeasurement();
6244  void TagFeatureToFeatureMeasurement();
6245  void TagAngleMeasurement();
6246 
6247  //restoring measurements
6248  void RestoreMeasurement(SegmentKey const & measurement_segment);
6249  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6250  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6251  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6252  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6253  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6254  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6255 
6256  //topology functions
6257  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6258  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6259  void PlaneToCenterLineDistance();
6260  void PlaneToPlaneDistance();
6261  void LineToLineDistance();
6262  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);
6263  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6264  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6265  bool IsPlane(Exchange::Component const & face_component);
6266  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6267  };
6268 
6269 private:
6271  Exchange();
6272 };
6273 
6274 }
6275 
6276 #endif
Definition: hps.h:6460
Definition: hps.h:85
Definition: sprk_exchange.h:4326
Level
Definition: sprk_exchange.h:917
ConstructionEntities
Definition: sprk_exchange.h:1080
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1031
Definition: sprk.h:1102
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5325
Definition: sprk_exchange.h:1214
Definition: sprk_exchange.h:5796
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4683
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4986
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:6064
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:68
Simplification
Definition: sprk_exchange.h:3225
Definition: sprk.h:936
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5815
Definition: sprk_exchange.h:656
Version
Definition: sprk_exchange.h:1101
Definition: sprk_exchange.h:3514
Definition: sprk_exchange.h:927
intptr_t GetChannel() const
Definition: hps.h:6577
Definition: sprk_exchange.h:757
SurfaceType
Definition: sprk_exchange.h:849
Definition: hps.h:1790
Format
Definition: sprk_exchange.h:1018
Definition: sprk_exchange.h:4849
Definition: sprk.h:1071
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5662
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6926
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6902
Definition: hps.h:49215
Format
Definition: sprk_exchange.h:1219
Definition: hps.h:7971
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6896
Type
Definition: sprk_exchange.h:908
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3855
Definition: hps.h:16737
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1168
Definition: sprk_exchange.h:504
Definition: sprk_exchange.h:595
Definition: sprk_exchange.h:334
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1512
HPS::Type ObjectType() const
Definition: sprk_exchange.h:531
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4866
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4765
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4002
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
HPS::Type ObjectType() const
Definition: sprk_exchange.h:786
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5873
Definition: sprk_exchange.h:5539
Definition: sprk_exchange.h:1489
Definition: sprk_exchange.h:274
HPS::Type ObjectType() const
Definition: sprk_exchange.h:624
Definition: sprk_exchange.h:4192
Merging
Definition: sprk_exchange.h:3234
Definition: sprk_exchange.h:1113
Field
Definition: sprk_exchange.h:1008
Definition: sprk_exchange.h:4666
Definition: hps.h:49113
Definition: hps.h:42477
Definition: sprk_exchange.h:4090
Definition: sprk_exchange.h:3247
Event * Clone() const
Definition: sprk_exchange.h:5935
Limit
Definition: sprk_exchange.h:932
Definition: hps.h:4649
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3537
TessellationLevel
Definition: sprk_exchange.h:981
Definition: sprk_exchange.h:903
Definition: sprk_exchange.h:4483
Definition: sprk_exchange.h:113
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5556
Definition: sprk_exchange.h:1003
Definition: sprk_exchange.h:3985
Definition: hps.h:4588
Definition: hps.h:7342
Definition: hps.h:48584
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4107
Definition: sprk_exchange.h:455
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:44490
Definition: hps.h:49000
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:896
Definition: sprk_exchange.h:4748
Definition: sprk_exchange.h:967
Definition: hps.h:16110
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6882
Definition: sprk_exchange.h:1096
SessionColor
Definition: sprk_exchange.h:1055
Definition: sprk.h:2654
Definition: hps.h:49322
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:45698
Definition: hps.h:48091
CurveType
Definition: sprk_exchange.h:872
Definition: sprk_exchange.h:549
Definition: hps.h:6544
Definition: hps.h:14358
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6894
Definition: sprk_exchange.h:6030
Definition: sprk.h:1317
BRepCompression
Definition: sprk_exchange.h:1036
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5164
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:822
Definition: sprk.h:3026
ComponentType
Definition: sprk.h:2660
Accuracy
Definition: sprk_exchange.h:949
Definition: sprk_exchange.h:3838
Definition: sprk_exchange.h:4969
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5919
Definition: sprk.h:3732
FamilyTable
Definition: sprk_exchange.h:1068
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4500
Content
Definition: sprk_exchange.h:972
Definition: sprk_exchange.h:1714
Definition: sprk.h:3832
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4209
static MouseButtons ButtonLeft()
Definition: hps.h:48702
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:6046
Event * Clone() const
Definition: sprk_exchange.h:5889
Definition: hps.h:7889
HPS::Type ObjectType() const
Definition: sprk_exchange.h:685
Definition: sprk_exchange.h:1050
AccurateEdges
Definition: sprk_exchange.h:3216
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
Definition: hps.h:9602
HPS::Type ObjectType() const
Definition: sprk_exchange.h:739
Definition: sprk_exchange.h:710
Definition: hps.h:25017
Healing
Definition: sprk_exchange.h:3207
Definition: sprk.h:3919
Definition: hps.h:31450
PhysicalProperties
Definition: sprk_exchange.h:1116
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
ImportMode
Definition: sprk_exchange.h:837
Definition: sprk_exchange.h:1130
Definition: hps.h:538
Definition: sprk.h:1945
Definition: sprk_exchange.h:3202
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:5147
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1737
Definition: sprk_exchange.h:203
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3270
Definition: hps.h:41973
Version
Definition: sprk_exchange.h:990
Definition: sprk_exchange.h:5645
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4343
Definition: hps.h:43108
Definition: sprk_exchange.h:5308