sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas & 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:
661 
664  TranslationNotifier(TranslationNotifier const & in_that);
665 
670  TranslationNotifier(IONotifier const & in_that);
671 
676 
680  TranslationNotifier & operator=(TranslationNotifier && in_that);
681 
682  virtual ~TranslationNotifier();
683 
684  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
685  HPS::Type ObjectType() const { return staticType; };
686 
690  TranslationNotifier & operator=(TranslationNotifier const & in_that);
691 
694  void Assign(TranslationNotifier const & in_that);
695 
698  Exchange::ParasolidEntityArray GetParasolidParts() const;
699 
702  HPS::Time GetImportTime() const;
703 
706  HPS::Time GetTranslationTime() const;
707  };
708 
710  class EXCHANGE_API ExportNotifier : public IONotifier
711  {
712  public:
714  ExportNotifier();
715 
718  ExportNotifier(ExportNotifier const & in_that);
719 
724  ExportNotifier(IONotifier const & in_that);
725 
729  ExportNotifier(ExportNotifier && in_that);
730 
734  ExportNotifier & operator=(ExportNotifier && in_that);
735 
736  virtual ~ExportNotifier();
737 
738  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
739  HPS::Type ObjectType() const { return staticType; };
740 
744  ExportNotifier & operator=(ExportNotifier const & in_that);
745 
748  void Assign(ExportNotifier const & in_that);
749 
753  A3DAsmModelFile * GetModelFile() const;
754  };
755 
757  class EXCHANGE_API ReloadNotifier : public IONotifier
758  {
759  public:
761  ReloadNotifier();
762 
765  ReloadNotifier(ReloadNotifier const & in_that);
766 
771  ReloadNotifier(IONotifier const & in_that);
772 
776  ReloadNotifier(ReloadNotifier && in_that);
777 
781  ReloadNotifier & operator=(ReloadNotifier && in_that);
782 
783  virtual ~ReloadNotifier();
784 
785  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
786  HPS::Type ObjectType() const { return staticType; };
787 
791  ReloadNotifier & operator=(ReloadNotifier const & in_that);
792 
795  void Assign(ReloadNotifier const & in_that);
796  };
797 
798 
799  class ImportOptionsKit;
800  class ModelFileImportOptionsKit;
801 
802 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
803  class Export3MFOptionsKit;
804  class ExportFBXOptionsKit;
805  class ExportACISOptionsKit;
806  class ExportJTOptionsKit;
807  class ExportPRCOptionsKit;
808  class ExportSTLOptionsKit;
809  class ExportOBJOptionsKit;
810  class ExportU3DOptionsKit;
811  class ExportXMLOptionsKit;
812 #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 
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 
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:
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:
1484 
1488 
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 
1858  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1859 
1865  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1866 
1873  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1874 
1881  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1882 
1888  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1889 
1895  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1896 
1904  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1905 
1912  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1913 
1921  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1922 
1930  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1931 
1937  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1938 
1944  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1945 
1952  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1953 
1965  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);
1966 
1972  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1973 
1979  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1980 
1986  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1987 
1992  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1993 
2000  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
2001 
2007  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
2008 
2017  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2018 
2027  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2028 
2034  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2035 
2040  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2041 
2048  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2049 
2054  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2055 
2061  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2062 
2067  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2068 
2074  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2075 
2082  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2083 
2090  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2091 
2097  ImportOptionsKit & SetCatiaV5MaterialRendering(bool in_active);
2098 
2106  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2107 
2114  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2115 
2121  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2122 
2128  ImportOptionsKit & SetProECodePageName(char const * in_name);
2129 
2135  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2136 
2142  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2143 
2149  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2150 
2157  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2158 
2165  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2166 
2173  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2174 
2181  ImportOptionsKit & SetProEHomeView(bool in_state);
2182 
2189  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2190 
2197  ImportOptionsKit & SetProEDatum(bool in_state);
2198 
2199 
2206  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2207 
2214  ImportOptionsKit & SetProESkeletons(bool in_state);
2215 
2222  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2223 
2229  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2230 
2236  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2237 
2243  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2244 
2250  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2251 
2257  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2258 
2264  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2265 
2272  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2273 
2279  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2280 
2286  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2287 
2294  ImportOptionsKit & SetIFCEdges(bool in_state);
2295 
2301  ImportOptionsKit & SetIFCMetadata(bool in_state);
2302 
2308  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2309 
2315  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2316 
2322  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2323 
2329  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2330 
2336  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2337 
2344  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2345 
2352  ImportOptionsKit & SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);
2353 
2357  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2358 
2370  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2371 
2383  ImportOptionsKit & SetMode(ImportMode in_mode);
2384 
2394  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2395 
2403  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2404 
2411  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2412 
2416  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2417 
2422  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2423 
2426  ImportOptionsKit & UnsetBRepMode();
2427 
2430  ImportOptionsKit & UnsetSolids();
2431 
2434  ImportOptionsKit & UnsetSurfaces();
2435 
2438  ImportOptionsKit & UnsetWireframes();
2439 
2442  ImportOptionsKit & UnsetPMI();
2443 
2446  ImportOptionsKit & UnsetAttributes();
2447 
2450  ImportOptionsKit & UnsetHiddenObjects();
2451 
2454  ImportOptionsKit & UnsetConstructionAndReferences();
2455 
2458  ImportOptionsKit & UnsetActiveFilter();
2459 
2462  ImportOptionsKit & UnsetDrawings();
2463 
2466  ImportOptionsKit & UnsetFeatureTrees();
2467 
2470  ImportOptionsKit & UnsetSewingTolerance();
2471 
2474  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2475 
2478  ImportOptionsKit & UnsetDefaultUnits();
2479 
2482  ImportOptionsKit & UnsetMultiProcessCount();
2483 
2486  ImportOptionsKit & UnsetPMISubstitutionFont();
2487 
2490  ImportOptionsKit & UnsetPMIPrecision();
2491 
2494  ImportOptionsKit & UnsetPMIDefaultUnits();
2495 
2498  ImportOptionsKit & UnsetPMIDefaultColor();
2499 
2502  ImportOptionsKit & UnsetTessellationLevel();
2503 
2506  ImportOptionsKit & UnsetTessellationAccuracy();
2507 
2510  ImportOptionsKit & UnsetTessellationCleanup();
2511 
2514  ImportOptionsKit & UnsetPMIFlipping();
2515 
2518  ImportOptionsKit & UnsetRemovedViews();
2519 
2522  ImportOptionsKit & UnsetExternalProductOccurrence();
2523 
2526  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2527 
2530  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2531 
2534  ImportOptionsKit & UnsetTextureDirectories();
2535 
2538  ImportOptionsKit & UnsetSearchDirectories();
2539 
2542  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2543 
2546  ImportOptionsKit & UnsetSearchRootDirectory();
2547 
2550  ImportOptionsKit & UnsetConfiguration();
2551 
2554  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2555 
2558  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2559 
2562  ImportOptionsKit & UnsetCatiaV5Cache();
2563 
2566  ImportOptionsKit & UnsetCatiaV5MaterialRendering();
2567 
2570  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2571 
2574  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2575 
2578  ImportOptionsKit & UnsetProECodePageName();
2579 
2582  ImportOptionsKit & UnsetProEDimensionTolerance();
2583 
2586  ImportOptionsKit & UnsetProESubpartPMI();
2587 
2590  ImportOptionsKit & UnsetProESessionColor();
2591 
2594  ImportOptionsKit & UnsetProEDatum();
2595 
2598  ImportOptionsKit & UnsetProEHomeView();
2599 
2602  ImportOptionsKit & UnsetProEExplodedViews();
2603 
2606  ImportOptionsKit & UnsetProEMissingBoolean();
2607 
2610  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2611 
2614  ImportOptionsKit & UnsetProEFamilyTreeSource();
2615 
2618  ImportOptionsKit & UnsetProEConstructionEntities();
2619 
2622  ImportOptionsKit & UnsetProESkeletons();
2623 
2626  ImportOptionsKit & UnsetSTEPNamePreference();
2627 
2630  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2631 
2634  ImportOptionsKit & UnsetSTEPCodePageName();
2635 
2638  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2639 
2642  ImportOptionsKit & UnsetSTEPOrientationHealing();
2643 
2646  ImportOptionsKit & UnsetSTEPValidationProperties();
2647 
2650  ImportOptionsKit & UnsetIFCCodePageName();
2651 
2654  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2655 
2658  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2659 
2662  ImportOptionsKit & UnsetIFCFaceOptimization();
2663 
2666  ImportOptionsKit & UnsetIFCEdges();
2667 
2670  ImportOptionsKit & UnsetIFCMetadata();
2671 
2674  ImportOptionsKit & UnsetPDF3DStreamIndex();
2675 
2678  ImportOptionsKit & UnsetJTTessellationLevel();
2679 
2682  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2683 
2686  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2687 
2690  ImportOptionsKit & UnsetPRCReadHelper();
2691 
2694  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2695 
2698  ImportOptionsKit & UnsetRevitPhysicalProperties();
2699 
2702  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2703 
2706  ImportOptionsKit & UnsetLocation();
2707 
2710  ImportOptionsKit & UnsetMode();
2711 
2714  ImportOptionsKit & UnsetIncrementalComponentPaths();
2715 
2718  ImportOptionsKit & UnsetNURBSConversion();
2719 
2722  ImportOptionsKit & UnsetGeometryDefaultColor();
2723 
2726  ImportOptionsKit & UnsetEverything();
2727 
2731  bool ShowBRepMode(BRepMode & out_mode) const;
2732 
2736  bool ShowSolids(bool & out_state) const;
2737 
2741  bool ShowSurfaces(bool & out_state) const;
2742 
2746  bool ShowWireframes(bool & out_state) const;
2747 
2751  bool ShowPMI(bool & out_state) const;
2752 
2756  bool ShowAttributes(bool & out_state) const;
2757 
2761  bool ShowHiddenObjects(bool & out_state) const;
2762 
2766  bool ShowConstructionAndReferences(bool & out_state) const;
2767 
2771  bool ShowActiveFilter(bool & out_state) const;
2772 
2776  bool ShowDrawings(bool & out_state) const;
2777 
2781  bool ShowFeatureTrees(bool & out_state) const;
2782 
2786  bool ShowSewingTolerance(double & out_tolerance) const;
2787 
2791  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2792 
2796  bool ShowDefaultUnits(Units & out_units) const;
2797 
2801  bool ShowMultiProcessCount(unsigned int & out_count) const;
2802 
2807  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2808 
2812  bool ShowPMIPrecision(size_t & out_precision) const;
2813 
2817  bool ShowPMIDefaultUnits(Units & out_units) const;
2818 
2823  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2824 
2832  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2833 
2840  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2841 
2845  bool ShowTessellationCleanup(bool & out_cleanup) const;
2846 
2850  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2851 
2855  bool ShowRemovedViews(bool & out_read_removed_views) const;
2856 
2860  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2861 
2865  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2866 
2870  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2871 
2875  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2876 
2882  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2883 
2887  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2888 
2893  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2894 
2898  bool ShowConfiguration(UTF8Array & out_configuration) const;
2899 
2903  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2904 
2908  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2909 
2914  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2915 
2919  bool ShowCatiaV5MaterialRendering(bool & out_active) const;
2920 
2925  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2926 
2930  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2931 
2935  bool ShowProECodePageName(UTF8 & out_name) const;
2936 
2940  bool ShowProEDimensionTolerance(bool & out_state) const;
2941 
2945  bool ShowProESubpartPMI(bool & out_state) const;
2946 
2950  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2951 
2955  bool ShowProEDatum(bool & out_state) const;
2956 
2960  bool ShowProEHomeView(bool & out_state) const;
2961 
2965  bool ShowProEExplodedViews(bool & out_state) const;
2966 
2970  bool ShowProEMissingBoolean(bool & out_state) const;
2971 
2975  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2976 
2980  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2981 
2985  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2986 
2990  bool ShowProESkeletons(bool & out_state) const;
2991 
2995  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2996 
3000  bool ShowSTEPFirstColorPreference(bool & out_state) const;
3001 
3005  bool ShowSTEPCodePageName(UTF8 & out_name) const;
3006 
3010  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
3011 
3015  bool ShowSTEPOrientationHealing(bool & out_state) const;
3016 
3020  bool ShowSTEPValidationProperties(bool & out_state) const;
3021 
3025  bool ShowIFCCodePageName(UTF8 & out_name) const;
3026 
3030  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
3031 
3035  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
3036 
3040  bool ShowIFCFaceOptimization(bool & out_state) const;
3041 
3045  bool ShowIFCEdges(bool & out_state) const;
3046 
3050  bool ShowIFCMetadata(bool & out_state) const;
3051 
3055  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3056 
3060  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3061 
3065  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3066 
3070  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3071 
3075  bool ShowPRCReadHelper(bool & out_use_helper) const;
3076 
3080  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3081 
3085  bool ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;
3086 
3090  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3091 
3096  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3097 
3101  bool ShowMode(ImportMode & out_mode) const;
3102 
3106  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3107 
3111  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3112 
3116  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3117  };
3118 
3120  class EXCHANGE_API Translation
3121  {
3122  public:
3125  enum class Healing
3126  {
3127  Off,
3128  On,
3129  OnlyIfNotParasolid,
3130  };
3131 
3134  enum class AccurateEdges
3135  {
3136  Off,
3137  On,
3138  OnlyIfNotParasolid,
3139  };
3140 
3143  enum class Simplification
3144  {
3145  Off,
3146  On,
3147  OnlyIfNotParasolid,
3148  };
3149 
3152  enum class Merging
3153  {
3154  Off,
3155  On,
3156  OnlyIfNotParasolid,
3157  };
3158 
3159  private:
3161  Translation();
3162  };
3163 
3165  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3166  {
3167  public:
3170 
3174 
3179 
3183  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3184 
3185  virtual ~TranslationOptionsKit();
3186 
3187  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3188  HPS::Type ObjectType() const { return staticType; }
3189 
3193  static TranslationOptionsKit GetDefault();
3194 
3197  void Set(TranslationOptionsKit const & in_kit);
3198 
3201  void Show(TranslationOptionsKit & out_kit) const;
3202 
3206  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3207 
3210  bool Empty() const;
3211 
3215  bool Equals(TranslationOptionsKit const & in_kit) const;
3216 
3220  bool operator==(TranslationOptionsKit const & in_kit) const;
3221 
3225  bool operator!=(TranslationOptionsKit const & in_kit) const;
3226 
3232  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3233 
3239  TranslationOptionsKit & SetTessellation(bool in_state);
3240 
3246  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3247 
3251  TranslationOptionsKit & SetApplication(char const * in_name);
3252 
3256  TranslationOptionsKit & SetVersion(char const * in_version);
3257 
3263  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3264 
3268  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3269 
3273  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3274 
3278  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3279 
3283  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3284 
3289  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3290 
3294  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3295 
3298  TranslationOptionsKit & UnsetSolidsAsFaces();
3299 
3302  TranslationOptionsKit & UnsetTessellation();
3303 
3306  TranslationOptionsKit & UnsetHiddenObjects();
3307 
3310  TranslationOptionsKit & UnsetApplication();
3311 
3314  TranslationOptionsKit & UnsetVersion();
3315 
3318  TranslationOptionsKit & UnsetHealing();
3319 
3322  TranslationOptionsKit & UnsetAccurateEdges();
3323 
3326  TranslationOptionsKit & UnsetSimplification();
3327 
3330  TranslationOptionsKit & UnsetEntityMerging();
3331 
3334  TranslationOptionsKit & UnsetSewing();
3335 
3338  TranslationOptionsKit & UnsetDisjointFaces();
3339 
3342  TranslationOptionsKit& UnsetExplodeMultiBodies();
3343 
3346  TranslationOptionsKit & UnsetEverything();
3347 
3348 
3352  bool ShowSolidsAsFaces(bool & out_state) const;
3353 
3357  bool ShowTessellation(bool & out_state) const;
3358 
3362  bool ShowHiddenObjects(bool & out_state) const;
3363 
3367  bool ShowApplication(UTF8 & out_name) const;
3368 
3372  bool ShowVersion(UTF8 & out_version) const;
3373 
3377  bool ShowExplodeMultiBodies(bool& out_state) const;
3378 
3382  bool ShowHealing(Translation::Healing & out_healing) const;
3383 
3387  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3388 
3392  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3393 
3397  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3398 
3403  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3404 
3408  bool ShowDisjointFaces(bool & out_state) const;
3409 
3414  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3415 
3418  TranslationOptionsKit & UnsetMultiProcessCount();
3419 
3423  bool ShowMultiProcessCount(unsigned int & out_count) const;
3424  };
3425 
3426 
3427 
3432  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3433  {
3434  public:
3437 
3441 
3446 
3450  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3451 
3452  virtual ~ModelFileImportOptionsKit();
3453 
3454  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3455  HPS::Type ObjectType() const { return staticType; }
3456 
3460  static ModelFileImportOptionsKit GetDefault();
3461 
3464  void Set(ModelFileImportOptionsKit const & in_kit);
3465 
3468  void Show(ModelFileImportOptionsKit & out_kit) const;
3469 
3473  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3474 
3477  bool Empty() const;
3478 
3482  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3483 
3487  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3488 
3492  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3493 
3494 
3495  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3496  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3497  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3498  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3499  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3500  * \return A reference to this ModelFileImportOptionsKit.
3501  */
3502  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3503 
3509  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3510 
3517  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3518 
3530  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);
3531 
3532  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3533  * \warning Setting this option to true will cause future exports to output without tessellation data.
3534  * \param in_cleanup Whether to clean up tessellation data from representation items.
3535  * \return A reference to this ImportOptionsKit.
3536  */
3537  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3538 
3544  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3545 
3551  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3552 
3559  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3560 
3564  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3565 
3578  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3579 
3585  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3586 
3593  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3594 
3598  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3599 
3604  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3605 
3611  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
3612 
3615  ModelFileImportOptionsKit & UnsetTessellationLevel();
3616 
3619  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3620 
3623  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3624 
3627  ModelFileImportOptionsKit & UnsetPMIFlipping();
3628 
3631  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3632 
3635  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3636 
3639  ModelFileImportOptionsKit & UnsetIFCEdges();
3640 
3643  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3644 
3647  ModelFileImportOptionsKit & UnsetLocation();
3648 
3651  ModelFileImportOptionsKit & UnsetSewingTolerance();
3652 
3655  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3656 
3659  ModelFileImportOptionsKit & UnsetNURBSConversion();
3660 
3663  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3664 
3667  ModelFileImportOptionsKit & UnsetHiddenObjects();
3668 
3671  ModelFileImportOptionsKit & UnsetEverything();
3672 
3673 
3681  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3682 
3689  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3690 
3694  bool ShowTessellationCleanup(bool & out_cleanup) const;
3695 
3699  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3700 
3704  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3705 
3709  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3710 
3714  bool ShowIFCEdges(bool & out_state) const;
3715 
3719  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3720 
3725  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3726 
3730  bool ShowSewingTolerance(double & out_tolerance) const;
3731 
3732 
3736  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3737 
3741  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3742 
3746  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3747 
3751  bool ShowHiddenObjects(bool & out_state) const;
3752  };
3753 
3754 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3755 
3756  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3757  {
3758  public:
3761 
3764  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3765 
3769 
3770  virtual ~Export3MFOptionsKit();
3771 
3772  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3773  HPS::Type ObjectType() const { return staticType; }
3774 
3778  static Export3MFOptionsKit GetDefault();
3779 
3782  void Set(Export3MFOptionsKit const & in_kit);
3783 
3786  void Show(Export3MFOptionsKit& out_kit) const;
3787 
3791  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3792 
3796  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3797 
3800  bool Empty() const;
3801 
3805  bool Equals(Export3MFOptionsKit const & in_kit) const;
3806 
3810  bool operator==(Export3MFOptionsKit const & in_kit) const;
3811 
3815  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3816 
3821  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3822 
3828  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3829 
3832  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3833 
3837  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3838 
3843  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3844 
3847  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3848 
3853  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3854 
3858  Export3MFOptionsKit & SetDescription(char const * in_description);
3859 
3862  Export3MFOptionsKit & UnsetDescription();
3863 
3867  bool ShowDescription(HPS::UTF8 & out_state) const;
3868 
3872  Export3MFOptionsKit & SetCopyright(char const * in_state);
3873 
3876  Export3MFOptionsKit & UnsetCopyright();
3877 
3881  bool ShowCopyright(HPS::UTF8 & out_state) const;
3882 
3886  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3887 
3890  Export3MFOptionsKit & UnsetLicenseTerms();
3891 
3895  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3896 
3899  Export3MFOptionsKit & UnsetEverything();
3900  };
3901 
3903  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
3904  {
3905  public:
3908 
3911  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
3912 
3916 
3917  virtual ~ExportFBXOptionsKit();
3918 
3919  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
3920  HPS::Type ObjectType() const { return staticType; }
3921 
3925  static ExportFBXOptionsKit GetDefault();
3926 
3929  void Set(ExportFBXOptionsKit const & in_kit);
3930 
3933  void Show(ExportFBXOptionsKit & out_kit) const;
3934 
3938  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
3939 
3943  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
3944 
3947  bool Empty() const;
3948 
3952  bool Equals(ExportFBXOptionsKit const & in_kit) const;
3953 
3957  bool operator==(ExportFBXOptionsKit const & in_kit) const;
3958 
3962  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
3963 
3964 
3972  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
3973 
3974 
3980  ExportFBXOptionsKit & SetAscii(bool in_state);
3981 
3982 
3985  ExportFBXOptionsKit & UnsetTextureFolder();
3986 
3989  ExportFBXOptionsKit & UnsetAscii();
3990 
3993  ExportFBXOptionsKit & UnsetEverything();
3994 
3995 
3999  bool ShowTextureFolder(UTF8 & out_path) const;
4000 
4004  bool ShowAscii(bool & out_state) const;
4005  };
4006 
4008  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
4009  {
4010  public:
4013 
4017 
4021 
4022  virtual ~ExportACISOptionsKit();
4023 
4024  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
4025  HPS::Type ObjectType() const { return staticType; }
4026 
4030  static ExportACISOptionsKit GetDefault();
4031 
4034  void Set(ExportACISOptionsKit const & in_kit);
4035 
4038  void Show(ExportACISOptionsKit & out_kit) const;
4039 
4043  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
4044 
4048  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
4049 
4052  bool Empty() const;
4053 
4057  bool Equals(ExportACISOptionsKit const & in_kit) const;
4058 
4062  bool operator==(ExportACISOptionsKit const & in_kit) const;
4063 
4067  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4068 
4069 
4075  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4076 
4082  ExportACISOptionsKit & SetBinary(bool in_state);
4083 
4084 
4087  ExportACISOptionsKit & UnsetMillimeterUnits();
4088 
4091  ExportACISOptionsKit & UnsetBinary();
4092 
4095  ExportACISOptionsKit & UnsetEverything();
4096 
4097 
4101  bool ShowMillimeterUnits(bool & out_state) const;
4102 
4106  bool ShowBinary(bool & out_state) const;
4107  };
4108 
4110  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4111  {
4112  public:
4115 
4118  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4119 
4123 
4124  virtual ~ExportJTOptionsKit();
4125 
4126  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4127  HPS::Type ObjectType() const { return staticType; }
4128 
4132  static ExportJTOptionsKit GetDefault();
4133 
4136  void Set(ExportJTOptionsKit const & in_kit);
4137 
4140  void Show(ExportJTOptionsKit & out_kit) const;
4141 
4145  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4146 
4150  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4151 
4154  bool Empty() const;
4155 
4159  bool Equals(ExportJTOptionsKit const & in_kit) const;
4160 
4164  bool operator==(ExportJTOptionsKit const & in_kit) const;
4165 
4169  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4170 
4171 
4177  ExportJTOptionsKit & SetContent(JT::Content in_content);
4178 
4184  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4185 
4191  ExportJTOptionsKit & SetPMI(bool in_state);
4192 
4198  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4199 
4200 
4203  ExportJTOptionsKit & UnsetContent();
4204 
4207  ExportJTOptionsKit & UnsetHiddenObjects();
4208 
4211  ExportJTOptionsKit & UnsetPMI();
4212 
4215  ExportJTOptionsKit & UnsetVersion();
4216 
4219  ExportJTOptionsKit & UnsetEverything();
4220 
4221 
4225  bool ShowContent(JT::Content & out_content) const;
4226 
4230  bool ShowHiddenObjects(bool & out_state) const;
4231 
4235  bool ShowPMI(bool & out_state) const;
4236 
4240  bool ShowVersion(JT::Version & out_version) const;
4241  };
4242 
4244  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4245  {
4246  public:
4249 
4252  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4253 
4257 
4258  virtual ~ExportPRCOptionsKit();
4259 
4260  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4261  HPS::Type ObjectType() const { return staticType; }
4262 
4266  static ExportPRCOptionsKit GetDefault();
4267 
4270  void Set(ExportPRCOptionsKit const & in_kit);
4271 
4274  void Show(ExportPRCOptionsKit & out_kit) const;
4275 
4279  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4280 
4284  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4285 
4288  bool Empty() const;
4289 
4293  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4294 
4298  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4299 
4303  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4304 
4305 
4311  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4312 
4319  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4320 
4326  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4327 
4333  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4334 
4339  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4340 
4346  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4347 
4348 
4351  ExportPRCOptionsKit & UnsetTessellationCompression();
4352 
4355  ExportPRCOptionsKit & UnsetBRepCompression();
4356 
4359  ExportPRCOptionsKit & UnsetBRepRemoval();
4360 
4363  ExportPRCOptionsKit & UnsetAttributeRemoval();
4364 
4367  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4368 
4371  ExportPRCOptionsKit & UnsetEverything();
4372 
4373 
4377  bool ShowTessellationCompression(bool & out_state) const;
4378 
4382  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4383 
4387  bool ShowBRepRemoval(bool & out_state) const;
4388 
4392  bool ShowAttributeRemoval(bool & out_state) const;
4393 
4397  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4398  };
4399 
4401  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4402  {
4403  public:
4406 
4409  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4410 
4414 
4415  virtual ~ExportSTLOptionsKit();
4416 
4417  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4418  HPS::Type ObjectType() const { return staticType; }
4419 
4423  static ExportSTLOptionsKit GetDefault();
4424 
4427  void Set(ExportSTLOptionsKit const & in_kit);
4428 
4431  void Show(ExportSTLOptionsKit & out_kit) const;
4432 
4436  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4437 
4441  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4442 
4445  bool Empty() const;
4446 
4450  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4451 
4455  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4456 
4460  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4461 
4462 
4468  ExportSTLOptionsKit & SetBinary(bool in_state);
4469 
4475  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4476 
4483  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4484 
4490  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4491 
4497  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4498 
4505  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4506 
4516  ExportSTLOptionsKit & SetUnits(Units in_units);
4517 
4518 
4521  ExportSTLOptionsKit & UnsetBinary();
4522 
4525  ExportSTLOptionsKit & UnsetTessellationLevel();
4526 
4529  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4530 
4533  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4534 
4537  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4538 
4541  ExportSTLOptionsKit & UnsetUnits();
4542 
4545  ExportSTLOptionsKit & UnsetEverything();
4546 
4547 
4551  bool ShowBinary(bool & out_state) const;
4552 
4560  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4561 
4565  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4566 
4570  bool ShowCurrentTessellationRetention(bool & out_state) const;
4571 
4575  bool ShowMaximumEdgeLength(double & out_length) const;
4576 
4580  bool ShowUnits(Units & out_units) const;
4581  };
4582 
4584  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4585  {
4586  public:
4589 
4592  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
4593 
4597 
4598  virtual ~ExportOBJOptionsKit();
4599 
4600  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
4601  HPS::Type ObjectType() const { return staticType; }
4602 
4606  static ExportOBJOptionsKit GetDefault();
4607 
4610  void Set(ExportOBJOptionsKit const & in_kit);
4611 
4614  void Show(ExportOBJOptionsKit & out_kit) const;
4615 
4619  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
4620 
4624  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
4625 
4628  bool Empty() const;
4629 
4633  bool Equals(ExportOBJOptionsKit const & in_kit) const;
4634 
4638  bool operator==(ExportOBJOptionsKit const & in_kit) const;
4639 
4643  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
4644 
4649  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
4650 
4654  bool ShowTextureFolder(UTF8 & out_path) const;
4655 
4658  ExportOBJOptionsKit & UnsetTextureFolder();
4659 
4662  ExportOBJOptionsKit & UnsetEverything();
4663  };
4664 
4666  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4667  {
4668  public:
4671 
4674  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4675 
4679 
4680  virtual ~ExportU3DOptionsKit();
4681 
4682  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4683  HPS::Type ObjectType() const { return staticType; }
4684 
4688  static ExportU3DOptionsKit GetDefault();
4689 
4692  void Set(ExportU3DOptionsKit const & in_kit);
4693 
4696  void Show(ExportU3DOptionsKit & out_kit) const;
4697 
4701  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4702 
4706  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4707 
4710  bool Empty() const;
4711 
4715  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4716 
4720  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4721 
4725  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4726 
4727 
4733  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4734 
4739  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4740 
4741 
4744  ExportU3DOptionsKit & UnsetVersion();
4745 
4748  ExportU3DOptionsKit & UnsetCompression();
4749 
4752  ExportU3DOptionsKit & UnsetEverything();
4753 
4754 
4758  bool ShowVersion(U3D::Version & out_version) const;
4759 
4763  bool ShowCompression(unsigned char & out_level) const;
4764  };
4765 
4767  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4768  {
4769  public:
4772 
4775  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4776 
4780 
4781  virtual ~ExportXMLOptionsKit();
4782 
4783  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4784  HPS::Type ObjectType() const { return staticType; }
4785 
4789  static ExportXMLOptionsKit GetDefault();
4790 
4793  void Set(ExportXMLOptionsKit const & in_kit);
4794 
4797  void Show(ExportXMLOptionsKit & out_kit) const;
4798 
4802  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4803 
4807  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4808 
4811  bool Empty() const;
4812 
4816  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4817 
4821  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4822 
4826  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4827 
4828 
4834  ExportXMLOptionsKit & SetMetadata(bool in_state);
4835 
4841  ExportXMLOptionsKit & SetTransformations(bool in_state);
4842 
4848  ExportXMLOptionsKit & SetMaterials(bool in_state);
4849 
4850 
4853  ExportXMLOptionsKit & UnsetMetadata();
4854 
4857  ExportXMLOptionsKit & UnsetTransformations();
4858 
4861  ExportXMLOptionsKit & UnsetMaterials();
4862 
4865  ExportXMLOptionsKit & UnsetEverything();
4866 
4867 
4871  bool ShowMetadata(bool & out_state) const;
4872 
4876  bool ShowTransformations(bool & out_state) const;
4877 
4881  bool ShowMaterials(bool & out_state) const;
4882  };
4883 #endif
4884 
4885 #if !defined(TARGET_OS_ANDROID)
4886 
4887  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4888  {
4889  public:
4892 
4896 
4900 
4901  virtual ~ExportIGESOptionsKit();
4902 
4903  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4904  HPS::Type ObjectType() const { return staticType; }
4905 
4909  static ExportIGESOptionsKit GetDefault();
4910 
4913  void Set(ExportIGESOptionsKit const & in_kit);
4914 
4917  void Show(ExportIGESOptionsKit & out_kit) const;
4918 
4922  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4923 
4927  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4928 
4931  bool Empty() const;
4932 
4936  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4937 
4941  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4942 
4946  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4947 
4948 
4954  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4955 
4961  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4962 
4968  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4969 
4975  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4976 
4982  ExportIGESOptionsKit & SetTessellation(bool in_state);
4983 
4987  ExportIGESOptionsKit & SetApplication(char const * in_name);
4988 
4992  ExportIGESOptionsKit & SetVersion(char const * in_version);
4993 
4994 
4997  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4998 
5001  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
5002 
5005  ExportIGESOptionsKit & UnsetSolidsAsFaces();
5006 
5009  ExportIGESOptionsKit & UnsetHiddenObjects();
5010 
5013  ExportIGESOptionsKit & UnsetTessellation();
5014 
5017  ExportIGESOptionsKit & UnsetApplication();
5018 
5021  ExportIGESOptionsKit & UnsetVersion();
5022 
5025  ExportIGESOptionsKit & UnsetEverything();
5026 
5027 
5031  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5032 
5036  bool ShowFacetedAsWireframe(bool & out_state) const;
5037 
5041  bool ShowSolidsAsFaces(bool & out_state) const;
5042 
5046  bool ShowHiddenObjects(bool & out_state) const;
5047 
5051  bool ShowTessellation(bool & out_state) const;
5052 
5056  bool ShowApplication(UTF8 & out_name) const;
5057 
5061  bool ShowVersion(UTF8 & out_version) const;
5062  };
5063 
5065  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5066  {
5067  public:
5070 
5074 
5078 
5079  virtual ~ExportParasolidOptionsKit();
5080 
5081  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5082  HPS::Type ObjectType() const { return staticType; }
5083 
5087  static ExportParasolidOptionsKit GetDefault();
5088 
5091  void Set(ExportParasolidOptionsKit const & in_kit);
5092 
5095  void Show(ExportParasolidOptionsKit & out_kit) const;
5096 
5100  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5101 
5105  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5106 
5109  bool Empty() const;
5110 
5114  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5115 
5119  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5120 
5124  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5125 
5126 
5132  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5133 
5139  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5140 
5146  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5147 
5151  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5152 
5156  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5157 
5163  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5164 
5167  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5168 
5171  ExportParasolidOptionsKit & UnsetTessellation();
5172 
5175  ExportParasolidOptionsKit & UnsetHiddenObjects();
5176 
5179  ExportParasolidOptionsKit & UnsetApplication();
5180 
5183  ExportParasolidOptionsKit & UnsetVersion();
5184 
5187  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5188 
5191  ExportParasolidOptionsKit & UnsetEverything();
5192 
5193 
5197  bool ShowSolidsAsFaces(bool & out_state) const;
5198 
5202  bool ShowTessellation(bool & out_state) const;
5203 
5207  bool ShowHiddenObjects(bool & out_state) const;
5208 
5212  bool ShowApplication(UTF8 & out_name) const;
5213 
5217  bool ShowVersion(UTF8 & out_version) const;
5218 
5222  bool ShowExplodeMultiBodies(bool& out_state) const;
5223  };
5224 
5226  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5227  {
5228  public:
5231 
5235 
5239 
5240  virtual ~ExportSTEPOptionsKit();
5241 
5242  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5243  HPS::Type ObjectType() const { return staticType; }
5244 
5248  static ExportSTEPOptionsKit GetDefault();
5249 
5252  void Set(ExportSTEPOptionsKit const & in_kit);
5253 
5256  void Show(ExportSTEPOptionsKit & out_kit) const;
5257 
5261  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5262 
5266  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5267 
5270  bool Empty() const;
5271 
5275  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5276 
5280  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5281 
5285  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5286 
5287 
5293  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5294 
5300  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5301 
5307  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5308 
5314  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5315 
5319  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5320 
5324  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5325 
5329  ExportSTEPOptionsKit & SetPMI(bool in_state);
5330 
5334  ExportSTEPOptionsKit & SetCurves(bool in_state);
5335 
5339  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5340 
5344  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5345 
5349  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5350 
5353  ExportSTEPOptionsKit & UnsetFormat();
5354 
5357  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5358 
5361  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5362 
5365  ExportSTEPOptionsKit & UnsetNameShortening();
5366 
5369  ExportSTEPOptionsKit & UnsetApplication();
5370 
5373  ExportSTEPOptionsKit & UnsetVersion();
5374 
5377  ExportSTEPOptionsKit & UnsetPMI();
5378 
5381  ExportSTEPOptionsKit & UnsetCurves();
5382 
5385  ExportSTEPOptionsKit & UnsetAttributes();
5386 
5389  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5390 
5393  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5394 
5397  ExportSTEPOptionsKit & UnsetEverything();
5398 
5399 
5403  bool ShowFormat(STEP::Format & out_format) const;
5404 
5408  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5409 
5413  bool ShowFacetedAsWireframe(bool & out_state) const;
5414 
5418  bool ShowNameShortening(bool & out_state) const;
5419 
5423  bool ShowApplication(UTF8 & out_name) const;
5424 
5428  bool ShowVersion(UTF8 & out_version) const;
5429 
5433  bool ShowPMI(bool & out_state) const;
5434 
5438  bool ShowCurves(bool & out_state) const;
5439 
5443  bool ShowAttributes(bool & out_state) const;
5444 
5448  bool ShowPMIWithSemantic(bool & out_state) const;
5449 
5453  bool ShowPMIAsTessellated(bool & out_state) const;
5454  };
5455 #endif
5456 
5458  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5459  {
5460  public:
5463 
5467 
5471 
5472  virtual ~TessellationOptionsKit();
5473 
5474  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5475  HPS::Type ObjectType() const { return staticType; }
5476 
5480  static TessellationOptionsKit GetDefault();
5481 
5484  void Set(TessellationOptionsKit const & in_kit);
5485 
5488  void Show(TessellationOptionsKit & out_kit) const;
5489 
5493  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5494 
5498  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5499 
5502  bool Empty() const;
5503 
5507  bool Equals(TessellationOptionsKit const & in_kit) const;
5508 
5512  bool operator==(TessellationOptionsKit const & in_kit) const;
5513 
5517  bool operator!=(TessellationOptionsKit const & in_kit) const;
5518 
5519 
5523  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5524 
5531  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5532 
5542  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);
5543 
5547  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5548 
5552  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5553 
5554 
5557  TessellationOptionsKit & UnsetLevel();
5558 
5561  TessellationOptionsKit & UnsetAccuracy();
5562 
5565  TessellationOptionsKit & UnsetUVPointPreservation();
5566 
5569  TessellationOptionsKit & UnsetMaximumEdgeLength();
5570 
5573  TessellationOptionsKit & UnsetEverything();
5574 
5575 
5583  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5584 
5591  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5592 
5596  bool ShowUVPointPreservation(bool & out_state) const;
5597 
5601  bool ShowMaximumEdgeLength(double & out_length) const;
5602  };
5603 
5609  class EXCHANGE_API CommonMeasurementOperator : public Operator
5610  {
5611  public:
5612  enum class Tags
5613  {
5614  Name = 0,
5615  MeasurementType,
5616  Radius,
5617  Inverted,
5618  VectorX,
5619  VectorY,
5620  VectorZ,
5621  };
5622 
5624 
5625  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5626 
5628  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5629 
5630  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5631  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5632 
5633  Exchange::CADModel GetCADModel() const;
5634  void SetCADModel(Exchange::CADModel const & in_cad_model);
5635 
5637  size_t GetPrecision() const;
5638 
5641  void SetPrecision(size_t in_precision);
5642 
5644  MaterialMappingKit GetMaterial() const;
5645 
5648  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5649 
5651  TextAttributeKit GetTextAttributes() const;
5652 
5655  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5656 
5658  SegmentKey GetMeasurementSegment() const;
5659 
5661  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5662 
5663  /* Deletes all measurements */
5664  void DeleteMeasurements();
5665 
5666  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5667  {
5668  public:
5671  {
5672  channel = GetClassID();
5673  consumable = false;
5674  }
5675 
5676  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5677  {
5678  channel = GetClassID();
5679  consumable = false;
5680  measurement_key = in_measurement_key;
5681  view = in_view;
5682  }
5683 
5686  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5687  {
5688  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5689  {
5690  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5691  measurement_key = that.measurement_key;
5692  view = that.view;
5693  }
5694  else
5695  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5696  }
5697 
5699 
5702  Event * Clone() const
5703  {
5704  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5705  return new_event;
5706  }
5707 
5708  Key measurement_key;
5709  View view;
5710  };
5711 
5712  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5713  {
5714  public:
5717  {
5718  channel = GetClassID();
5719  consumable = false;
5720  }
5721 
5722  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5723  {
5724  channel = GetClassID();
5725  consumable = false;
5726  measurement_name = in_measurement_name;
5727  view = in_view;
5728  }
5729 
5732  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5733  {
5734  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5735  {
5736  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5737  measurement_name = that.measurement_name;
5738  view = that.view;
5739  }
5740  else
5741  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5742  }
5743 
5745 
5748  Event * Clone() const
5749  {
5750  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5751  return new_event;
5752  }
5753 
5754  UTF8 measurement_name;
5755  View view;
5756  };
5757 
5758  protected:
5759  Exchange::CADModel cad_model;
5760  size_t measurement_precision;
5761  UTF8 units;
5762  MaterialMappingKit materials;
5763  TextAttributeKit text_attributes;
5764  SegmentKey measurement_segment;
5765  GlyphDefinition left_arrow;
5766  GlyphDefinition right_arrow;
5767  SelectionOptionsKit selection_options;
5768  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5769  Vector camera_direction;
5770  PortfolioKey portfolio;
5771  SegmentKey style_segment;
5772  HighlightOptionsKit highlight_options;
5773 
5774  static size_t length_measurement_index;
5775  static size_t radius_measurement_index;
5776  static size_t distance_measurement_index;
5777  static size_t angle_measurement_index;
5778 
5779  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5780  void GetUnits();
5781  void SetGlyphColor();
5782  void GetCameraDirection();
5783  void SetupConstructionSegment();
5784  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5785  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5786  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5787  float GetModelScale(Exchange::Component const & component);
5788  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5789  };
5790 
5844  {
5845  public:
5846  enum class MeasurementType
5847  {
5848  PointToPoint,
5849  EdgeAndRadius,
5850  FeatureToFeature,
5851  FaceAngle,
5852  };
5853 
5855 
5856  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5857 
5859  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5860 
5861  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5862  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5863 
5868  virtual bool OnMouseDown(MouseState const & in_state) override;
5869 
5873  virtual bool OnMouseUp(MouseState const & in_state) override;
5874 
5880  virtual bool OnMouseMove(MouseState const & in_state) override;
5881 
5886  virtual bool OnTouchDown(TouchState const & in_state) override;
5887 
5891  virtual bool OnTouchUp(TouchState const & in_state) override;
5892 
5898  virtual bool OnTouchMove(TouchState const & in_state) override;
5899 
5903  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5904 
5907  void SetMeasurementType(MeasurementType in_measurement_type);
5908 
5911  MeasurementType GetMeasurementType();
5912 
5915  void SetMouseOverHighlighting(bool in_highlighting);
5916 
5920  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5921 
5924  bool GetMouseOverHighlighting();
5925 
5928  HighlightOptionsKit GetHighlightOptions();
5929 
5932  bool IsMeasurementActive();
5933 
5935  void DeleteLastMeasurement();
5936 
5937  private:
5938  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5939  {
5940  Circle,
5941  Line,
5942  Generic,
5943  };
5944 
5945  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5946  {
5947  public:
5948  Surface();
5949 
5950  enum class SurfaceType
5951  {
5952  Plane,
5953  ConeOrCylinder,
5954  Unsupported,
5955  };
5956 
5957  SurfaceType surface_type; //the type of surface being measured
5958  Point center; //the center point of the surface
5959  Vector normal; //the center line of surfaces of type Cylinder or Cone
5960  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5961  ComponentPath path; //the ComponentPath to this surface
5962  };
5963 
5964  //bookkeeping
5965  MeasurementType measurement_type; //the type of measurement to be inserted
5966  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5967  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5968  TouchID current_touch_id; //the ID of the touch being processed
5969  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5970  bool operator_active; //whether a measurement is in progress
5971  bool end_measurement; //whether we should end the current measurement
5972  CanvasArray canvases; //canvases related to the view where this operator is attached
5973 
5974  //measurement anchors
5975  size_t anchors; //valid for point-to-point and face-angle measurements
5976  bool anchors_in_place; //true if all the anchors have been placed
5977  Point first_click_position; //position of the first anchor
5978  Point second_click_position; //position of the second anchor
5979 
5980  //geometry for linear measurements
5981  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5982  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5983  LineKey distance_line; //a line representing the distance measured
5984  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5985  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5986  Point distance_point_one; //intersection of leader_line_one and distance_line
5987  Point distance_point_two; //intersection of leader_line_two and distance_line
5988  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5989  TextKey text; //text representing the measurement and units
5990  UTF8 text_string; //the contents of the text
5991  Vector measurement_direction; //the direction of the measurement
5992  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5993  Vector explicit_direction; //used if use_explicit_direction is true
5994 
5995  //geometry for radius measurement
5996  MarkerKey center_marker; //marker representing the center of the circle
5997  Point circle_center; //circle center
5998  float radius; //circle radius
5999 
6000  //edge specific data
6001  LineKey edge_line; //the edge being measured
6002  double edge_length; //length of the measured edge
6003  EdgeType edge_type; //the type of edge being measured
6004 
6005  //feature-to-feature specific data
6006  Surface surface_one; //data related to first selected surface
6007  Surface surface_two; //data related to second selected surface
6008  Plane measurement_plane; //the measurement plane
6009  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
6010 
6011  //angle specific data
6012  Vector leader_line_one_direction; //the direction of the first leader line
6013  Vector leader_line_two_direction; //the direction of the second leader line
6014  Vector first_face_normal; //the normal of the first selected face
6015  Vector second_face_normal; //the normal of the second selected face
6016  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'
6017  CircularArcKey measurement_arc; //an arc representing the measured angle
6018  LineKey line_to_leader_line; //line extending from one anchor to a leader line
6019  Vector mid_point_direction;
6020 
6021  //selection kits
6022  SelectionOptionsKit point_to_point_selection;
6023  SelectionOptionsKit edge_radius_selection;
6024  SelectionOptionsKit feature_to_feature_selection;
6025  SelectionOptionsKit angle_selection;
6026 
6027  //highlighting
6028  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
6029  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
6030  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
6031  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
6032  KeyPath highlighted_path; //highlighted_path
6033  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
6034  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
6035 
6036  //input handling
6037  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
6038  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
6039  bool InputUp(WindowKey & in_window);
6040  void ResetMeasurement();
6041 
6042  //inserting measurements
6043  void InsertPointToPointMeasurement(Point const & in_world_point);
6044  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
6045  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
6046  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
6047  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
6048  void InvertMeasuredAngle(WindowKey & in_window);
6049  void AdjustLineToCursor(Point const & cursor_position);
6050 
6051  //saving measurements
6052  void TagMeasurement();
6053  void TagPointToPointMeasurement();
6054  void TagEdgeMeasurement();
6055  void TagRadiusMeasurement();
6056  void TagGenericEdgeMeasurement();
6057  void TagFeatureToFeatureMeasurement();
6058  void TagAngleMeasurement();
6059 
6060  //restoring measurements
6061  void RestoreMeasurement(SegmentKey const & measurement_segment);
6062  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6063  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6064  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6065  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6066  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6067  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6068 
6069  //topology functions
6070  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6071  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6072  void PlaneToCenterLineDistance();
6073  void PlaneToPlaneDistance();
6074  void LineToLineDistance();
6075  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);
6076  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6077  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6078  bool IsPlane(Exchange::Component const & face_component);
6079  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6080  };
6081 
6082 private:
6084  Exchange();
6085 };
6086 
6087 }
6088 
6089 #endif
Definition: hps.h:6312
Definition: hps.h:85
Definition: sprk_exchange.h:4244
Level
Definition: sprk_exchange.h:916
ConstructionEntities
Definition: sprk_exchange.h:1079
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1030
Definition: sprk.h:273
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5243
Definition: sprk_exchange.h:1213
Definition: sprk_exchange.h:5609
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4601
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4904
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5916
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:67
Simplification
Definition: sprk_exchange.h:3143
Definition: sprk.h:106
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5628
Definition: sprk_exchange.h:656
Version
Definition: sprk_exchange.h:1100
Definition: sprk_exchange.h:3432
Definition: sprk_exchange.h:926
intptr_t GetChannel() const
Definition: hps.h:6429
Definition: sprk_exchange.h:757
SurfaceType
Definition: sprk_exchange.h:848
Definition: hps.h:1765
Format
Definition: sprk_exchange.h:1017
Definition: sprk_exchange.h:4767
Definition: sprk.h:242
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5475
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6778
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6754
Definition: hps.h:48936
Format
Definition: sprk_exchange.h:1218
Definition: hps.h:7820
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6748
Type
Definition: sprk_exchange.h:907
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3773
Definition: hps.h:16523
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1167
Definition: sprk_exchange.h:504
Definition: sprk_exchange.h:595
Definition: sprk_exchange.h:334
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1502
HPS::Type ObjectType() const
Definition: sprk_exchange.h:531
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4784
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4683
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3920
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
HPS::Type ObjectType() const
Definition: sprk_exchange.h:786
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5686
Definition: sprk_exchange.h:1479
Definition: sprk_exchange.h:274
HPS::Type ObjectType() const
Definition: sprk_exchange.h:624
Definition: sprk_exchange.h:4110
Merging
Definition: sprk_exchange.h:3152
Definition: sprk_exchange.h:1112
Field
Definition: sprk_exchange.h:1007
Definition: sprk_exchange.h:4584
Definition: hps.h:48834
Definition: hps.h:42200
Definition: sprk_exchange.h:4008
Definition: sprk_exchange.h:3165
Event * Clone() const
Definition: sprk_exchange.h:5748
Limit
Definition: sprk_exchange.h:931
Definition: hps.h:4581
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3455
TessellationLevel
Definition: sprk_exchange.h:980
Definition: sprk_exchange.h:902
Definition: sprk_exchange.h:4401
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:1002
Definition: sprk_exchange.h:3903
Definition: hps.h:4520
Definition: hps.h:7191
Definition: hps.h:48305
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4025
Definition: sprk_exchange.h:455
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:44213
Definition: hps.h:48721
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:895
Definition: sprk_exchange.h:4666
Definition: sprk_exchange.h:966
Definition: hps.h:15910
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6734
Definition: sprk_exchange.h:1095
SessionColor
Definition: sprk_exchange.h:1054
Definition: sprk.h:1778
Definition: hps.h:49043
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:45420
Definition: hps.h:47812
CurveType
Definition: sprk_exchange.h:871
Definition: sprk_exchange.h:549
Definition: hps.h:6396
Definition: hps.h:14158
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6746
Definition: sprk_exchange.h:5843
Definition: sprk.h:484
BRepCompression
Definition: sprk_exchange.h:1035
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5082
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:821
Definition: sprk.h:2148
ComponentType
Definition: sprk.h:1784
Accuracy
Definition: sprk_exchange.h:948
Definition: sprk_exchange.h:3756
Definition: sprk_exchange.h:4887
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5732
Definition: sprk.h:2854
FamilyTable
Definition: sprk_exchange.h:1067
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4418
Content
Definition: sprk_exchange.h:971
Definition: sprk_exchange.h:1704
Definition: sprk.h:2954
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4127
static MouseButtons ButtonLeft()
Definition: hps.h:48423
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5859
Event * Clone() const
Definition: sprk_exchange.h:5702
Definition: hps.h:7738
HPS::Type ObjectType() const
Definition: sprk_exchange.h:685
Definition: sprk_exchange.h:1049
AccurateEdges
Definition: sprk_exchange.h:3134
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
Definition: hps.h:9451
HPS::Type ObjectType() const
Definition: sprk_exchange.h:739
Definition: sprk_exchange.h:710
Definition: hps.h:24774
Healing
Definition: sprk_exchange.h:3125
Definition: sprk.h:3041
Definition: hps.h:31207
PhysicalProperties
Definition: sprk_exchange.h:1115
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
ImportMode
Definition: sprk_exchange.h:836
Definition: sprk_exchange.h:1129
Definition: hps.h:514
Definition: sprk.h:1107
Definition: sprk_exchange.h:3120
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:5065
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1727
Definition: sprk_exchange.h:203
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3188
Definition: hps.h:41696
Version
Definition: sprk_exchange.h:989
Definition: sprk_exchange.h:5458
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4261
Definition: hps.h:42831
Definition: sprk_exchange.h:5226