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;
51  class TessellationOptionsKit;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
55  class ExportParasolidOptionsKit;
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:
207  ProductOccurrence();
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
226  ProductOccurrence(ProductOccurrence && in_that);
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 & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas & 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:
660  TranslationNotifier();
661 
664  TranslationNotifier(TranslationNotifier const & in_that);
665 
670  TranslationNotifier(IONotifier const & in_that);
671 
675  TranslationNotifier(TranslationNotifier && in_that);
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 #endif
813 
814 #if !defined(TARGET_OS_ANDROID)
815  class ExportSTEPOptionsKit;
816  class ExportIGESOptionsKit;
817 #endif
818 
821  enum class BRepMode
822  {
825  TessellationOnly,
828  BRepOnly,
831  BRepAndTessellation,
832  };
833 
836  enum class ImportMode
837  {
840  Complete,
843  Incremental,
844  };
845 
848  enum class SurfaceType
849  {
850  Blend01,
851  Blend02,
852  Blend03,
853  Blend04,
854  NURBS,
855  Cone,
856  Cylinder,
857  Offset,
858  Pipe,
859  Plane,
860  Ruled,
861  Sphere,
862  Revolution,
863  Extrusion,
864  FromCurve,
865  Torus,
866  Transform,
867  };
868 
871  enum class CurveType
872  {
873  Blend,
874  NURBS,
875  Circle,
876  Composite,
877  CurveOnSurface,
878  Ellipse,
879  Equation,
880  Helix,
881  Hyperbola,
882  Intersection,
883  Line,
884  Offset,
885  Parabola,
886  Polyline,
887  Transform,
888  };
889 
890  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
891  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
892 
895  enum class AnnotationCaptureFitting
896  {
897  PMIOnly,
898  ModelAndPMI
899  };
900 
902  class EXCHANGE_API Tessellation
903  {
904  public:
907  enum class Type
908  {
909  Standard,
910  Custom
911  };
912 
913 
916  enum class Level
917  {
918  ExtraLow,
919  Low,
920  Medium,
921  High,
922  ExtraHigh,
923  };
924 
926  class EXCHANGE_API Chord
927  {
928  public:
931  enum class Limit
932  {
935  Ratio,
938  Height
939  };
940 
941  private:
943  Chord();
944  };
945 
948  enum class Accuracy
949  {
952  Standard,
955  Accurate,
957  GridAccurate
958  };
959 
960  private:
962  Tessellation();
963  };
964 
966  class EXCHANGE_API JT
967  {
968  public:
971  enum class Content
972  {
973  Geometry,
974  Tessellation,
975  GeometryAndTessellation
976  };
977 
980  enum class TessellationLevel
981  {
982  Low,
983  Medium,
984  High,
985  };
986 
989  enum class Version
990  {
991  JT81,
992  JT95,
993  JT100,
994  };
995 
996  private:
998  JT();
999  };
1000 
1002  class EXCHANGE_API STEP
1003  {
1004  public:
1007  enum class Field
1008  {
1009  ProductName,
1010  NextAssemblyUsageOccurrenceID,
1011  NextAssemblyUsageOccurrenceName,
1012  NextAssemblyUsageOccurrenceDescription
1013  };
1014 
1017  enum class Format
1018  {
1019  AP203,
1020  AP214,
1021  AP242,
1022  };
1023 
1024  private:
1026  STEP();
1027  };
1028 
1030  class EXCHANGE_API PRC
1031  {
1032  public:
1035  enum class BRepCompression
1036  {
1037  None,
1038  Low,
1039  Medium,
1040  High
1041  };
1042 
1043  private:
1045  PRC();
1046  };
1047 
1049  class EXCHANGE_API ProE
1050  {
1051  public:
1054  enum class SessionColor
1055  {
1057  LastCreoVersion,
1059  ExchangeDefault,
1062  UserDefined
1063  };
1064 
1067  enum class FamilyTable
1068  {
1070  BRepOnly,
1072  BRepOrTessellation,
1074  BRepOrTessellationOrGeneric
1075  };
1076 
1079  enum class ConstructionEntities
1080  {
1082  On,
1084  Off,
1086  AsDatum,
1087  };
1088 
1089  private:
1091  ProE();
1092  };
1093 
1095  class EXCHANGE_API U3D
1096  {
1097  public:
1100  enum class Version
1101  {
1102  ECMA1,
1103  ECMA3
1104  };
1105 
1106  private:
1108  U3D();
1109  };
1110 
1112  class EXCHANGE_API Revit
1113  {
1114  public:
1115  enum class PhysicalProperties
1116  {
1118  NotComputed,
1120  Computed
1121  };
1122 
1123  private:
1125  Revit();
1126  };
1127 
1129  class EXCHANGE_API Configuration : public HPS::Sprocket
1130  {
1131  public:
1133  Configuration();
1134 
1137  Configuration(char const * in_name);
1138 
1143  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1144 
1148  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1149 
1152  Configuration(Configuration const & in_configuration);
1153 
1157  Configuration(Configuration && in_that);
1158 
1162  Configuration & operator=(Configuration && in_that);
1163 
1164  virtual ~Configuration();
1165 
1166  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1167  HPS::Type ObjectType() const { return staticType; }
1168 
1169 
1172  void Set(Configuration const & in_kit);
1173 
1176  void Show(Configuration & out_kit) const;
1177 
1181  Configuration & operator=(Configuration const & in_kit);
1182 
1185  bool Empty() const;
1186 
1190  bool Equals(Configuration const & in_kit) const;
1191 
1195  bool operator==(Configuration const & in_kit) const;
1196 
1200  bool operator!=(Configuration const & in_kit) const;
1201 
1202 
1205  HPS::UTF8 GetName() const;
1206 
1209  ConfigurationArray GetSubconfigurations() const;
1210  };
1211 
1213  class EXCHANGE_API File
1214  {
1215  public:
1218  enum class Format
1219  {
1220  Unsupported,
1221  ACIS,
1222  CADDS,
1223  CATIAV4,
1224  CATIAV5,
1225  CGR,
1226  COLLADA,
1227  CreoProE,
1228  DWG,
1229  DXF,
1230  IDEAS,
1231  IFC,
1232  IGES,
1233  Inventor,
1234  JT,
1235  KeyholeMarkupLanguage,
1236  LatticeXVL,
1237  OneSpaceDesigner,
1238  Parasolid,
1239  PDF,
1240  PRC,
1241  Rhino,
1242  NXUnigraphics,
1243  SolidEdge,
1244  SolidWorks,
1245  STEP,
1246  StereoLithography,
1247  ThreeDStudioMax,
1248  ThreeDXML,
1249  Universal3D,
1250  VDAFS,
1251  VRML,
1252  WavefrontObject,
1253  Revit,
1254  GLTF,
1255  DWF,
1256  FBX,
1257  STEPXML,
1258  };
1259 
1261  static Format GetFormat(char const * in_file_name);
1262 
1266  static ConfigurationArray GetConfigurations(char const * in_file_name);
1267 
1279  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);
1280 
1286  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1287 
1294  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1295 
1302  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1303 
1311  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1312 
1319  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1320 
1321 
1328  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1329 
1330 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1331 
1335  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1336 
1342  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1343 
1350  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1351 
1357  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1358 
1363  static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);
1364 
1369  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1370 
1375  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1376 
1382  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1383 
1389  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1390 
1397  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1398 
1405  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1406 
1410  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1411 
1416  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1417 
1421  static ExportNotifier ExportPRC(KeyPath const & in_source);
1422 
1427  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1428 
1433  static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);
1434 
1439  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1440 
1444  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1445 
1450  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1451 #endif
1452 
1453 #if TARGET_OS_ANDROID == 0
1454 
1458  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1459 
1464  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1465 
1470  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1471 #endif
1472 
1473  private:
1475  File();
1476  };
1477 
1479  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1480  {
1481  public:
1483  NURBSConversionOptionsKit();
1484 
1487  NURBSConversionOptionsKit(NURBSConversionOptionsKit const & in_kit);
1488 
1492  NURBSConversionOptionsKit(NURBSConversionOptionsKit && in_that);
1493 
1497  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1498 
1499  virtual ~NURBSConversionOptionsKit();
1500 
1501  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1502  HPS::Type ObjectType() const { return staticType; }
1503 
1506  void Set(NURBSConversionOptionsKit const & in_kit);
1507 
1510  void Show(NURBSConversionOptionsKit & out_kit) const;
1511 
1515  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1516 
1519  bool Empty() const;
1520 
1524  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1525 
1529  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1530 
1534  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1535 
1539  static NURBSConversionOptionsKit GetDefault();
1540 
1545  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1546 
1551  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1552 
1557  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1558 
1563  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1564 
1569  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1570 
1575  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1576 
1581  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1582 
1588  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1589 
1596  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1597 
1603  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1604 
1611  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1612 
1613 
1616  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1617 
1620  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1621 
1624  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1625 
1628  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1629 
1632  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1633 
1636  NURBSConversionOptionsKit & UnsetParameterization();
1637 
1640  NURBSConversionOptionsKit & UnsetTolerance();
1641 
1644  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1645 
1648  NURBSConversionOptionsKit & UnsetAllowedCurves();
1649 
1652  NURBSConversionOptionsKit & UnsetEverything();
1653 
1654 
1655 
1659  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1660 
1664  bool Show3DCurvesComputation(bool & out_state) const;
1665 
1670  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1671 
1675  bool ShowClosedFaceSplitting(bool & out_state) const;
1676 
1680  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1681 
1685  bool ShowParameterization(bool & out_state) const;
1686 
1690  bool ShowTolerance(double & out_tolerance) const;
1691 
1695  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1696 
1700  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1701  };
1702 
1704  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1705  {
1706  public:
1708  ImportOptionsKit();
1709 
1712  ImportOptionsKit(ImportOptionsKit const & in_kit);
1713 
1717  ImportOptionsKit(ImportOptionsKit && in_that);
1718 
1722  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1723 
1724  virtual ~ImportOptionsKit();
1725 
1726  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1727  HPS::Type ObjectType() const { return staticType; }
1728 
1732  static ImportOptionsKit GetDefault();
1733 
1736  void Set(ImportOptionsKit const & in_kit);
1737 
1740  void Show(ImportOptionsKit & out_kit) const;
1741 
1745  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1746 
1749  bool Empty() const;
1750 
1754  bool Equals(ImportOptionsKit const & in_kit) const;
1755 
1759  bool operator==(ImportOptionsKit const & in_kit) const;
1760 
1764  bool operator!=(ImportOptionsKit const & in_kit) const;
1765 
1766 
1772  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1773 
1779  ImportOptionsKit & SetSolids(bool in_state);
1780 
1786  ImportOptionsKit & SetSurfaces(bool in_state);
1787 
1793  ImportOptionsKit & SetWireframes(bool in_state);
1794 
1800  ImportOptionsKit & SetPMI(bool in_state);
1801 
1808  ImportOptionsKit & SetAttributes(bool in_state);
1809 
1815  ImportOptionsKit & SetHiddenObjects(bool in_state);
1816 
1822  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1823 
1829  ImportOptionsKit & SetActiveFilter(bool in_state);
1830 
1838  ImportOptionsKit & SetFeatureTrees(bool in_state);
1839 
1845  ImportOptionsKit & SetDrawings(bool in_state);
1846 
1852  ImportOptionsKit & SetDefaultUnits(Units in_units);
1853 
1859  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1860 
1866  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1867 
1874  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1875 
1882  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1883 
1889  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1890 
1896  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1897 
1905  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1906 
1913  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1914 
1922  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1923 
1931  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1932 
1938  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1939 
1945  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1946 
1953  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1954 
1966  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);
1967 
1973  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1974 
1980  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1981 
1987  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1988 
1993  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1994 
2001  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
2002 
2008  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
2009 
2018  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2019 
2028  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2029 
2035  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2036 
2041  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2042 
2049  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2050 
2055  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2056 
2062  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2063 
2068  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2069 
2075  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2076 
2083  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2084 
2091  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2092 
2098  ImportOptionsKit & SetCatiaV5MaterialRendering(bool in_active);
2099 
2107  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2108 
2115  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2116 
2122  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2123 
2129  ImportOptionsKit & SetProECodePageName(char const * in_name);
2130 
2136  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2137 
2143  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2144 
2150  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2151 
2158  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2159 
2166  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2167 
2174  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2175 
2182  ImportOptionsKit & SetProEHomeView(bool in_state);
2183 
2190  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2191 
2198  ImportOptionsKit & SetProEDatum(bool in_state);
2199 
2200 
2207  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2208 
2215  ImportOptionsKit & SetProESkeletons(bool in_state);
2216 
2223  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2224 
2230  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2231 
2237  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2238 
2244  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2245 
2251  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2252 
2258  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2259 
2265  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2266 
2273  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2274 
2280  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2281 
2287  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2288 
2295  ImportOptionsKit & SetIFCEdges(bool in_state);
2296 
2302  ImportOptionsKit & SetIFCMetadata(bool in_state);
2303 
2309  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2310 
2316  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2317 
2323  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2324 
2330  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2331 
2337  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2338 
2345  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2346 
2353  ImportOptionsKit & SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);
2354 
2358  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2359 
2371  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2372 
2384  ImportOptionsKit & SetMode(ImportMode in_mode);
2385 
2395  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2396 
2404  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2405 
2412  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2413 
2417  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2418 
2423  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2424 
2425  /* When this option is enabled, translations that are deemed to be especially large compared to the model size are removed from the
2426  * scene graph and instead imported as user data, at the index specified, on the segment where the translation would have been.
2427  * Removing very large translation is useful to avoid visual artifacts due to loss in precision.
2428  * Note that only part of a translation might be extracted.
2429  * If you are adding a model to an existing scene through the SetLocation feature, and the original model was loaded using the
2430  * SetLargeTranslationExtraction setting, the same data_index value should be used for the model being added to the existing scene,
2431  * so that any translations previously extracted from the model can be taken into account during import.
2432  * \param in_state Whether to enable large translation extraction
2433  * \param in_data_index The index at which the user data representing the extracted translation will be stored
2434  * \return A reference to this ImportOptionsKit. */
2435  ImportOptionsKit & SetLargeTranslationExtraction(bool in_state, intptr_t in_data_index = 1);
2436 
2439  ImportOptionsKit & UnsetBRepMode();
2440 
2443  ImportOptionsKit & UnsetSolids();
2444 
2447  ImportOptionsKit & UnsetSurfaces();
2448 
2451  ImportOptionsKit & UnsetWireframes();
2452 
2455  ImportOptionsKit & UnsetPMI();
2456 
2459  ImportOptionsKit & UnsetAttributes();
2460 
2463  ImportOptionsKit & UnsetHiddenObjects();
2464 
2467  ImportOptionsKit & UnsetConstructionAndReferences();
2468 
2471  ImportOptionsKit & UnsetActiveFilter();
2472 
2475  ImportOptionsKit & UnsetDrawings();
2476 
2479  ImportOptionsKit & UnsetFeatureTrees();
2480 
2483  ImportOptionsKit & UnsetSewingTolerance();
2484 
2487  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2488 
2491  ImportOptionsKit & UnsetDefaultUnits();
2492 
2495  ImportOptionsKit & UnsetMultiProcessCount();
2496 
2499  ImportOptionsKit & UnsetPMISubstitutionFont();
2500 
2503  ImportOptionsKit & UnsetPMIPrecision();
2504 
2507  ImportOptionsKit & UnsetPMIDefaultUnits();
2508 
2511  ImportOptionsKit & UnsetPMIDefaultColor();
2512 
2515  ImportOptionsKit & UnsetTessellationLevel();
2516 
2519  ImportOptionsKit & UnsetTessellationAccuracy();
2520 
2523  ImportOptionsKit & UnsetTessellationCleanup();
2524 
2527  ImportOptionsKit & UnsetPMIFlipping();
2528 
2531  ImportOptionsKit & UnsetRemovedViews();
2532 
2535  ImportOptionsKit & UnsetExternalProductOccurrence();
2536 
2539  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2540 
2543  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2544 
2547  ImportOptionsKit & UnsetTextureDirectories();
2548 
2551  ImportOptionsKit & UnsetSearchDirectories();
2552 
2555  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2556 
2559  ImportOptionsKit & UnsetSearchRootDirectory();
2560 
2563  ImportOptionsKit & UnsetConfiguration();
2564 
2567  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2568 
2571  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2572 
2575  ImportOptionsKit & UnsetCatiaV5Cache();
2576 
2579  ImportOptionsKit & UnsetCatiaV5MaterialRendering();
2580 
2583  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2584 
2587  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2588 
2591  ImportOptionsKit & UnsetProECodePageName();
2592 
2595  ImportOptionsKit & UnsetProEDimensionTolerance();
2596 
2599  ImportOptionsKit & UnsetProESubpartPMI();
2600 
2603  ImportOptionsKit & UnsetProESessionColor();
2604 
2607  ImportOptionsKit & UnsetProEDatum();
2608 
2611  ImportOptionsKit & UnsetProEHomeView();
2612 
2615  ImportOptionsKit & UnsetProEExplodedViews();
2616 
2619  ImportOptionsKit & UnsetProEMissingBoolean();
2620 
2623  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2624 
2627  ImportOptionsKit & UnsetProEFamilyTreeSource();
2628 
2631  ImportOptionsKit & UnsetProEConstructionEntities();
2632 
2635  ImportOptionsKit & UnsetProESkeletons();
2636 
2639  ImportOptionsKit & UnsetSTEPNamePreference();
2640 
2643  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2644 
2647  ImportOptionsKit & UnsetSTEPCodePageName();
2648 
2651  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2652 
2655  ImportOptionsKit & UnsetSTEPOrientationHealing();
2656 
2659  ImportOptionsKit & UnsetSTEPValidationProperties();
2660 
2663  ImportOptionsKit & UnsetIFCCodePageName();
2664 
2667  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2668 
2671  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2672 
2675  ImportOptionsKit & UnsetIFCFaceOptimization();
2676 
2679  ImportOptionsKit & UnsetIFCEdges();
2680 
2683  ImportOptionsKit & UnsetIFCMetadata();
2684 
2687  ImportOptionsKit & UnsetPDF3DStreamIndex();
2688 
2691  ImportOptionsKit & UnsetJTTessellationLevel();
2692 
2695  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2696 
2699  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2700 
2703  ImportOptionsKit & UnsetPRCReadHelper();
2704 
2707  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2708 
2711  ImportOptionsKit & UnsetRevitPhysicalProperties();
2712 
2715  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2716 
2719  ImportOptionsKit & UnsetLocation();
2720 
2723  ImportOptionsKit & UnsetMode();
2724 
2727  ImportOptionsKit & UnsetIncrementalComponentPaths();
2728 
2731  ImportOptionsKit & UnsetNURBSConversion();
2732 
2735  ImportOptionsKit & UnsetGeometryDefaultColor();
2736 
2737  /* Removes the large translation extraction setting.
2738  * \return A reference to this ImportOptionsKit. */
2739  ImportOptionsKit & UnsetLargeTranslationExtraction();
2740 
2743  ImportOptionsKit & UnsetEverything();
2744 
2748  bool ShowBRepMode(BRepMode & out_mode) const;
2749 
2753  bool ShowSolids(bool & out_state) const;
2754 
2758  bool ShowSurfaces(bool & out_state) const;
2759 
2763  bool ShowWireframes(bool & out_state) const;
2764 
2768  bool ShowPMI(bool & out_state) const;
2769 
2773  bool ShowAttributes(bool & out_state) const;
2774 
2778  bool ShowHiddenObjects(bool & out_state) const;
2779 
2783  bool ShowConstructionAndReferences(bool & out_state) const;
2784 
2788  bool ShowActiveFilter(bool & out_state) const;
2789 
2793  bool ShowDrawings(bool & out_state) const;
2794 
2798  bool ShowFeatureTrees(bool & out_state) const;
2799 
2803  bool ShowSewingTolerance(double & out_tolerance) const;
2804 
2808  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2809 
2813  bool ShowDefaultUnits(Units & out_units) const;
2814 
2818  bool ShowMultiProcessCount(unsigned int & out_count) const;
2819 
2824  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2825 
2829  bool ShowPMIPrecision(size_t & out_precision) const;
2830 
2834  bool ShowPMIDefaultUnits(Units & out_units) const;
2835 
2840  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2841 
2849  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2850 
2857  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2858 
2862  bool ShowTessellationCleanup(bool & out_cleanup) const;
2863 
2867  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2868 
2872  bool ShowRemovedViews(bool & out_read_removed_views) const;
2873 
2877  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2878 
2882  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2883 
2887  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2888 
2892  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2893 
2899  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2900 
2904  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2905 
2910  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2911 
2915  bool ShowConfiguration(UTF8Array & out_configuration) const;
2916 
2920  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2921 
2925  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2926 
2931  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2932 
2936  bool ShowCatiaV5MaterialRendering(bool & out_active) const;
2937 
2942  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2943 
2947  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2948 
2952  bool ShowProECodePageName(UTF8 & out_name) const;
2953 
2957  bool ShowProEDimensionTolerance(bool & out_state) const;
2958 
2962  bool ShowProESubpartPMI(bool & out_state) const;
2963 
2967  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2968 
2972  bool ShowProEDatum(bool & out_state) const;
2973 
2977  bool ShowProEHomeView(bool & out_state) const;
2978 
2982  bool ShowProEExplodedViews(bool & out_state) const;
2983 
2987  bool ShowProEMissingBoolean(bool & out_state) const;
2988 
2992  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2993 
2997  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2998 
3002  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
3003 
3007  bool ShowProESkeletons(bool & out_state) const;
3008 
3012  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
3013 
3017  bool ShowSTEPFirstColorPreference(bool & out_state) const;
3018 
3022  bool ShowSTEPCodePageName(UTF8 & out_name) const;
3023 
3027  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
3028 
3032  bool ShowSTEPOrientationHealing(bool & out_state) const;
3033 
3037  bool ShowSTEPValidationProperties(bool & out_state) const;
3038 
3042  bool ShowIFCCodePageName(UTF8 & out_name) const;
3043 
3047  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
3048 
3052  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
3053 
3057  bool ShowIFCFaceOptimization(bool & out_state) const;
3058 
3062  bool ShowIFCEdges(bool & out_state) const;
3063 
3067  bool ShowIFCMetadata(bool & out_state) const;
3068 
3072  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3073 
3077  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3078 
3082  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3083 
3087  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3088 
3092  bool ShowPRCReadHelper(bool & out_use_helper) const;
3093 
3097  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3098 
3102  bool ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;
3103 
3107  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3108 
3113  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3114 
3118  bool ShowMode(ImportMode & out_mode) const;
3119 
3123  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3124 
3128  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3129 
3133  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3134 
3135  /* Shows the large translation extraction setting.
3136  * \param out_state Whether to extract large translations during an import.
3137  * \param out_data_index The index at which the user data representing the extracted translation will be stored
3138  * \return <span class='code'>true</span> if a large translation extraction setting was specified, <span class='code'>false</span> otherwise. */
3139  bool ShowLargeTranslationExtraction(bool & out_state, intptr_t & out_data_index) const;
3140  };
3141 
3143  class EXCHANGE_API Translation
3144  {
3145  public:
3148  enum class Healing
3149  {
3150  Off,
3151  On,
3152  OnlyIfNotParasolid,
3153  };
3154 
3157  enum class AccurateEdges
3158  {
3159  Off,
3160  On,
3161  OnlyIfNotParasolid,
3162  };
3163 
3166  enum class Simplification
3167  {
3168  Off,
3169  On,
3170  OnlyIfNotParasolid,
3171  };
3172 
3175  enum class Merging
3176  {
3177  Off,
3178  On,
3179  OnlyIfNotParasolid,
3180  };
3181 
3182  private:
3184  Translation();
3185  };
3186 
3188  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3189  {
3190  public:
3192  TranslationOptionsKit();
3193 
3196  TranslationOptionsKit(TranslationOptionsKit const & in_kit);
3197 
3201  TranslationOptionsKit(TranslationOptionsKit && in_that);
3202 
3206  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3207 
3208  virtual ~TranslationOptionsKit();
3209 
3210  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3211  HPS::Type ObjectType() const { return staticType; }
3212 
3216  static TranslationOptionsKit GetDefault();
3217 
3220  void Set(TranslationOptionsKit const & in_kit);
3221 
3224  void Show(TranslationOptionsKit & out_kit) const;
3225 
3229  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3230 
3233  bool Empty() const;
3234 
3238  bool Equals(TranslationOptionsKit const & in_kit) const;
3239 
3243  bool operator==(TranslationOptionsKit const & in_kit) const;
3244 
3248  bool operator!=(TranslationOptionsKit const & in_kit) const;
3249 
3255  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3256 
3262  TranslationOptionsKit & SetTessellation(bool in_state);
3263 
3269  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3270 
3274  TranslationOptionsKit & SetApplication(char const * in_name);
3275 
3279  TranslationOptionsKit & SetVersion(char const * in_version);
3280 
3286  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3287 
3291  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3292 
3296  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3297 
3301  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3302 
3306  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3307 
3312  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3313 
3317  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3318 
3321  TranslationOptionsKit & UnsetSolidsAsFaces();
3322 
3325  TranslationOptionsKit & UnsetTessellation();
3326 
3329  TranslationOptionsKit & UnsetHiddenObjects();
3330 
3333  TranslationOptionsKit & UnsetApplication();
3334 
3337  TranslationOptionsKit & UnsetVersion();
3338 
3341  TranslationOptionsKit & UnsetHealing();
3342 
3345  TranslationOptionsKit & UnsetAccurateEdges();
3346 
3349  TranslationOptionsKit & UnsetSimplification();
3350 
3353  TranslationOptionsKit & UnsetEntityMerging();
3354 
3357  TranslationOptionsKit & UnsetSewing();
3358 
3361  TranslationOptionsKit & UnsetDisjointFaces();
3362 
3365  TranslationOptionsKit& UnsetExplodeMultiBodies();
3366 
3369  TranslationOptionsKit & UnsetEverything();
3370 
3371 
3375  bool ShowSolidsAsFaces(bool & out_state) const;
3376 
3380  bool ShowTessellation(bool & out_state) const;
3381 
3385  bool ShowHiddenObjects(bool & out_state) const;
3386 
3390  bool ShowApplication(UTF8 & out_name) const;
3391 
3395  bool ShowVersion(UTF8 & out_version) const;
3396 
3400  bool ShowExplodeMultiBodies(bool& out_state) const;
3401 
3405  bool ShowHealing(Translation::Healing & out_healing) const;
3406 
3410  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3411 
3415  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3416 
3420  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3421 
3426  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3427 
3431  bool ShowDisjointFaces(bool & out_state) const;
3432 
3437  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3438 
3441  TranslationOptionsKit & UnsetMultiProcessCount();
3442 
3446  bool ShowMultiProcessCount(unsigned int & out_count) const;
3447  };
3448 
3449 
3450 
3455  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3456  {
3457  public:
3459  ModelFileImportOptionsKit();
3460 
3463  ModelFileImportOptionsKit(ModelFileImportOptionsKit const & in_kit);
3464 
3468  ModelFileImportOptionsKit(ModelFileImportOptionsKit && in_that);
3469 
3473  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3474 
3475  virtual ~ModelFileImportOptionsKit();
3476 
3477  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3478  HPS::Type ObjectType() const { return staticType; }
3479 
3483  static ModelFileImportOptionsKit GetDefault();
3484 
3487  void Set(ModelFileImportOptionsKit const & in_kit);
3488 
3491  void Show(ModelFileImportOptionsKit & out_kit) const;
3492 
3496  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3497 
3500  bool Empty() const;
3501 
3505  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3506 
3510  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3511 
3515  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3516 
3517 
3518  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3519  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3520  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3521  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3522  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3523  * \return A reference to this ModelFileImportOptionsKit.
3524  */
3525  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3526 
3532  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3533 
3540  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3541 
3553  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);
3554 
3555  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3556  * \warning Setting this option to true will cause future exports to output without tessellation data.
3557  * \param in_cleanup Whether to clean up tessellation data from representation items.
3558  * \return A reference to this ImportOptionsKit.
3559  */
3560  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3561 
3567  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3568 
3574  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3575 
3582  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3583 
3587  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3588 
3601  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3602 
3608  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3609 
3616  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3617 
3621  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3622 
3627  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3628 
3634  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
3635 
3638  ModelFileImportOptionsKit & UnsetTessellationLevel();
3639 
3642  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3643 
3646  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3647 
3650  ModelFileImportOptionsKit & UnsetPMIFlipping();
3651 
3654  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3655 
3658  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3659 
3662  ModelFileImportOptionsKit & UnsetIFCEdges();
3663 
3666  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3667 
3670  ModelFileImportOptionsKit & UnsetLocation();
3671 
3674  ModelFileImportOptionsKit & UnsetSewingTolerance();
3675 
3678  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3679 
3682  ModelFileImportOptionsKit & UnsetNURBSConversion();
3683 
3686  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3687 
3690  ModelFileImportOptionsKit & UnsetHiddenObjects();
3691 
3694  ModelFileImportOptionsKit & UnsetEverything();
3695 
3696 
3704  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3705 
3712  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3713 
3717  bool ShowTessellationCleanup(bool & out_cleanup) const;
3718 
3722  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3723 
3727  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3728 
3732  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3733 
3737  bool ShowIFCEdges(bool & out_state) const;
3738 
3742  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3743 
3748  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3749 
3753  bool ShowSewingTolerance(double & out_tolerance) const;
3754 
3755 
3759  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3760 
3764  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3765 
3769  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3770 
3774  bool ShowHiddenObjects(bool & out_state) const;
3775  };
3776 
3777 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3778 
3779  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3780  {
3781  public:
3783  Export3MFOptionsKit();
3784 
3787  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3788 
3791  Export3MFOptionsKit(Export3MFOptionsKit && in_that);
3792 
3793  virtual ~Export3MFOptionsKit();
3794 
3795  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3796  HPS::Type ObjectType() const { return staticType; }
3797 
3801  static Export3MFOptionsKit GetDefault();
3802 
3805  void Set(Export3MFOptionsKit const & in_kit);
3806 
3809  void Show(Export3MFOptionsKit& out_kit) const;
3810 
3814  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3815 
3819  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3820 
3823  bool Empty() const;
3824 
3828  bool Equals(Export3MFOptionsKit const & in_kit) const;
3829 
3833  bool operator==(Export3MFOptionsKit const & in_kit) const;
3834 
3838  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3839 
3844  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3845 
3851  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3852 
3855  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3856 
3860  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3861 
3866  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3867 
3870  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3871 
3876  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3877 
3881  Export3MFOptionsKit & SetDescription(char const * in_description);
3882 
3885  Export3MFOptionsKit & UnsetDescription();
3886 
3890  bool ShowDescription(HPS::UTF8 & out_state) const;
3891 
3895  Export3MFOptionsKit & SetCopyright(char const * in_state);
3896 
3899  Export3MFOptionsKit & UnsetCopyright();
3900 
3904  bool ShowCopyright(HPS::UTF8 & out_state) const;
3905 
3909  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3910 
3913  Export3MFOptionsKit & UnsetLicenseTerms();
3914 
3918  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3919 
3922  Export3MFOptionsKit & UnsetEverything();
3923  };
3924 
3926  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
3927  {
3928  public:
3930  ExportFBXOptionsKit();
3931 
3934  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
3935 
3938  ExportFBXOptionsKit(ExportFBXOptionsKit && in_that);
3939 
3940  virtual ~ExportFBXOptionsKit();
3941 
3942  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
3943  HPS::Type ObjectType() const { return staticType; }
3944 
3948  static ExportFBXOptionsKit GetDefault();
3949 
3952  void Set(ExportFBXOptionsKit const & in_kit);
3953 
3956  void Show(ExportFBXOptionsKit & out_kit) const;
3957 
3961  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
3962 
3966  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
3967 
3970  bool Empty() const;
3971 
3975  bool Equals(ExportFBXOptionsKit const & in_kit) const;
3976 
3980  bool operator==(ExportFBXOptionsKit const & in_kit) const;
3981 
3985  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
3986 
3987 
3995  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
3996 
3997 
4003  ExportFBXOptionsKit & SetAscii(bool in_state);
4004 
4005 
4008  ExportFBXOptionsKit & UnsetTextureFolder();
4009 
4012  ExportFBXOptionsKit & UnsetAscii();
4013 
4016  ExportFBXOptionsKit & UnsetEverything();
4017 
4018 
4022  bool ShowTextureFolder(UTF8 & out_path) const;
4023 
4027  bool ShowAscii(bool & out_state) const;
4028  };
4029 
4031  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
4032  {
4033  public:
4035  ExportACISOptionsKit();
4036 
4039  ExportACISOptionsKit(ExportACISOptionsKit const & in_kit);
4040 
4043  ExportACISOptionsKit(ExportACISOptionsKit && in_that);
4044 
4045  virtual ~ExportACISOptionsKit();
4046 
4047  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
4048  HPS::Type ObjectType() const { return staticType; }
4049 
4053  static ExportACISOptionsKit GetDefault();
4054 
4057  void Set(ExportACISOptionsKit const & in_kit);
4058 
4061  void Show(ExportACISOptionsKit & out_kit) const;
4062 
4066  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
4067 
4071  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
4072 
4075  bool Empty() const;
4076 
4080  bool Equals(ExportACISOptionsKit const & in_kit) const;
4081 
4085  bool operator==(ExportACISOptionsKit const & in_kit) const;
4086 
4090  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4091 
4092 
4098  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4099 
4105  ExportACISOptionsKit & SetBinary(bool in_state);
4106 
4107 
4110  ExportACISOptionsKit & UnsetMillimeterUnits();
4111 
4114  ExportACISOptionsKit & UnsetBinary();
4115 
4118  ExportACISOptionsKit & UnsetEverything();
4119 
4120 
4124  bool ShowMillimeterUnits(bool & out_state) const;
4125 
4129  bool ShowBinary(bool & out_state) const;
4130  };
4131 
4133  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4134  {
4135  public:
4137  ExportJTOptionsKit();
4138 
4141  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4142 
4145  ExportJTOptionsKit(ExportJTOptionsKit && in_that);
4146 
4147  virtual ~ExportJTOptionsKit();
4148 
4149  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4150  HPS::Type ObjectType() const { return staticType; }
4151 
4155  static ExportJTOptionsKit GetDefault();
4156 
4159  void Set(ExportJTOptionsKit const & in_kit);
4160 
4163  void Show(ExportJTOptionsKit & out_kit) const;
4164 
4168  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4169 
4173  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4174 
4177  bool Empty() const;
4178 
4182  bool Equals(ExportJTOptionsKit const & in_kit) const;
4183 
4187  bool operator==(ExportJTOptionsKit const & in_kit) const;
4188 
4192  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4193 
4194 
4200  ExportJTOptionsKit & SetContent(JT::Content in_content);
4201 
4207  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4208 
4214  ExportJTOptionsKit & SetPMI(bool in_state);
4215 
4221  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4222 
4223 
4226  ExportJTOptionsKit & UnsetContent();
4227 
4230  ExportJTOptionsKit & UnsetHiddenObjects();
4231 
4234  ExportJTOptionsKit & UnsetPMI();
4235 
4238  ExportJTOptionsKit & UnsetVersion();
4239 
4242  ExportJTOptionsKit & UnsetEverything();
4243 
4244 
4248  bool ShowContent(JT::Content & out_content) const;
4249 
4253  bool ShowHiddenObjects(bool & out_state) const;
4254 
4258  bool ShowPMI(bool & out_state) const;
4259 
4263  bool ShowVersion(JT::Version & out_version) const;
4264  };
4265 
4267  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4268  {
4269  public:
4271  ExportPRCOptionsKit();
4272 
4275  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4276 
4279  ExportPRCOptionsKit(ExportPRCOptionsKit && in_that);
4280 
4281  virtual ~ExportPRCOptionsKit();
4282 
4283  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4284  HPS::Type ObjectType() const { return staticType; }
4285 
4289  static ExportPRCOptionsKit GetDefault();
4290 
4293  void Set(ExportPRCOptionsKit const & in_kit);
4294 
4297  void Show(ExportPRCOptionsKit & out_kit) const;
4298 
4302  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4303 
4307  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4308 
4311  bool Empty() const;
4312 
4316  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4317 
4321  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4322 
4326  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4327 
4328 
4334  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4335 
4342  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4343 
4349  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4350 
4356  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4357 
4362  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4363 
4369  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4370 
4371 
4374  ExportPRCOptionsKit & UnsetTessellationCompression();
4375 
4378  ExportPRCOptionsKit & UnsetBRepCompression();
4379 
4382  ExportPRCOptionsKit & UnsetBRepRemoval();
4383 
4386  ExportPRCOptionsKit & UnsetAttributeRemoval();
4387 
4390  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4391 
4394  ExportPRCOptionsKit & UnsetEverything();
4395 
4396 
4400  bool ShowTessellationCompression(bool & out_state) const;
4401 
4405  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4406 
4410  bool ShowBRepRemoval(bool & out_state) const;
4411 
4415  bool ShowAttributeRemoval(bool & out_state) const;
4416 
4420  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4421  };
4422 
4424  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4425  {
4426  public:
4428  ExportSTLOptionsKit();
4429 
4432  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4433 
4436  ExportSTLOptionsKit(ExportSTLOptionsKit && in_that);
4437 
4438  virtual ~ExportSTLOptionsKit();
4439 
4440  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4441  HPS::Type ObjectType() const { return staticType; }
4442 
4446  static ExportSTLOptionsKit GetDefault();
4447 
4450  void Set(ExportSTLOptionsKit const & in_kit);
4451 
4454  void Show(ExportSTLOptionsKit & out_kit) const;
4455 
4459  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4460 
4464  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4465 
4468  bool Empty() const;
4469 
4473  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4474 
4478  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4479 
4483  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4484 
4485 
4491  ExportSTLOptionsKit & SetBinary(bool in_state);
4492 
4498  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4499 
4506  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4507 
4513  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4514 
4520  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4521 
4528  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4529 
4539  ExportSTLOptionsKit & SetUnits(Units in_units);
4540 
4541 
4544  ExportSTLOptionsKit & UnsetBinary();
4545 
4548  ExportSTLOptionsKit & UnsetTessellationLevel();
4549 
4552  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4553 
4556  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4557 
4560  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4561 
4564  ExportSTLOptionsKit & UnsetUnits();
4565 
4568  ExportSTLOptionsKit & UnsetEverything();
4569 
4570 
4574  bool ShowBinary(bool & out_state) const;
4575 
4583  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4584 
4588  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4589 
4593  bool ShowCurrentTessellationRetention(bool & out_state) const;
4594 
4598  bool ShowMaximumEdgeLength(double & out_length) const;
4599 
4603  bool ShowUnits(Units & out_units) const;
4604  };
4605 
4607  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4608  {
4609  public:
4611  ExportOBJOptionsKit();
4612 
4615  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
4616 
4619  ExportOBJOptionsKit(ExportOBJOptionsKit && in_that);
4620 
4621  virtual ~ExportOBJOptionsKit();
4622 
4623  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
4624  HPS::Type ObjectType() const { return staticType; }
4625 
4629  static ExportOBJOptionsKit GetDefault();
4630 
4633  void Set(ExportOBJOptionsKit const & in_kit);
4634 
4637  void Show(ExportOBJOptionsKit & out_kit) const;
4638 
4642  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
4643 
4647  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
4648 
4651  bool Empty() const;
4652 
4656  bool Equals(ExportOBJOptionsKit const & in_kit) const;
4657 
4661  bool operator==(ExportOBJOptionsKit const & in_kit) const;
4662 
4666  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
4667 
4672  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
4673 
4677  bool ShowTextureFolder(UTF8 & out_path) const;
4678 
4681  ExportOBJOptionsKit & UnsetTextureFolder();
4682 
4685  ExportOBJOptionsKit & UnsetEverything();
4686  };
4687 
4689  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4690  {
4691  public:
4693  ExportU3DOptionsKit();
4694 
4697  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4698 
4701  ExportU3DOptionsKit(ExportU3DOptionsKit && in_that);
4702 
4703  virtual ~ExportU3DOptionsKit();
4704 
4705  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4706  HPS::Type ObjectType() const { return staticType; }
4707 
4711  static ExportU3DOptionsKit GetDefault();
4712 
4715  void Set(ExportU3DOptionsKit const & in_kit);
4716 
4719  void Show(ExportU3DOptionsKit & out_kit) const;
4720 
4724  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4725 
4729  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4730 
4733  bool Empty() const;
4734 
4738  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4739 
4743  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4744 
4748  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4749 
4750 
4756  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4757 
4762  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4763 
4764 
4767  ExportU3DOptionsKit & UnsetVersion();
4768 
4771  ExportU3DOptionsKit & UnsetCompression();
4772 
4775  ExportU3DOptionsKit & UnsetEverything();
4776 
4777 
4781  bool ShowVersion(U3D::Version & out_version) const;
4782 
4786  bool ShowCompression(unsigned char & out_level) const;
4787  };
4788 
4790  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4791  {
4792  public:
4794  ExportXMLOptionsKit();
4795 
4798  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4799 
4802  ExportXMLOptionsKit(ExportXMLOptionsKit && in_that);
4803 
4804  virtual ~ExportXMLOptionsKit();
4805 
4806  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4807  HPS::Type ObjectType() const { return staticType; }
4808 
4812  static ExportXMLOptionsKit GetDefault();
4813 
4816  void Set(ExportXMLOptionsKit const & in_kit);
4817 
4820  void Show(ExportXMLOptionsKit & out_kit) const;
4821 
4825  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4826 
4830  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4831 
4834  bool Empty() const;
4835 
4839  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4840 
4844  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4845 
4849  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4850 
4851 
4857  ExportXMLOptionsKit & SetMetadata(bool in_state);
4858 
4864  ExportXMLOptionsKit & SetTransformations(bool in_state);
4865 
4871  ExportXMLOptionsKit & SetMaterials(bool in_state);
4872 
4873 
4876  ExportXMLOptionsKit & UnsetMetadata();
4877 
4880  ExportXMLOptionsKit & UnsetTransformations();
4881 
4884  ExportXMLOptionsKit & UnsetMaterials();
4885 
4888  ExportXMLOptionsKit & UnsetEverything();
4889 
4890 
4894  bool ShowMetadata(bool & out_state) const;
4895 
4899  bool ShowTransformations(bool & out_state) const;
4900 
4904  bool ShowMaterials(bool & out_state) const;
4905  };
4906 #endif
4907 
4908 #if !defined(TARGET_OS_ANDROID)
4909 
4910  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4911  {
4912  public:
4914  ExportIGESOptionsKit();
4915 
4918  ExportIGESOptionsKit(ExportIGESOptionsKit const & in_kit);
4919 
4922  ExportIGESOptionsKit(ExportIGESOptionsKit && in_that);
4923 
4924  virtual ~ExportIGESOptionsKit();
4925 
4926  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4927  HPS::Type ObjectType() const { return staticType; }
4928 
4932  static ExportIGESOptionsKit GetDefault();
4933 
4936  void Set(ExportIGESOptionsKit const & in_kit);
4937 
4940  void Show(ExportIGESOptionsKit & out_kit) const;
4941 
4945  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4946 
4950  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4951 
4954  bool Empty() const;
4955 
4959  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4960 
4964  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4965 
4969  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4970 
4971 
4977  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4978 
4984  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4985 
4991  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4992 
4998  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4999 
5005  ExportIGESOptionsKit & SetTessellation(bool in_state);
5006 
5010  ExportIGESOptionsKit & SetApplication(char const * in_name);
5011 
5015  ExportIGESOptionsKit & SetVersion(char const * in_version);
5016 
5017 
5020  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
5021 
5024  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
5025 
5028  ExportIGESOptionsKit & UnsetSolidsAsFaces();
5029 
5032  ExportIGESOptionsKit & UnsetHiddenObjects();
5033 
5036  ExportIGESOptionsKit & UnsetTessellation();
5037 
5040  ExportIGESOptionsKit & UnsetApplication();
5041 
5044  ExportIGESOptionsKit & UnsetVersion();
5045 
5048  ExportIGESOptionsKit & UnsetEverything();
5049 
5050 
5054  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5055 
5059  bool ShowFacetedAsWireframe(bool & out_state) const;
5060 
5064  bool ShowSolidsAsFaces(bool & out_state) const;
5065 
5069  bool ShowHiddenObjects(bool & out_state) const;
5070 
5074  bool ShowTessellation(bool & out_state) const;
5075 
5079  bool ShowApplication(UTF8 & out_name) const;
5080 
5084  bool ShowVersion(UTF8 & out_version) const;
5085  };
5086 
5088  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5089  {
5090  public:
5092  ExportParasolidOptionsKit();
5093 
5096  ExportParasolidOptionsKit(ExportParasolidOptionsKit const & in_kit);
5097 
5100  ExportParasolidOptionsKit(ExportParasolidOptionsKit && in_that);
5101 
5102  virtual ~ExportParasolidOptionsKit();
5103 
5104  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5105  HPS::Type ObjectType() const { return staticType; }
5106 
5110  static ExportParasolidOptionsKit GetDefault();
5111 
5114  void Set(ExportParasolidOptionsKit const & in_kit);
5115 
5118  void Show(ExportParasolidOptionsKit & out_kit) const;
5119 
5123  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5124 
5128  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5129 
5132  bool Empty() const;
5133 
5137  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5138 
5142  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5143 
5147  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5148 
5149 
5155  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5156 
5162  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5163 
5169  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5170 
5174  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5175 
5179  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5180 
5186  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5187 
5190  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5191 
5194  ExportParasolidOptionsKit & UnsetTessellation();
5195 
5198  ExportParasolidOptionsKit & UnsetHiddenObjects();
5199 
5202  ExportParasolidOptionsKit & UnsetApplication();
5203 
5206  ExportParasolidOptionsKit & UnsetVersion();
5207 
5210  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5211 
5214  ExportParasolidOptionsKit & UnsetEverything();
5215 
5216 
5220  bool ShowSolidsAsFaces(bool & out_state) const;
5221 
5225  bool ShowTessellation(bool & out_state) const;
5226 
5230  bool ShowHiddenObjects(bool & out_state) const;
5231 
5235  bool ShowApplication(UTF8 & out_name) const;
5236 
5240  bool ShowVersion(UTF8 & out_version) const;
5241 
5245  bool ShowExplodeMultiBodies(bool& out_state) const;
5246  };
5247 
5249  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5250  {
5251  public:
5253  ExportSTEPOptionsKit();
5254 
5257  ExportSTEPOptionsKit(ExportSTEPOptionsKit const & in_kit);
5258 
5261  ExportSTEPOptionsKit(ExportSTEPOptionsKit && in_that);
5262 
5263  virtual ~ExportSTEPOptionsKit();
5264 
5265  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5266  HPS::Type ObjectType() const { return staticType; }
5267 
5271  static ExportSTEPOptionsKit GetDefault();
5272 
5275  void Set(ExportSTEPOptionsKit const & in_kit);
5276 
5279  void Show(ExportSTEPOptionsKit & out_kit) const;
5280 
5284  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5285 
5289  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5290 
5293  bool Empty() const;
5294 
5298  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5299 
5303  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5304 
5308  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5309 
5310 
5316  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5317 
5323  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5324 
5330  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5331 
5337  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5338 
5342  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5343 
5347  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5348 
5352  ExportSTEPOptionsKit & SetPMI(bool in_state);
5353 
5357  ExportSTEPOptionsKit & SetCurves(bool in_state);
5358 
5362  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5363 
5367  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5368 
5372  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5373 
5376  ExportSTEPOptionsKit & UnsetFormat();
5377 
5380  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5381 
5384  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5385 
5388  ExportSTEPOptionsKit & UnsetNameShortening();
5389 
5392  ExportSTEPOptionsKit & UnsetApplication();
5393 
5396  ExportSTEPOptionsKit & UnsetVersion();
5397 
5400  ExportSTEPOptionsKit & UnsetPMI();
5401 
5404  ExportSTEPOptionsKit & UnsetCurves();
5405 
5408  ExportSTEPOptionsKit & UnsetAttributes();
5409 
5412  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5413 
5416  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5417 
5420  ExportSTEPOptionsKit & UnsetEverything();
5421 
5422 
5426  bool ShowFormat(STEP::Format & out_format) const;
5427 
5431  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5432 
5436  bool ShowFacetedAsWireframe(bool & out_state) const;
5437 
5441  bool ShowNameShortening(bool & out_state) const;
5442 
5446  bool ShowApplication(UTF8 & out_name) const;
5447 
5451  bool ShowVersion(UTF8 & out_version) const;
5452 
5456  bool ShowPMI(bool & out_state) const;
5457 
5461  bool ShowCurves(bool & out_state) const;
5462 
5466  bool ShowAttributes(bool & out_state) const;
5467 
5471  bool ShowPMIWithSemantic(bool & out_state) const;
5472 
5476  bool ShowPMIAsTessellated(bool & out_state) const;
5477  };
5478 #endif
5479 
5481  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5482  {
5483  public:
5485  TessellationOptionsKit();
5486 
5489  TessellationOptionsKit(TessellationOptionsKit const & in_kit);
5490 
5493  TessellationOptionsKit(TessellationOptionsKit && in_that);
5494 
5495  virtual ~TessellationOptionsKit();
5496 
5497  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5498  HPS::Type ObjectType() const { return staticType; }
5499 
5503  static TessellationOptionsKit GetDefault();
5504 
5507  void Set(TessellationOptionsKit const & in_kit);
5508 
5511  void Show(TessellationOptionsKit & out_kit) const;
5512 
5516  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5517 
5521  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5522 
5525  bool Empty() const;
5526 
5530  bool Equals(TessellationOptionsKit const & in_kit) const;
5531 
5535  bool operator==(TessellationOptionsKit const & in_kit) const;
5536 
5540  bool operator!=(TessellationOptionsKit const & in_kit) const;
5541 
5542 
5546  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5547 
5554  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5555 
5565  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);
5566 
5570  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5571 
5575  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5576 
5577 
5580  TessellationOptionsKit & UnsetLevel();
5581 
5584  TessellationOptionsKit & UnsetAccuracy();
5585 
5588  TessellationOptionsKit & UnsetUVPointPreservation();
5589 
5592  TessellationOptionsKit & UnsetMaximumEdgeLength();
5593 
5596  TessellationOptionsKit & UnsetEverything();
5597 
5598 
5606  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5607 
5614  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5615 
5619  bool ShowUVPointPreservation(bool & out_state) const;
5620 
5624  bool ShowMaximumEdgeLength(double & out_length) const;
5625  };
5626 
5632  class EXCHANGE_API CommonMeasurementOperator : public Operator
5633  {
5634  public:
5635  enum class Tags
5636  {
5637  Name = 0,
5638  MeasurementType,
5639  Radius,
5640  Inverted,
5641  VectorX,
5642  VectorY,
5643  VectorZ,
5644  };
5645 
5646  CommonMeasurementOperator();
5647 
5648  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5649 
5651  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5652 
5653  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5654  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5655 
5656  Exchange::CADModel GetCADModel() const;
5657  void SetCADModel(Exchange::CADModel const & in_cad_model);
5658 
5660  size_t GetPrecision() const;
5661 
5664  void SetPrecision(size_t in_precision);
5665 
5667  MaterialMappingKit GetMaterial() const;
5668 
5671  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5672 
5674  TextAttributeKit GetTextAttributes() const;
5675 
5678  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5679 
5681  SegmentKey GetMeasurementSegment() const;
5682 
5684  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5685 
5686  /* Deletes all measurements */
5687  void DeleteMeasurements();
5688 
5689  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5690  {
5691  public:
5693  MeasurementInsertedEvent() : Event()
5694  {
5695  channel = GetClassID();
5696  consumable = false;
5697  }
5698 
5699  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5700  {
5701  channel = GetClassID();
5702  consumable = false;
5703  measurement_key = in_measurement_key;
5704  view = in_view;
5705  }
5706 
5709  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5710  {
5711  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5712  {
5713  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5714  measurement_key = that.measurement_key;
5715  view = that.view;
5716  }
5717  else
5718  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5719  }
5720 
5721  ~MeasurementInsertedEvent();
5722 
5725  Event * Clone() const
5726  {
5727  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5728  return new_event;
5729  }
5730 
5731  Key measurement_key;
5732  View view;
5733  };
5734 
5735  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5736  {
5737  public:
5739  MeasurementDeletedEvent() : Event()
5740  {
5741  channel = GetClassID();
5742  consumable = false;
5743  }
5744 
5745  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5746  {
5747  channel = GetClassID();
5748  consumable = false;
5749  measurement_name = in_measurement_name;
5750  view = in_view;
5751  }
5752 
5755  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5756  {
5757  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5758  {
5759  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5760  measurement_name = that.measurement_name;
5761  view = that.view;
5762  }
5763  else
5764  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5765  }
5766 
5767  ~MeasurementDeletedEvent();
5768 
5771  Event * Clone() const
5772  {
5773  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5774  return new_event;
5775  }
5776 
5777  UTF8 measurement_name;
5778  View view;
5779  };
5780 
5781  protected:
5782  Exchange::CADModel cad_model;
5783  size_t measurement_precision;
5784  UTF8 units;
5785  MaterialMappingKit materials;
5786  TextAttributeKit text_attributes;
5787  SegmentKey measurement_segment;
5788  GlyphDefinition left_arrow;
5789  GlyphDefinition right_arrow;
5790  SelectionOptionsKit selection_options;
5791  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5792  Vector camera_direction;
5793  PortfolioKey portfolio;
5794  SegmentKey style_segment;
5795  HighlightOptionsKit highlight_options;
5796 
5797  static size_t length_measurement_index;
5798  static size_t radius_measurement_index;
5799  static size_t distance_measurement_index;
5800  static size_t angle_measurement_index;
5801 
5802  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5803  void GetUnits();
5804  void SetGlyphColor();
5805  void GetCameraDirection();
5806  void SetupConstructionSegment();
5807  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5808  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5809  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5810  float GetModelScale(Exchange::Component const & component);
5811  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5812  };
5813 
5866  class EXCHANGE_API MeasurementOperator : public CommonMeasurementOperator
5867  {
5868  public:
5869  enum class MeasurementType
5870  {
5871  PointToPoint,
5872  EdgeAndRadius,
5873  FeatureToFeature,
5874  FaceAngle,
5875  };
5876 
5877  MeasurementOperator();
5878 
5879  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5880 
5882  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5883 
5884  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5885  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5886 
5891  virtual bool OnMouseDown(MouseState const & in_state) override;
5892 
5896  virtual bool OnMouseUp(MouseState const & in_state) override;
5897 
5903  virtual bool OnMouseMove(MouseState const & in_state) override;
5904 
5909  virtual bool OnTouchDown(TouchState const & in_state) override;
5910 
5914  virtual bool OnTouchUp(TouchState const & in_state) override;
5915 
5921  virtual bool OnTouchMove(TouchState const & in_state) override;
5922 
5926  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5927 
5930  void SetMeasurementType(MeasurementType in_measurement_type);
5931 
5934  MeasurementType GetMeasurementType();
5935 
5938  void SetMouseOverHighlighting(bool in_highlighting);
5939 
5943  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5944 
5947  bool GetMouseOverHighlighting();
5948 
5951  HighlightOptionsKit GetHighlightOptions();
5952 
5955  bool IsMeasurementActive();
5956 
5958  void DeleteLastMeasurement();
5959 
5960  private:
5961  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5962  {
5963  Circle,
5964  Line,
5965  Generic,
5966  };
5967 
5968  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5969  {
5970  public:
5971  Surface();
5972 
5973  enum class SurfaceType
5974  {
5975  Plane,
5976  ConeOrCylinder,
5977  Unsupported,
5978  };
5979 
5980  SurfaceType surface_type; //the type of surface being measured
5981  Point center; //the center point of the surface
5982  Vector normal; //the center line of surfaces of type Cylinder or Cone
5983  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5984  ComponentPath path; //the ComponentPath to this surface
5985  };
5986 
5987  //bookkeeping
5988  MeasurementType measurement_type; //the type of measurement to be inserted
5989  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5990  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5991  TouchID current_touch_id; //the ID of the touch being processed
5992  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5993  bool operator_active; //whether a measurement is in progress
5994  bool end_measurement; //whether we should end the current measurement
5995  CanvasArray canvases; //canvases related to the view where this operator is attached
5996 
5997  //measurement anchors
5998  size_t anchors; //valid for point-to-point and face-angle measurements
5999  bool anchors_in_place; //true if all the anchors have been placed
6000  Point first_click_position; //position of the first anchor
6001  Point second_click_position; //position of the second anchor
6002 
6003  //geometry for linear measurements
6004  MarkerKey anchor_one; //marker corresponding to the start of the measurement
6005  MarkerKey anchor_two; //marker corresponding to the end of the measurement
6006  LineKey distance_line; //a line representing the distance measured
6007  LineKey leader_line_one; //line connecting the first anchor point to the distance line
6008  LineKey leader_line_two; //line connecting the second anchor point to the distance line
6009  Point distance_point_one; //intersection of leader_line_one and distance_line
6010  Point distance_point_two; //intersection of leader_line_two and distance_line
6011  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
6012  TextKey text; //text representing the measurement and units
6013  UTF8 text_string; //the contents of the text
6014  Vector measurement_direction; //the direction of the measurement
6015  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
6016  Vector explicit_direction; //used if use_explicit_direction is true
6017 
6018  //geometry for radius measurement
6019  MarkerKey center_marker; //marker representing the center of the circle
6020  Point circle_center; //circle center
6021  float radius; //circle radius
6022 
6023  //edge specific data
6024  LineKey edge_line; //the edge being measured
6025  double edge_length; //length of the measured edge
6026  EdgeType edge_type; //the type of edge being measured
6027 
6028  //feature-to-feature specific data
6029  Surface surface_one; //data related to first selected surface
6030  Surface surface_two; //data related to second selected surface
6031  Plane measurement_plane; //the measurement plane
6032  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
6033 
6034  //angle specific data
6035  Vector leader_line_one_direction; //the direction of the first leader line
6036  Vector leader_line_two_direction; //the direction of the second leader line
6037  Vector first_face_normal; //the normal of the first selected face
6038  Vector second_face_normal; //the normal of the second selected face
6039  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'
6040  CircularArcKey measurement_arc; //an arc representing the measured angle
6041  LineKey line_to_leader_line; //line extending from one anchor to a leader line
6042  Vector mid_point_direction;
6043 
6044  //selection kits
6045  SelectionOptionsKit point_to_point_selection;
6046  SelectionOptionsKit edge_radius_selection;
6047  SelectionOptionsKit feature_to_feature_selection;
6048  SelectionOptionsKit angle_selection;
6049 
6050  //highlighting
6051  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
6052  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
6053  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
6054  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
6055  KeyPath highlighted_path; //highlighted_path
6056  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
6057  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
6058 
6059  //input handling
6060  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
6061  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
6062  bool InputUp(WindowKey & in_window);
6063  void ResetMeasurement();
6064 
6065  //inserting measurements
6066  void InsertPointToPointMeasurement(Point const & in_world_point);
6067  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
6068  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
6069  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
6070  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
6071  void InvertMeasuredAngle(WindowKey & in_window);
6072  void AdjustLineToCursor(Point const & cursor_position);
6073 
6074  //saving measurements
6075  void TagMeasurement();
6076  void TagPointToPointMeasurement();
6077  void TagEdgeMeasurement();
6078  void TagRadiusMeasurement();
6079  void TagGenericEdgeMeasurement();
6080  void TagFeatureToFeatureMeasurement();
6081  void TagAngleMeasurement();
6082 
6083  //restoring measurements
6084  void RestoreMeasurement(SegmentKey const & measurement_segment);
6085  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6086  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6087  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6088  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6089  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6090  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6091 
6092  //topology functions
6093  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6094  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6095  void PlaneToCenterLineDistance();
6096  void PlaneToPlaneDistance();
6097  void LineToLineDistance();
6098  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);
6099  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6100  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6101  bool IsPlane(Exchange::Component const & face_component);
6102  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6103  };
6104 
6105 private:
6107  Exchange();
6108 };
6109 
6110 }
6111 
6112 #endif
HPS::WindowPoint
Definition: hps.h:6349
HPS
Definition: hps.h:85
HPS::Exchange::ExportPRCOptionsKit
Definition: sprk_exchange.h:4267
HPS::Exchange::Tessellation::Level
Level
Definition: sprk_exchange.h:916
HPS::Exchange::ProE::ConstructionEntities
ConstructionEntities
Definition: sprk_exchange.h:1079
HPS::Exchange
Definition: sprk_exchange.h:44
HPS::Exchange::PRC
Definition: sprk_exchange.h:1030
HPS::View
Definition: sprk.h:273
HPS::Exchange::ExportSTEPOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5266
HPS::Exchange::File
Definition: sprk_exchange.h:1213
HPS::Exchange::CommonMeasurementOperator
Definition: sprk_exchange.h:5632
HPS::Exchange::ExportOBJOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4624
HPS::Exchange::ExportIGESOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4927
HPS::InvalidSpecificationException
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5953
HPS::Exchange::Units
Units
Definition: sprk_exchange.h:65
HPS::Sprocket
Definition: sprk.h:67
HPS::Exchange::Translation::Simplification
Simplification
Definition: sprk_exchange.h:3166
HPS::Canvas
Definition: sprk.h:106
HPS::Exchange::CommonMeasurementOperator::GetName
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5651
HPS::Exchange::TranslationNotifier
Definition: sprk_exchange.h:656
HPS::Exchange::U3D::Version
Version
Definition: sprk_exchange.h:1100
HPS::Exchange::ModelFileImportOptionsKit
Definition: sprk_exchange.h:3455
HPS::Exchange::Tessellation::Chord
Definition: sprk_exchange.h:926
HPS::Event::GetChannel
intptr_t GetChannel() const
Definition: hps.h:6466
HPS::Exchange::ReloadNotifier
Definition: sprk_exchange.h:757
HPS::Exchange::SurfaceType
SurfaceType
Definition: sprk_exchange.h:848
HPS::Line
Definition: hps.h:1766
HPS::Exchange::STEP::Format
Format
Definition: sprk_exchange.h:1017
HPS::Exchange::ExportXMLOptionsKit
Definition: sprk_exchange.h:4790
HPS::SprocketKit
Definition: sprk.h:242
HPS::Exchange::TessellationOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5498
HPS::KeyPathArray
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6815
HPS::ByteArray
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6791
HPS::KeyboardState
Definition: hps.h:48973
HPS::Exchange::File::Format
Format
Definition: sprk_exchange.h:1218
HPS::SegmentKey
Definition: hps.h:7857
HPS::BoolArray
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6785
HPS::Exchange::Tessellation::Type
Type
Definition: sprk_exchange.h:907
HPS::Exchange::Export3MFOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3796
HPS::MaterialMappingKit
Definition: hps.h:16560
HPS::Exchange::Configuration::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1167
HPS::Exchange::Filter
Definition: sprk_exchange.h:504
HPS::Exchange::ImportNotifier
Definition: sprk_exchange.h:595
HPS::Exchange::CADModel
Definition: sprk_exchange.h:334
HPS::Exchange::NURBSConversionOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1502
HPS::Exchange::Filter::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:531
HPS::Exchange::ExportXMLOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4807
HPS::Exchange::ExportU3DOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4706
HPS::Exchange::ExportFBXOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3943
HPS::Exchange::ProductOccurrence::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
HPS::Exchange::ReloadNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:786
HPS::Exchange::CommonMeasurementOperator::MeasurementInsertedEvent::MeasurementInsertedEvent
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5709
HPS::Exchange::NURBSConversionOptionsKit
Definition: sprk_exchange.h:1479
HPS::Exchange::Sheet
Definition: sprk_exchange.h:274
HPS::Exchange::ImportNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:624
HPS::Exchange::ExportJTOptionsKit
Definition: sprk_exchange.h:4133
HPS::Exchange::Translation::Merging
Merging
Definition: sprk_exchange.h:3175
HPS::Exchange::Revit
Definition: sprk_exchange.h:1112
HPS::Exchange::STEP::Field
Field
Definition: sprk_exchange.h:1007
HPS::Exchange::ExportOBJOptionsKit
Definition: sprk_exchange.h:4607
HPS::TouchState
Definition: hps.h:48871
HPS::GlyphDefinition
Definition: hps.h:42237
HPS::Exchange::ExportACISOptionsKit
Definition: sprk_exchange.h:4031
HPS::Exchange::TranslationOptionsKit
Definition: sprk_exchange.h:3188
HPS::Point_3D< float >
HPS::Exchange::CommonMeasurementOperator::MeasurementDeletedEvent::Clone
Event * Clone() const
Definition: sprk_exchange.h:5771
HPS::Exchange::Tessellation::Chord::Limit
Limit
Definition: sprk_exchange.h:931
HPS::RGBAColor
Definition: hps.h:4607
HPS::Exchange::ModelFileImportOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3478
HPS::Exchange::JT::TessellationLevel
TessellationLevel
Definition: sprk_exchange.h:980
HPS::Exchange::Tessellation
Definition: sprk_exchange.h:902
HPS::Exchange::ExportSTLOptionsKit
Definition: sprk_exchange.h:4424
HPS::Exchange::Component
Definition: sprk_exchange.h:113
HPS::Exchange::STEP
Definition: sprk_exchange.h:1002
HPS::Exchange::ExportFBXOptionsKit
Definition: sprk_exchange.h:3926
HPS::RGBColor
Definition: hps.h:4546
HPS::UTF8
Definition: hps.h:7228
HPS::MouseButtons
Definition: hps.h:48342
HPS::Exchange::ExportACISOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4048
HPS::Exchange::Capture
Definition: sprk_exchange.h:455
HPS::Exchange::UnloadMode
UnloadMode
Definition: sprk_exchange.h:82
HPS::SelectionOptionsKit
Definition: hps.h:44250
HPS::MouseState
Definition: hps.h:48758
HPS::DWG
Definition: sprk_dwg.h:43
HPS::Exchange::AnnotationCaptureFitting
AnnotationCaptureFitting
Definition: sprk_exchange.h:895
HPS::Exchange::ExportU3DOptionsKit
Definition: sprk_exchange.h:4689
HPS::Exchange::JT
Definition: sprk_exchange.h:966
HPS::MatrixKit
Definition: hps.h:15947
HPS::IntArray
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6771
HPS::Exchange::U3D
Definition: sprk_exchange.h:1095
HPS::Exchange::ProE::SessionColor
SessionColor
Definition: sprk_exchange.h:1054
HPS::Component
Definition: sprk.h:1778
HPS::IONotifier
Definition: hps.h:49080
HPS::Exchange::LoadStatus
LoadStatus
Definition: sprk_exchange.h:97
HPS::HighlightOptionsKit
Definition: hps.h:45457
HPS::ModifierKeys
Definition: hps.h:47849
HPS::Exchange::CurveType
CurveType
Definition: sprk_exchange.h:871
HPS::Exchange::Factory
Definition: sprk_exchange.h:549
HPS::Event
Definition: hps.h:6433
HPS::TextAttributeKit
Definition: hps.h:14195
HPS::Vector_3D< float >
HPS::UTF8Array
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6783
HPS::Exchange::MeasurementOperator
Definition: sprk_exchange.h:5866
HPS::Model
Definition: sprk.h:484
HPS::Exchange::PRC::BRepCompression
BRepCompression
Definition: sprk_exchange.h:1035
HPS::Exchange::ExportParasolidOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5105
HPS::Parasolid
Definition: sprk_parasolid.h:39
HPS::Exchange::BRepMode
BRepMode
Definition: sprk_exchange.h:821
HPS::ComponentPath
Definition: sprk.h:2148
HPS::Component::ComponentType
ComponentType
Definition: sprk.h:1784
HPS::Exchange::Tessellation::Accuracy
Accuracy
Definition: sprk_exchange.h:948
HPS::Exchange::Export3MFOptionsKit
Definition: sprk_exchange.h:3779
HPS::Exchange::ExportIGESOptionsKit
Definition: sprk_exchange.h:4910
HPS::Exchange::CommonMeasurementOperator::MeasurementDeletedEvent::MeasurementDeletedEvent
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5755
HPS::Filter
Definition: sprk.h:2854
HPS::Exchange::ProE::FamilyTable
FamilyTable
Definition: sprk_exchange.h:1067
HPS::Exchange::ExportSTLOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4441
HPS::Exchange::JT::Content
Content
Definition: sprk_exchange.h:971
HPS::Exchange::ImportOptionsKit
Definition: sprk_exchange.h:1704
HPS::Capture
Definition: sprk.h:2954
HPS::Exchange::ExportJTOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4150
HPS::MouseButtons::ButtonLeft
static MouseButtons ButtonLeft()
Definition: hps.h:48460
HPS::Exchange::MeasurementOperator::GetName
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5882
HPS::Exchange::CommonMeasurementOperator::MeasurementInsertedEvent::Clone
Event * Clone() const
Definition: sprk_exchange.h:5725
HPS::Key
Definition: hps.h:7775
HPS::Exchange::TranslationNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:685
HPS::Exchange::ProE
Definition: sprk_exchange.h:1049
HPS::Exchange::Translation::AccurateEdges
AccurateEdges
Definition: sprk_exchange.h:3157
HPS::Exchange::CADModel::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
HPS::Exchange::Component::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
HPS::KeyPath
Definition: hps.h:9488
HPS::Exchange::ExportNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:739
HPS::Exchange::ExportNotifier
Definition: sprk_exchange.h:710
HPS::LineKey
Definition: hps.h:24811
HPS::Exchange::Translation::Healing
Healing
Definition: sprk_exchange.h:3148
HPS::CADModel
Definition: sprk.h:3041
HPS::TextKey
Definition: hps.h:31244
HPS::Exchange::Revit::PhysicalProperties
PhysicalProperties
Definition: sprk_exchange.h:1115
HPS::Exchange::Sheet::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
HPS::Exchange::ImportMode
ImportMode
Definition: sprk_exchange.h:836
HPS::Exchange::Configuration
Definition: sprk_exchange.h:1129
HPS::Cylinder
Definition: hps.h:515
HPS::Operator
Definition: sprk.h:1107
HPS::Exchange::Translation
Definition: sprk_exchange.h:3143
HPS::Exchange::Capture::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
HPS::Plane_3D< float >
HPS::Factory::CreateModel
static Model CreateModel(char const *in_name="")
HPS::Exchange::ExportParasolidOptionsKit
Definition: sprk_exchange.h:5088
HPS::Exchange::ImportOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1727
HPS::Exchange::ProductOccurrence
Definition: sprk_exchange.h:203
HPS::Exchange::TranslationOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3211
HPS::PortfolioKey
Definition: hps.h:41733
HPS::Exchange::JT::Version
Version
Definition: sprk_exchange.h:989
HPS::Exchange::TessellationOptionsKit
Definition: sprk_exchange.h:5481
HPS::Exchange::ExportPRCOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4284
HPS::ImageKit
Definition: hps.h:42868
HPS::Exchange::ExportSTEPOptionsKit
Definition: sprk_exchange.h:5249