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;
55  class ReloadNotifier;
56 
57  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
58  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
59  typedef HPS::IntArray ParasolidEntityArray;
60 
63  enum class Units
64  {
65  Unknown,
66  Point,
67  Inch,
68  Millimeter,
69  Centimeter,
70  Pica,
71  Foot,
72  Yard,
73  Meter,
74  Kilometer,
75  Mile
76  };
77 
80  enum class UnloadMode
81  {
84  ExchangeAndVisualization,
85 
90  ExchangeOnly,
91  };
92 
95  enum class LoadStatus
96  {
98  Unknown,
100  Loaded,
102  VisualizationOnly,
104  PartiallyLoaded,
106  NotLoaded
107  };
108 
111  class EXCHANGE_API Component : public HPS::Component
112  {
113  public:
115  Component();
116 
120  Component(HPS::Component const & in_that);
121 
124  Component(Exchange::Component const & in_that);
125 
128  Component(Exchange::Component && in_that);
129 
130  virtual ~Component();
131 
132  HPS::Type ObjectType() const { return HPS::Type::ExchangeComponent; }
133 
134 #if !defined(_MSC_VER) || _MSC_VER >= 1900
135  Component & operator=(Component const & in_that) = default;
136 #endif
137 
141  Component & operator=(Exchange::Component && in_that);
142 
143 
146  A3DEntity * GetExchangeEntity() const;
147 
148 
154  void Tessellate(TessellationOptionsKit const & in_options);
155 
162  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
163 
170  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
171  };
172 
173  class EXCHANGE_API ProductOccurrence : public Exchange::Component
174  {
175  public:
178 
182  ProductOccurrence(HPS::Component const & in_that);
183 
187  ProductOccurrence(Component const & in_that);
188 
191  ProductOccurrence(ProductOccurrence const & in_sheet);
192 
197 
201  ProductOccurrence & operator=(ProductOccurrence && in_that);
202 
203  virtual ~ProductOccurrence();
204 
205  HPS::Type ObjectType() const { return HPS::Type::ExchangeProductOccurrence; }
206 
210  bool Equals(ProductOccurrence const & in_kit) const;
211 
215  bool operator==(ProductOccurrence const & in_kit) const;
216 
220  bool operator!=(ProductOccurrence const & in_kit) const;
221 
227  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
228 
234  LoadStatus GetLoadStatus() const;
235  };
236 
238  class EXCHANGE_API Sheet : public Exchange::Component
239  {
240  public:
242  Sheet();
243 
247  Sheet(HPS::Component const & in_that);
248 
252  Sheet(Component const & in_that);
253 
256  Sheet(Sheet const & in_sheet);
257 
261  Sheet(Sheet && in_that);
262 
266  Sheet & operator=(Sheet && in_that);
267 
268  virtual ~Sheet();
269 
270  HPS::Type ObjectType() const { return HPS::Type::ExchangeSheet; }
271 
275  bool Equals(Sheet const & in_kit) const;
276 
277 #if !defined(_MSC_VER) || _MSC_VER >= 1900
278  Sheet & operator=(Sheet const & in_that) = default;
279 #endif
280 
284  bool operator==(Sheet const & in_kit) const;
285 
289  bool operator!=(Sheet const & in_kit) const;
290 
291  /* Activates this sheet */
292  HPS::View Activate();
293  };
294 
297  class EXCHANGE_API CADModel : public HPS::CADModel
298  {
299  public:
301  CADModel();
302 
306  CADModel(Component const & in_that);
307 
311  CADModel(HPS::CADModel const & in_that);
312 
315  CADModel(Exchange::CADModel const & in_that);
316 
319  CADModel(Exchange::CADModel && in_that);
320 
321  virtual ~CADModel();
322 
323  HPS::Type ObjectType() const { return HPS::Type::ExchangeCADModel; }
324 
325 #if !defined(_MSC_VER) || _MSC_VER >= 1900
326  CADModel & operator=(Exchange::CADModel const & in_that) = default;
327 #endif
328 
332  CADModel & operator=(Exchange::CADModel && in_that);
333 
334 
337  A3DEntity * GetExchangeEntity() const;
338 
342  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
343 
349  bool GetEntityOwnership() const;
350 
351 
355  UTF8Array GetCurrentConfiguration() const;
356 
360  ConfigurationArray GetConfigurations() const;
361 
362  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
363  * \return The list of sheets for this CADModel */
364  SheetArray GetSheets() const;
365 
371  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
372 
377  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
378 
384  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
385 
391  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
392 
397  void Tessellate(TessellationOptionsKit const & in_options);
398  };
399 
402  class EXCHANGE_API Capture : public HPS::Capture
403  {
404  public:
406  Capture();
407 
411  Capture(Component const & in_that);
412 
416  Capture(HPS::Capture const & in_that);
417 
420  Capture(Exchange::Capture const & in_that);
421 
424  Capture(Exchange::Capture && in_that);
425 
426  virtual ~Capture();
427 
428  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
429 
430 #if !defined(_MSC_VER) || _MSC_VER >= 1900
431  Capture & operator=(Exchange::Capture const & in_that) = default;
432 #endif
433 
437  Capture & operator=(Exchange::Capture && in_that);
438 
439 
442  A3DEntity * GetExchangeEntity() const;
443  };
444 
447  class EXCHANGE_API Filter : public HPS::Filter
448  {
449  public:
451  Filter();
452 
456  Filter(Component const & in_that);
457 
461  Filter(HPS::Filter const & in_that);
462 
465  Filter(Exchange::Filter const & in_that);
466 
469  Filter(Exchange::Filter && in_that);
470 
471  virtual ~Filter();
472 
473  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
474 
475 #if !defined(_MSC_VER) || _MSC_VER >= 1900
476  Filter & operator=(Exchange::Filter const & in_that) = default;
477 #endif
478 
482  Filter & operator=(Exchange::Filter && in_that);
483 
484 
487  A3DEntity * GetExchangeEntity() const;
488  };
489 
491  class EXCHANGE_API Factory : public Sprocket
492  {
493  public:
498  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
499 
505  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
506 
510  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
511 
518  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
519 
523  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
524 
525  private:
527  Factory();
528  };
529 
531  class EXCHANGE_API ImportNotifier : public IONotifier
532  {
533  public:
535  ImportNotifier();
536 
539  ImportNotifier(ImportNotifier const & in_that);
540 
545  ImportNotifier(IONotifier const & in_that);
546 
550  ImportNotifier(ImportNotifier && in_that);
551 
555  ImportNotifier & operator=(ImportNotifier && in_that);
556 
557  virtual ~ImportNotifier();
558 
559  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
560 
564  ImportNotifier & operator=(ImportNotifier const & in_that);
565 
568  void Assign(ImportNotifier const & in_that);
569 
572  Exchange::CADModel GetCADModel() const;
573 
579  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
580 
583  Time GetImportTime() const;
584 
587  Time GetParseTime() const;
588  };
589 
591  class EXCHANGE_API TranslationNotifier : public IONotifier
592  {
593  public:
596 
599  TranslationNotifier(TranslationNotifier const & in_that);
600 
605  TranslationNotifier(IONotifier const & in_that);
606 
611 
615  TranslationNotifier & operator=(TranslationNotifier && in_that);
616 
617  virtual ~TranslationNotifier();
618 
619  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
620 
624  TranslationNotifier & operator=(TranslationNotifier const & in_that);
625 
628  void Assign(TranslationNotifier const & in_that);
629 
632  Exchange::ParasolidEntityArray GetParasolidParts() const;
633 
636  HPS::Time GetImportTime() const;
637 
640  HPS::Time GetTranslationTime() const;
641  };
642 
644  class EXCHANGE_API ExportNotifier : public IONotifier
645  {
646  public:
648  ExportNotifier();
649 
652  ExportNotifier(ExportNotifier const & in_that);
653 
658  ExportNotifier(IONotifier const & in_that);
659 
663  ExportNotifier(ExportNotifier && in_that);
664 
668  ExportNotifier & operator=(ExportNotifier && in_that);
669 
670  virtual ~ExportNotifier();
671 
672  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
673 
677  ExportNotifier & operator=(ExportNotifier const & in_that);
678 
681  void Assign(ExportNotifier const & in_that);
682 
686  A3DAsmModelFile * GetModelFile() const;
687  };
688 
690  class EXCHANGE_API ReloadNotifier : public IONotifier
691  {
692  public:
694  ReloadNotifier();
695 
698  ReloadNotifier(ReloadNotifier const & in_that);
699 
704  ReloadNotifier(IONotifier const & in_that);
705 
709  ReloadNotifier(ReloadNotifier && in_that);
710 
714  ReloadNotifier & operator=(ReloadNotifier && in_that);
715 
716  virtual ~ReloadNotifier();
717 
718  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
719 
723  ReloadNotifier & operator=(ReloadNotifier const & in_that);
724 
727  void Assign(ReloadNotifier const & in_that);
728  };
729 
730 
731  class ImportOptionsKit;
732  class ModelFileImportOptionsKit;
733  class Export3MFOptionsKit;
734  class ExportACISOptionsKit;
735  class ExportIGESOptionsKit;
736  class ExportJTOptionsKit;
737  class ExportPRCOptionsKit;
738  class ExportSTEPOptionsKit;
739  class ExportSTLOptionsKit;
740  class ExportU3DOptionsKit;
741  class ExportXMLOptionsKit;
742 
743 
746  enum class BRepMode
747  {
750  TessellationOnly,
753  BRepOnly,
756  BRepAndTessellation,
757  };
758 
761  enum class ImportMode
762  {
765  Complete,
768  Incremental,
769  };
770 
773  enum class SurfaceType
774  {
775  Blend01,
776  Blend02,
777  Blend03,
778  Blend04,
779  NURBS,
780  Cone,
781  Cylinder,
782  Offset,
783  Pipe,
784  Plane,
785  Ruled,
786  Sphere,
787  Revolution,
788  Extrusion,
789  FromCurve,
790  Torus,
791  Transform,
792  };
793 
796  enum class CurveType
797  {
798  Blend,
799  NURBS,
800  Circle,
801  Composite,
802  CurveOnSurface,
803  Ellipse,
804  Equation,
805  Helix,
806  Hyperbola,
807  Intersection,
808  Line,
809  Offset,
810  Parabola,
811  Polyline,
812  Transform,
813  };
814 
815  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
816  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
817 
821  {
822  PMIOnly,
823  ModelAndPMI
824  };
825 
827  class EXCHANGE_API Tessellation
828  {
829  public:
832  enum class Type
833  {
834  Standard,
835  Custom
836  };
837 
838 
841  enum class Level
842  {
843  ExtraLow,
844  Low,
845  Medium,
846  High,
847  ExtraHigh,
848  };
849 
851  class EXCHANGE_API Chord
852  {
853  public:
856  enum class Limit
857  {
860  Ratio,
863  Height
864  };
865 
866  private:
868  Chord();
869  };
870 
873  enum class Accuracy
874  {
877  Standard,
880  Accurate
881  };
882 
883  private:
885  Tessellation();
886  };
887 
889  class EXCHANGE_API JT
890  {
891  public:
894  enum class Content
895  {
896  Geometry,
897  Tessellation,
898  GeometryAndTessellation
899  };
900 
903  enum class TessellationLevel
904  {
905  Low,
906  Medium,
907  High,
908  };
909 
910  private:
912  JT();
913  };
914 
916  class EXCHANGE_API STEP
917  {
918  public:
921  enum class Field
922  {
923  ProductName,
924  NextAssemblyUsageOccurrenceID,
925  NextAssemblyUsageOccurrenceName,
926  NextAssemblyUsageOccurrenceDescription
927  };
928 
931  enum class Format
932  {
933  AP203,
934  AP214,
935  AP242,
936  };
937 
938  private:
940  STEP();
941  };
942 
944  class EXCHANGE_API PRC
945  {
946  public:
949  enum class BRepCompression
950  {
951  None,
952  Low,
953  Medium,
954  High
955  };
956 
957  private:
959  PRC();
960  };
961 
963  class EXCHANGE_API ProE
964  {
965  public:
968  enum class SessionColor
969  {
971  LastCreoVersion,
973  ExchangeDefault,
976  UserDefined
977  };
978 
981  enum class FamilyTable
982  {
984  BRepOnly,
986  BRepOrTessellation,
988  BRepOrTessellationOrGeneric
989  };
990 
994  {
996  On,
998  Off,
1000  AsDatum,
1001  };
1002 
1003  private:
1005  ProE();
1006  };
1007 
1009  class EXCHANGE_API U3D
1010  {
1011  public:
1014  enum class Version
1015  {
1016  ECMA1,
1017  ECMA3
1018  };
1019 
1020  private:
1022  U3D();
1023  };
1024 
1026  class EXCHANGE_API Configuration : public HPS::Sprocket
1027  {
1028  public:
1030  Configuration();
1031 
1034  Configuration(char const * in_name);
1035 
1040  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1041 
1045  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1046 
1049  Configuration(Configuration const & in_configuration);
1050 
1054  Configuration(Configuration && in_that);
1055 
1059  Configuration & operator=(Configuration && in_that);
1060 
1061  virtual ~Configuration();
1062 
1063  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
1064 
1065 
1068  void Set(Configuration const & in_kit);
1069 
1072  void Show(Configuration & out_kit) const;
1073 
1077  Configuration & operator=(Configuration const & in_kit);
1078 
1081  bool Empty() const;
1082 
1086  bool Equals(Configuration const & in_kit) const;
1087 
1091  bool operator==(Configuration const & in_kit) const;
1092 
1096  bool operator!=(Configuration const & in_kit) const;
1097 
1098 
1101  HPS::UTF8 GetName() const;
1102 
1105  ConfigurationArray GetSubconfigurations() const;
1106  };
1107 
1109  class EXCHANGE_API File
1110  {
1111  public:
1114  enum class Format
1115  {
1116  Unsupported,
1117  ACIS,
1118  CADDS,
1119  CATIAV4,
1120  CATIAV5,
1121  CGR,
1122  COLLADA,
1123  CreoProE,
1124  IDEAS,
1125  IFC,
1126  IGES,
1127  Inventor,
1128  JT,
1129  KeyholeMarkupLanguage,
1130  LatticeXVL,
1131  OneSpaceDesigner,
1132  Parasolid,
1133  PDF,
1134  PRC,
1135  Rhino,
1136  NXUnigraphics,
1137  SolidEdge,
1138  SolidWorks,
1139  STEP,
1140  StereoLithography,
1141  ThreeDStudioMax,
1142  ThreeDXML,
1143  Universal3D,
1144  VDAFS,
1145  VRML,
1146  WavefrontObject,
1147  };
1148 
1150  static Format GetFormat(char const * in_file_name);
1151 
1155  static ConfigurationArray GetConfigurations(char const * in_file_name);
1156 
1168  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);
1169 
1175  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1176 
1183  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1184 
1191  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1192 
1200  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1201 
1208  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1209 
1210 
1217  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1218 
1223  static void Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1224 
1229  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1230 
1235  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1236 
1241  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1242 
1247  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1248 
1254  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1255 
1261  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1262 
1269  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1270 
1277  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1278 
1282  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1283 
1288  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1289 
1293  static ExportNotifier ExportPRC(KeyPath const & in_source);
1294 
1299  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1300 
1305  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1306 
1311  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1312 
1316  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1317 
1322  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1323 
1324  private:
1326  File();
1327  };
1328 
1330  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1331  {
1332  public:
1335 
1339 
1344 
1348  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1349 
1350  virtual ~NURBSConversionOptionsKit();
1351 
1352  HPS::Type ObjectType() const { return HPS::Type::ExchangeNURBSConversionOptionsKit; }
1353 
1356  void Set(NURBSConversionOptionsKit const & in_kit);
1357 
1360  void Show(NURBSConversionOptionsKit & out_kit) const;
1361 
1365  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1366 
1369  bool Empty() const;
1370 
1374  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1375 
1379  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1380 
1384  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1385 
1389  static NURBSConversionOptionsKit GetDefault();
1390 
1395  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1396 
1401  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1402 
1407  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1408 
1413  NURBSConversionOptionsKit & SetClosedSurfaceSplitting(bool in_state);
1414 
1419  NURBSConversionOptionsKit & SetPeriodicSurfaceSplitting(bool in_state);
1420 
1425  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1426 
1431  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1432 
1438  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1439 
1446  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1447 
1453  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1454 
1461  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1462 
1463 
1466  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1467 
1470  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1471 
1474  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1475 
1478  NURBSConversionOptionsKit & UnsetClosedSurfaceSplitting();
1479 
1482  NURBSConversionOptionsKit & UnsetPeriodicSurfaceSplitting();
1483 
1486  NURBSConversionOptionsKit & UnsetParameterization();
1487 
1490  NURBSConversionOptionsKit & UnsetTolerance();
1491 
1494  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1495 
1498  NURBSConversionOptionsKit & UnsetAllowedCurves();
1499 
1502  NURBSConversionOptionsKit & UnsetEverything();
1503 
1504 
1505 
1509  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1510 
1514  bool Show3DCurvesComputation(bool & out_state) const;
1515 
1520  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1521 
1525  bool ShowClosedSurfaceSplitting(bool & out_state) const;
1526 
1530  bool ShowPeriodicSurfaceSplitting(bool & out_state) const;
1531 
1535  bool ShowParameterization(bool & out_state) const;
1536 
1540  bool ShowTolerance(double & out_tolerance) const;
1541 
1545  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1546 
1550  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1551  };
1552 
1554  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1555  {
1556  public:
1558  ImportOptionsKit();
1559 
1562  ImportOptionsKit(ImportOptionsKit const & in_kit);
1563 
1567  ImportOptionsKit(ImportOptionsKit && in_that);
1568 
1572  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1573 
1574  virtual ~ImportOptionsKit();
1575 
1576  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1577 
1581  static ImportOptionsKit GetDefault();
1582 
1585  void Set(ImportOptionsKit const & in_kit);
1586 
1589  void Show(ImportOptionsKit & out_kit) const;
1590 
1594  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1595 
1598  bool Empty() const;
1599 
1603  bool Equals(ImportOptionsKit const & in_kit) const;
1604 
1608  bool operator==(ImportOptionsKit const & in_kit) const;
1609 
1613  bool operator!=(ImportOptionsKit const & in_kit) const;
1614 
1615 
1621  ImportOptionsKit & SetBRepData(bool in_state);
1622 
1628  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1629 
1635  ImportOptionsKit & SetSolids(bool in_state);
1636 
1642  ImportOptionsKit & SetSurfaces(bool in_state);
1643 
1649  ImportOptionsKit & SetWireframes(bool in_state);
1650 
1656  ImportOptionsKit & SetPMI(bool in_state);
1657 
1664  ImportOptionsKit & SetAttributes(bool in_state);
1665 
1671  ImportOptionsKit & SetHiddenObjects(bool in_state);
1672 
1678  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1679 
1685  ImportOptionsKit & SetActiveFilter(bool in_state);
1686 
1692  ImportOptionsKit & SetDefaultUnits(Units in_units);
1693 
1698  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1699 
1705  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1706 
1713  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1714 
1720  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1721 
1727  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1728 
1736  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1737 
1745  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1746 
1752  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1753 
1759  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1760 
1767  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1768 
1776  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1777 
1783  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1784 
1790  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1791 
1797  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1798 
1803  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1804 
1811  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1812 
1818  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1819 
1828  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1829 
1838  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1839 
1845  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1846 
1851  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1852 
1857  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1858 
1864  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1865 
1870  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1871 
1877  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1878 
1885  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1886 
1893  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1894 
1902  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1903 
1910  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1911 
1917  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1918 
1924  ImportOptionsKit & SetProECodePageName(char const * in_name);
1925 
1931  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1932 
1938  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1939 
1945  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1946 
1953  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
1954 
1961  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
1962 
1969  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
1970 
1977  ImportOptionsKit & SetProEHomeView(bool in_state);
1978 
1985  ImportOptionsKit & SetProEExplodedViews(bool in_state);
1986 
1993  ImportOptionsKit & SetProEDatum(bool in_state);
1994 
1995 
2002  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2003 
2010  ImportOptionsKit & SetProESkeletons(bool in_state);
2011 
2018  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2019 
2025  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2026 
2032  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2033 
2039  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2040 
2046  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2047 
2053  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2054 
2060  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2061 
2068  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2069 
2075  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2076 
2082  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2083 
2090  ImportOptionsKit & SetIFCEdges(bool in_state);
2091 
2097  ImportOptionsKit & SetIFCMetadata(bool in_state);
2098 
2104  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2105 
2111  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2112 
2118  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2119 
2125  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2126 
2130  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2131 
2143  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2144 
2156  ImportOptionsKit & SetMode(ImportMode in_mode);
2157 
2167  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2168 
2176  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2177 
2184  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2185 
2189  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2190 
2195  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2196 
2200  ImportOptionsKit & UnsetBRepData();
2201 
2204  ImportOptionsKit & UnsetBRepMode();
2205 
2208  ImportOptionsKit & UnsetSolids();
2209 
2212  ImportOptionsKit & UnsetSurfaces();
2213 
2216  ImportOptionsKit & UnsetWireframes();
2217 
2220  ImportOptionsKit & UnsetPMI();
2221 
2224  ImportOptionsKit & UnsetAttributes();
2225 
2228  ImportOptionsKit & UnsetHiddenObjects();
2229 
2232  ImportOptionsKit & UnsetConstructionAndReferences();
2233 
2236  ImportOptionsKit & UnsetActiveFilter();
2237 
2240  ImportOptionsKit & UnsetSewingTolerance();
2241 
2244  ImportOptionsKit & UnsetDefaultUnits();
2245 
2248  ImportOptionsKit & UnsetMultiProcessCount();
2249 
2252  ImportOptionsKit & UnsetPMISubstitutionFont();
2253 
2256  ImportOptionsKit & UnsetPMIPrecision();
2257 
2260  ImportOptionsKit & UnsetPMIDefaultUnits();
2261 
2264  ImportOptionsKit & UnsetPMIDefaultColor();
2265 
2268  ImportOptionsKit & UnsetTessellationLevel();
2269 
2272  ImportOptionsKit & UnsetTessellationAccuracy();
2273 
2276  ImportOptionsKit & UnsetTessellationCleanup();
2277 
2280  ImportOptionsKit & UnsetPMIFlipping();
2281 
2284  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2285 
2288  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2289 
2292  ImportOptionsKit & UnsetTextureDirectories();
2293 
2296  ImportOptionsKit & UnsetSearchDirectories();
2297 
2300  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2301 
2304  ImportOptionsKit & UnsetConfiguration();
2305 
2308  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2309 
2312  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2313 
2316  ImportOptionsKit & UnsetCatiaV5Cache();
2317 
2320  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2321 
2324  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2325 
2328  ImportOptionsKit & UnsetProECodePageName();
2329 
2332  ImportOptionsKit & UnsetProEDimensionTolerance();
2333 
2336  ImportOptionsKit & UnsetProESubpartPMI();
2337 
2340  ImportOptionsKit & UnsetProESessionColor();
2341 
2344  ImportOptionsKit & UnsetProEDatum();
2345 
2348  ImportOptionsKit & UnsetProEHomeView();
2349 
2352  ImportOptionsKit & UnsetProEExplodedViews();
2353 
2356  ImportOptionsKit & UnsetProEMissingBoolean();
2357 
2360  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2361 
2364  ImportOptionsKit & UnsetProEFamilyTreeSource();
2365 
2368  ImportOptionsKit & UnsetProEConstructionEntities();
2369 
2372  ImportOptionsKit & UnsetProESkeletons();
2373 
2376  ImportOptionsKit & UnsetSTEPNamePreference();
2377 
2380  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2381 
2384  ImportOptionsKit & UnsetSTEPCodePageName();
2385 
2388  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2389 
2392  ImportOptionsKit & UnsetSTEPOrientationHealing();
2393 
2396  ImportOptionsKit & UnsetSTEPValidationProperties();
2397 
2400  ImportOptionsKit & UnsetIFCCodePageName();
2401 
2404  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2405 
2408  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2409 
2412  ImportOptionsKit & UnsetIFCFaceOptimization();
2413 
2416  ImportOptionsKit & UnsetIFCEdges();
2417 
2420  ImportOptionsKit & UnsetIFCMetadata();
2421 
2424  ImportOptionsKit & UnsetPDF3DStreamIndex();
2425 
2428  ImportOptionsKit & UnsetJTTessellationLevel();
2429 
2432  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2433 
2436  ImportOptionsKit & UnsetPRCReadHelper();
2437 
2440  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2441 
2444  ImportOptionsKit & UnsetLocation();
2445 
2448  ImportOptionsKit & UnsetMode();
2449 
2452  ImportOptionsKit & UnsetIncrementalComponentPaths();
2453 
2456  ImportOptionsKit & UnsetNURBSConversion();
2457 
2460  ImportOptionsKit & UnsetGeometryDefaultColor();
2461 
2464  ImportOptionsKit & UnsetEverything();
2465 
2466 
2471  bool ShowBRepData(bool & out_state) const;
2472 
2476  bool ShowBRepMode(BRepMode & out_mode) const;
2477 
2481  bool ShowSolids(bool & out_state) const;
2482 
2486  bool ShowSurfaces(bool & out_state) const;
2487 
2491  bool ShowWireframes(bool & out_state) const;
2492 
2496  bool ShowPMI(bool & out_state) const;
2497 
2501  bool ShowAttributes(bool & out_state) const;
2502 
2506  bool ShowHiddenObjects(bool & out_state) const;
2507 
2511  bool ShowConstructionAndReferences(bool & out_state) const;
2512 
2516  bool ShowActiveFilter(bool & out_state) const;
2517 
2521  bool ShowSewingTolerance(double & out_tolerance) const;
2522 
2526  bool ShowDefaultUnits(Units & out_units) const;
2527 
2531  bool ShowMultiProcessCount(unsigned int & out_count) const;
2532 
2537  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2538 
2542  bool ShowPMIPrecision(size_t & out_precision) const;
2543 
2547  bool ShowPMIDefaultUnits(Units & out_units) const;
2548 
2553  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2554 
2562  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2563 
2568  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2569 
2573  bool ShowTessellationCleanup(bool & out_cleanup) const;
2574 
2578  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2579 
2583  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2584 
2588  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2589 
2593  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2594 
2600  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2601 
2605  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2606 
2610  bool ShowConfiguration(UTF8Array & out_configuration) const;
2611 
2615  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2616 
2620  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2621 
2626  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2627 
2632  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2633 
2637  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2638 
2642  bool ShowProECodePageName(UTF8 & out_name) const;
2643 
2647  bool ShowProEDimensionTolerance(bool & out_state) const;
2648 
2652  bool ShowProESubpartPMI(bool & out_state) const;
2653 
2657  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2658 
2662  bool ShowProEDatum(bool & out_state) const;
2663 
2667  bool ShowProEHomeView(bool & out_state) const;
2668 
2672  bool ShowProEExplodedViews(bool & out_state) const;
2673 
2677  bool ShowProEMissingBoolean(bool & out_state) const;
2678 
2682  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2683 
2687  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2688 
2692  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2693 
2697  bool ShowProESkeletons(bool & out_state) const;
2698 
2702  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2703 
2707  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2708 
2712  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2713 
2717  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2718 
2722  bool ShowSTEPOrientationHealing(bool & out_state) const;
2723 
2727  bool ShowSTEPValidationProperties(bool & out_state) const;
2728 
2732  bool ShowIFCCodePageName(UTF8 & out_name) const;
2733 
2737  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2738 
2742  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2743 
2747  bool ShowIFCFaceOptimization(bool & out_state) const;
2748 
2752  bool ShowIFCEdges(bool & out_state) const;
2753 
2757  bool ShowIFCMetadata(bool & out_state) const;
2758 
2762  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2763 
2767  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2768 
2772  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2773 
2777  bool ShowPRCReadHelper(bool & out_use_helper) const;
2778 
2782  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2783 
2788  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2789 
2793  bool ShowMode(ImportMode & out_mode) const;
2794 
2798  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2799 
2803  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2804 
2808  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
2809  };
2810 
2812  class EXCHANGE_API Translation
2813  {
2814  public:
2817  enum class Healing
2818  {
2819  Off,
2820  On,
2821  OnlyIfNotParasolid,
2822  };
2823 
2826  enum class AccurateEdges
2827  {
2828  Off,
2829  On,
2830  OnlyIfNotParasolid,
2831  };
2832 
2835  enum class Simplification
2836  {
2837  Off,
2838  On,
2839  OnlyIfNotParasolid,
2840  };
2841 
2844  enum class Merging
2845  {
2846  Off,
2847  On,
2848  OnlyIfNotParasolid,
2849  };
2850 
2851  private:
2853  Translation();
2854  };
2855 
2857  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
2858  {
2859  public:
2862 
2866 
2871 
2875  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2876 
2877  virtual ~TranslationOptionsKit();
2878 
2879  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2880 
2884  static TranslationOptionsKit GetDefault();
2885 
2888  void Set(TranslationOptionsKit const & in_kit);
2889 
2892  void Show(TranslationOptionsKit & out_kit) const;
2893 
2897  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2898 
2901  bool Empty() const;
2902 
2906  bool Equals(TranslationOptionsKit const & in_kit) const;
2907 
2911  bool operator==(TranslationOptionsKit const & in_kit) const;
2912 
2916  bool operator!=(TranslationOptionsKit const & in_kit) const;
2917 
2923  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2924 
2930  TranslationOptionsKit & SetTessellation(bool in_state);
2931 
2937  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2938 
2942  TranslationOptionsKit & SetApplication(char const * in_name);
2943 
2947  TranslationOptionsKit & SetVersion(char const * in_version);
2948 
2952  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2953 
2957  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2958 
2962  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
2963 
2967  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
2968 
2973  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
2974 
2978  TranslationOptionsKit & SetDisjointFaces(bool in_state);
2979 
2982  TranslationOptionsKit & UnsetSolidsAsFaces();
2983 
2986  TranslationOptionsKit & UnsetTessellation();
2987 
2990  TranslationOptionsKit & UnsetHiddenObjects();
2991 
2994  TranslationOptionsKit & UnsetApplication();
2995 
2998  TranslationOptionsKit & UnsetVersion();
2999 
3002  TranslationOptionsKit & UnsetHealing();
3003 
3006  TranslationOptionsKit & UnsetAccurateEdges();
3007 
3010  TranslationOptionsKit & UnsetSimplification();
3011 
3014  TranslationOptionsKit & UnsetEntityMerging();
3015 
3018  TranslationOptionsKit & UnsetSewing();
3019 
3022  TranslationOptionsKit & UnsetDisjointFaces();
3023 
3026  TranslationOptionsKit & UnsetEverything();
3027 
3028 
3032  bool ShowSolidsAsFaces(bool & out_state) const;
3033 
3037  bool ShowTessellation(bool & out_state) const;
3038 
3042  bool ShowHiddenObjects(bool & out_state) const;
3043 
3047  bool ShowApplication(UTF8 & out_name) const;
3048 
3052  bool ShowVersion(UTF8 & out_version) const;
3053 
3057  bool ShowHealing(Translation::Healing & out_healing) const;
3058 
3062  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3063 
3067  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3068 
3072  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3073 
3078  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3079 
3083  bool ShowDisjointFaces(bool & out_state) const;
3084 
3089  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3090 
3093  TranslationOptionsKit & UnsetMultiProcessCount();
3094 
3098  bool ShowMultiProcessCount(unsigned int & out_count) const;
3099  };
3100 
3101 
3102 
3107  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3108  {
3109  public:
3112 
3116 
3121 
3125  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3126 
3127  virtual ~ModelFileImportOptionsKit();
3128 
3129  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
3130 
3134  static ModelFileImportOptionsKit GetDefault();
3135 
3138  void Set(ModelFileImportOptionsKit const & in_kit);
3139 
3142  void Show(ModelFileImportOptionsKit & out_kit) const;
3143 
3147  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3148 
3151  bool Empty() const;
3152 
3156  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3157 
3161  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3162 
3166  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3167 
3168 
3169  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3170  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3171  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3172  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3173  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3174  * \return A reference to this ImportOptionsKit.
3175  */
3176  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3177 
3183  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3184 
3191  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3192 
3200  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3201 
3202  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3203  * \warning Setting this option to true will cause future exports to output without tessellation data.
3204  * \param in_cleanup Whether to clean up tessellation data from representation items.
3205  * \return A reference to this ImportOptionsKit.
3206  */
3207  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3208 
3214  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3215 
3221  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3222 
3229  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3230 
3234  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3235 
3248  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3249 
3255  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3256 
3260  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3261 
3266  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3267 
3268 
3271  ModelFileImportOptionsKit & UnsetTessellationLevel();
3272 
3275  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3276 
3279  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3280 
3283  ModelFileImportOptionsKit & UnsetPMIFlipping();
3284 
3287  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3288 
3291  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3292 
3295  ModelFileImportOptionsKit & UnsetIFCEdges();
3296 
3299  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3300 
3303  ModelFileImportOptionsKit & UnsetLocation();
3304 
3307  ModelFileImportOptionsKit & UnsetSewingTolerance();
3308 
3311  ModelFileImportOptionsKit & UnsetNURBSConversion();
3312 
3315  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3316 
3319  ModelFileImportOptionsKit & UnsetEverything();
3320 
3321 
3329  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3330 
3335  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3336 
3340  bool ShowTessellationCleanup(bool & out_cleanup) const;
3341 
3345  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3346 
3350  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3351 
3355  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3356 
3360  bool ShowIFCEdges(bool & out_state) const;
3361 
3365  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3366 
3371  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3372 
3376  bool ShowSewingTolerance(double & out_tolerance) const;
3377 
3381  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3382 
3386  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3387  };
3388 
3390  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3391  {
3392  public:
3395 
3398  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3399 
3403 
3404  virtual ~Export3MFOptionsKit();
3405 
3406  HPS::Type ObjectType() const { return HPS::Type::ExchangeExport3MFOptionsKit; }
3407 
3411  static Export3MFOptionsKit GetDefault();
3412 
3415  void Set(Export3MFOptionsKit const & in_kit);
3416 
3419  void Show(Export3MFOptionsKit& out_kit) const;
3420 
3424  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3425 
3429  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3430 
3433  bool Empty() const;
3434 
3438  bool Equals(Export3MFOptionsKit const & in_kit) const;
3439 
3443  bool operator==(Export3MFOptionsKit const & in_kit) const;
3444 
3448  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3449 
3454  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3455 
3458  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3459 
3464  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3465 
3469  Export3MFOptionsKit & SetDescription(char const * in_description);
3470 
3473  Export3MFOptionsKit & UnsetDescription();
3474 
3478  bool ShowDescription(HPS::UTF8 & out_state) const;
3479 
3483  Export3MFOptionsKit & SetCopyright(char const * in_state);
3484 
3487  Export3MFOptionsKit & UnsetCopyright();
3488 
3492  bool ShowCopyright(HPS::UTF8 & out_state) const;
3493 
3497  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3498 
3501  Export3MFOptionsKit & UnsetLicenseTerms();
3502 
3506  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3507 
3510  Export3MFOptionsKit & UnsetEverything();
3511  };
3512 
3514  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3515  {
3516  public:
3519 
3523 
3527 
3528  virtual ~ExportACISOptionsKit();
3529 
3530  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
3531 
3535  static ExportACISOptionsKit GetDefault();
3536 
3539  void Set(ExportACISOptionsKit const & in_kit);
3540 
3543  void Show(ExportACISOptionsKit & out_kit) const;
3544 
3548  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3549 
3553  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3554 
3557  bool Empty() const;
3558 
3562  bool Equals(ExportACISOptionsKit const & in_kit) const;
3563 
3567  bool operator==(ExportACISOptionsKit const & in_kit) const;
3568 
3572  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3573 
3574 
3580  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3581 
3587  ExportACISOptionsKit & SetBinary(bool in_state);
3588 
3589 
3592  ExportACISOptionsKit & UnsetMillimeterUnits();
3593 
3596  ExportACISOptionsKit & UnsetBinary();
3597 
3600  ExportACISOptionsKit & UnsetEverything();
3601 
3602 
3606  bool ShowMillimeterUnits(bool & out_state) const;
3607 
3611  bool ShowBinary(bool & out_state) const;
3612  };
3613 
3615  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
3616  {
3617  public:
3620 
3624 
3628 
3629  virtual ~ExportIGESOptionsKit();
3630 
3631  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
3632 
3636  static ExportIGESOptionsKit GetDefault();
3637 
3640  void Set(ExportIGESOptionsKit const & in_kit);
3641 
3644  void Show(ExportIGESOptionsKit & out_kit) const;
3645 
3649  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
3650 
3654  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
3655 
3658  bool Empty() const;
3659 
3663  bool Equals(ExportIGESOptionsKit const & in_kit) const;
3664 
3668  bool operator==(ExportIGESOptionsKit const & in_kit) const;
3669 
3673  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
3674 
3675 
3681  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3682 
3688  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
3689 
3695  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
3696 
3702  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
3703 
3709  ExportIGESOptionsKit & SetTessellation(bool in_state);
3710 
3714  ExportIGESOptionsKit & SetApplication(char const * in_name);
3715 
3719  ExportIGESOptionsKit & SetVersion(char const * in_version);
3720 
3721 
3724  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
3725 
3728  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
3729 
3732  ExportIGESOptionsKit & UnsetSolidsAsFaces();
3733 
3736  ExportIGESOptionsKit & UnsetHiddenObjects();
3737 
3740  ExportIGESOptionsKit & UnsetTessellation();
3741 
3744  ExportIGESOptionsKit & UnsetApplication();
3745 
3748  ExportIGESOptionsKit & UnsetVersion();
3749 
3752  ExportIGESOptionsKit & UnsetEverything();
3753 
3754 
3758  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3759 
3763  bool ShowFacetedAsWireframe(bool & out_state) const;
3764 
3768  bool ShowSolidsAsFaces(bool & out_state) const;
3769 
3773  bool ShowHiddenObjects(bool & out_state) const;
3774 
3778  bool ShowTessellation(bool & out_state) const;
3779 
3783  bool ShowApplication(UTF8 & out_name) const;
3784 
3788  bool ShowVersion(UTF8 & out_version) const;
3789  };
3790 
3792  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3793  {
3794  public:
3797 
3800  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3801 
3805 
3806  virtual ~ExportJTOptionsKit();
3807 
3808  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
3809 
3813  static ExportJTOptionsKit GetDefault();
3814 
3817  void Set(ExportJTOptionsKit const & in_kit);
3818 
3821  void Show(ExportJTOptionsKit & out_kit) const;
3822 
3826  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3827 
3831  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3832 
3835  bool Empty() const;
3836 
3840  bool Equals(ExportJTOptionsKit const & in_kit) const;
3841 
3845  bool operator==(ExportJTOptionsKit const & in_kit) const;
3846 
3850  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3851 
3852 
3858  ExportJTOptionsKit & SetContent(JT::Content in_content);
3859 
3865  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3866 
3872  ExportJTOptionsKit & SetPMI(bool in_state);
3873 
3874 
3877  ExportJTOptionsKit & UnsetContent();
3878 
3881  ExportJTOptionsKit & UnsetHiddenObjects();
3882 
3885  ExportJTOptionsKit & UnsetPMI();
3886 
3889  ExportJTOptionsKit & UnsetEverything();
3890 
3891 
3895  bool ShowContent(JT::Content & out_content) const;
3896 
3900  bool ShowHiddenObjects(bool & out_state) const;
3901 
3905  bool ShowPMI(bool & out_state) const;
3906  };
3907 
3909  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
3910  {
3911  public:
3914 
3918 
3922 
3923  virtual ~ExportParasolidOptionsKit();
3924 
3925  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
3926 
3930  static ExportParasolidOptionsKit GetDefault();
3931 
3934  void Set(ExportParasolidOptionsKit const & in_kit);
3935 
3938  void Show(ExportParasolidOptionsKit & out_kit) const;
3939 
3943  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
3944 
3948  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
3949 
3952  bool Empty() const;
3953 
3957  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
3958 
3962  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
3963 
3967  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
3968 
3969 
3975  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
3976 
3982  ExportParasolidOptionsKit & SetTessellation(bool in_state);
3983 
3989  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
3990 
3994  ExportParasolidOptionsKit & SetApplication(char const * in_name);
3995 
3999  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4000 
4001 
4004  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4005 
4008  ExportParasolidOptionsKit & UnsetTessellation();
4009 
4012  ExportParasolidOptionsKit & UnsetHiddenObjects();
4013 
4016  ExportParasolidOptionsKit & UnsetApplication();
4017 
4020  ExportParasolidOptionsKit & UnsetVersion();
4021 
4024  ExportParasolidOptionsKit & UnsetEverything();
4025 
4026 
4030  bool ShowSolidsAsFaces(bool & out_state) const;
4031 
4035  bool ShowTessellation(bool & out_state) const;
4036 
4040  bool ShowHiddenObjects(bool & out_state) const;
4041 
4045  bool ShowApplication(UTF8 & out_name) const;
4046 
4050  bool ShowVersion(UTF8 & out_version) const;
4051  };
4052 
4054  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4055  {
4056  public:
4059 
4062  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4063 
4067 
4068  virtual ~ExportPRCOptionsKit();
4069 
4070  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
4071 
4075  static ExportPRCOptionsKit GetDefault();
4076 
4079  void Set(ExportPRCOptionsKit const & in_kit);
4080 
4083  void Show(ExportPRCOptionsKit & out_kit) const;
4084 
4088  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4089 
4093  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4094 
4097  bool Empty() const;
4098 
4102  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4103 
4107  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4108 
4112  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4113 
4114 
4120  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4121 
4128  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4129 
4135  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4136 
4142  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4143 
4148  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4149 
4155  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4156 
4157 
4160  ExportPRCOptionsKit & UnsetTessellationCompression();
4161 
4164  ExportPRCOptionsKit & UnsetBRepCompression();
4165 
4168  ExportPRCOptionsKit & UnsetBRepRemoval();
4169 
4172  ExportPRCOptionsKit & UnsetAttributeRemoval();
4173 
4176  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4177 
4180  ExportPRCOptionsKit & UnsetEverything();
4181 
4182 
4186  bool ShowTessellationCompression(bool & out_state) const;
4187 
4191  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4192 
4196  bool ShowBRepRemoval(bool & out_state) const;
4197 
4201  bool ShowAttributeRemoval(bool & out_state) const;
4202 
4206  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4207  };
4208 
4210  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4211  {
4212  public:
4215 
4219 
4223 
4224  virtual ~ExportSTEPOptionsKit();
4225 
4226  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
4227 
4231  static ExportSTEPOptionsKit GetDefault();
4232 
4235  void Set(ExportSTEPOptionsKit const & in_kit);
4236 
4239  void Show(ExportSTEPOptionsKit & out_kit) const;
4240 
4244  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4245 
4249  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4250 
4253  bool Empty() const;
4254 
4258  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4259 
4263  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4264 
4268  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4269 
4270 
4276  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4277 
4283  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4284 
4290  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4291 
4297  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4298 
4302  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4303 
4307  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4308 
4312  ExportSTEPOptionsKit & SetPMI(bool in_state);
4313 
4317  ExportSTEPOptionsKit & SetCurves(bool in_state);
4318 
4322  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4323 
4324 
4327  ExportSTEPOptionsKit & UnsetFormat();
4328 
4331  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
4332 
4335  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
4336 
4339  ExportSTEPOptionsKit & UnsetNameShortening();
4340 
4343  ExportSTEPOptionsKit & UnsetApplication();
4344 
4347  ExportSTEPOptionsKit & UnsetVersion();
4348 
4351  ExportSTEPOptionsKit & UnsetPMI();
4352 
4355  ExportSTEPOptionsKit & UnsetCurves();
4356 
4359  ExportSTEPOptionsKit & UnsetAttributes();
4360 
4363  ExportSTEPOptionsKit & UnsetEverything();
4364 
4365 
4369  bool ShowFormat(STEP::Format & out_format) const;
4370 
4374  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4375 
4379  bool ShowFacetedAsWireframe(bool & out_state) const;
4380 
4384  bool ShowNameShortening(bool & out_state) const;
4385 
4389  bool ShowApplication(UTF8 & out_name) const;
4390 
4394  bool ShowVersion(UTF8 & out_version) const;
4395 
4399  bool ShowPMI(bool & out_state) const;
4400 
4404  bool ShowCurves(bool & out_state) const;
4405 
4409  bool ShowAttributes(bool & out_state) const;
4410  };
4411 
4413  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4414  {
4415  public:
4418 
4421  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4422 
4426 
4427  virtual ~ExportSTLOptionsKit();
4428 
4429  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
4430 
4434  static ExportSTLOptionsKit GetDefault();
4435 
4438  void Set(ExportSTLOptionsKit const & in_kit);
4439 
4442  void Show(ExportSTLOptionsKit & out_kit) const;
4443 
4447  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4448 
4452  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4453 
4456  bool Empty() const;
4457 
4461  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4462 
4466  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4467 
4471  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4472 
4473 
4479  ExportSTLOptionsKit & SetBinary(bool in_state);
4480 
4486  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4487 
4494  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4495 
4501  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4502 
4508  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4509 
4516  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4517 
4518 
4521  ExportSTLOptionsKit & UnsetBinary();
4522 
4525  ExportSTLOptionsKit & UnsetTessellationLevel();
4526 
4529  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4530 
4533  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4534 
4537  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4538 
4541  ExportSTLOptionsKit & UnsetEverything();
4542 
4543 
4547  bool ShowBinary(bool & out_state) const;
4548 
4556  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4557 
4561  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4562 
4566  bool ShowCurrentTessellationRetention(bool & out_state) const;
4567 
4571  bool ShowMaximumEdgeLength(double & out_length) const;
4572  };
4573 
4575  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4576  {
4577  public:
4580 
4583  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4584 
4588 
4589  virtual ~ExportU3DOptionsKit();
4590 
4591  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
4592 
4596  static ExportU3DOptionsKit GetDefault();
4597 
4600  void Set(ExportU3DOptionsKit const & in_kit);
4601 
4604  void Show(ExportU3DOptionsKit & out_kit) const;
4605 
4609  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4610 
4614  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4615 
4618  bool Empty() const;
4619 
4623  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4624 
4628  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4629 
4633  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4634 
4635 
4641  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4642 
4647  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4648 
4649 
4652  ExportU3DOptionsKit & UnsetVersion();
4653 
4656  ExportU3DOptionsKit & UnsetCompression();
4657 
4660  ExportU3DOptionsKit & UnsetEverything();
4661 
4662 
4666  bool ShowVersion(U3D::Version & out_version) const;
4667 
4671  bool ShowCompression(unsigned char & out_level) const;
4672  };
4673 
4675  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4676  {
4677  public:
4680 
4683  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4684 
4688 
4689  virtual ~ExportXMLOptionsKit();
4690 
4691  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
4692 
4696  static ExportXMLOptionsKit GetDefault();
4697 
4700  void Set(ExportXMLOptionsKit const & in_kit);
4701 
4704  void Show(ExportXMLOptionsKit & out_kit) const;
4705 
4709  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4710 
4714  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4715 
4718  bool Empty() const;
4719 
4723  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4724 
4728  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4729 
4733  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4734 
4735 
4741  ExportXMLOptionsKit & SetMetadata(bool in_state);
4742 
4748  ExportXMLOptionsKit & SetTransformations(bool in_state);
4749 
4755  ExportXMLOptionsKit & SetMaterials(bool in_state);
4756 
4757 
4760  ExportXMLOptionsKit & UnsetMetadata();
4761 
4764  ExportXMLOptionsKit & UnsetTransformations();
4765 
4768  ExportXMLOptionsKit & UnsetMaterials();
4769 
4772  ExportXMLOptionsKit & UnsetEverything();
4773 
4774 
4778  bool ShowMetadata(bool & out_state) const;
4779 
4783  bool ShowTransformations(bool & out_state) const;
4784 
4788  bool ShowMaterials(bool & out_state) const;
4789  };
4790 
4792  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
4793  {
4794  public:
4797 
4801 
4805 
4806  virtual ~TessellationOptionsKit();
4807 
4808  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
4809 
4813  static TessellationOptionsKit GetDefault();
4814 
4817  void Set(TessellationOptionsKit const & in_kit);
4818 
4821  void Show(TessellationOptionsKit & out_kit) const;
4822 
4826  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4827 
4831  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
4832 
4835  bool Empty() const;
4836 
4840  bool Equals(TessellationOptionsKit const & in_kit) const;
4841 
4845  bool operator==(TessellationOptionsKit const & in_kit) const;
4846 
4850  bool operator!=(TessellationOptionsKit const & in_kit) const;
4851 
4852 
4856  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
4857 
4864  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4865 
4871  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
4872 
4876  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
4877 
4881  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4882 
4883 
4886  TessellationOptionsKit & UnsetLevel();
4887 
4890  TessellationOptionsKit & UnsetAccuracy();
4891 
4894  TessellationOptionsKit & UnsetUVPointPreservation();
4895 
4898  TessellationOptionsKit & UnsetMaximumEdgeLength();
4899 
4902  TessellationOptionsKit & UnsetEverything();
4903 
4904 
4912  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4913 
4918  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
4919 
4923  bool ShowUVPointPreservation(bool & out_state) const;
4924 
4928  bool ShowMaximumEdgeLength(double & out_length) const;
4929  };
4930 
4936  class EXCHANGE_API CommonMeasurementOperator : public Operator
4937  {
4938  public:
4939  enum class Tags
4940  {
4941  Name = 0,
4942  MeasurementType,
4943  Radius,
4944  Inverted,
4945  VectorX,
4946  VectorY,
4947  VectorZ,
4948  };
4949 
4951 
4952  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4953 
4955  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
4956 
4957  virtual void OnViewAttached() OVERRIDE;
4958  virtual void OnViewDetached() OVERRIDE;
4959 
4960  Exchange::CADModel GetCADModel() const;
4961  void SetCADModel(Exchange::CADModel const & in_cad_model);
4962 
4964  size_t GetPrecision() const;
4965 
4968  void SetPrecision(size_t in_precision);
4969 
4971  MaterialMappingKit GetMaterial() const;
4972 
4975  void SetMaterial(MaterialMappingKit const & in_material_mapping);
4976 
4978  TextAttributeKit GetTextAttributes() const;
4979 
4982  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
4983 
4985  SegmentKey GetMeasurementSegment() const;
4986 
4988  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
4989 
4990  /* Deletes all measurements */
4991  void DeleteMeasurements();
4992 
4993  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
4994  {
4995  public:
4998  {
4999  channel = GetClassID();
5000  consumable = false;
5001  }
5002 
5003  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5004  {
5005  channel = GetClassID();
5006  consumable = false;
5007  measurement_key = in_measurement_key;
5008  view = in_view;
5009  }
5010 
5013  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5014  {
5015  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5016  {
5017  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5018  measurement_key = that.measurement_key;
5019  view = that.view;
5020  }
5021  else
5022  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5023  }
5024 
5026 
5029  Event * Clone() const
5030  {
5031  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5032  return new_event;
5033  }
5034 
5035  Key measurement_key;
5036  View view;
5037  };
5038 
5039  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5040  {
5041  public:
5044  {
5045  channel = GetClassID();
5046  consumable = false;
5047  }
5048 
5049  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5050  {
5051  channel = GetClassID();
5052  consumable = false;
5053  measurement_name = in_measurement_name;
5054  view = in_view;
5055  }
5056 
5059  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5060  {
5061  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5062  {
5063  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5064  measurement_name = that.measurement_name;
5065  view = that.view;
5066  }
5067  else
5068  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5069  }
5070 
5072 
5075  Event * Clone() const
5076  {
5077  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5078  return new_event;
5079  }
5080 
5081  UTF8 measurement_name;
5082  View view;
5083  };
5084 
5085  protected:
5086  Exchange::CADModel cad_model;
5087  size_t measurement_precision;
5088  UTF8 units;
5089  MaterialMappingKit materials;
5090  TextAttributeKit text_attributes;
5091  SegmentKey measurement_segment;
5092  GlyphDefinition left_arrow;
5093  GlyphDefinition right_arrow;
5094  SelectionOptionsKit selection_options;
5095  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5096  Vector camera_direction;
5097  PortfolioKey portfolio;
5098  SegmentKey style_segment;
5099  HighlightOptionsKit highlight_options;
5100 
5101  static size_t length_measurement_index;
5102  static size_t radius_measurement_index;
5103  static size_t distance_measurement_index;
5104  static size_t angle_measurement_index;
5105 
5106  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5107  void GetUnits();
5108  void SetGlyphColor();
5109  void GetCameraDirection();
5110  void SetupConstructionSegment();
5111  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5112  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5113  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5114  float GetModelScale(Exchange::Component const & component);
5115  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5116  };
5117 
5170  {
5171  public:
5172  enum class MeasurementType
5173  {
5174  PointToPoint,
5175  EdgeAndRadius,
5176  FeatureToFeature,
5177  FaceAngle,
5178  };
5179 
5181 
5182  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5183 
5185  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
5186 
5187  virtual void OnViewAttached() OVERRIDE;
5188  virtual void OnViewDetached() OVERRIDE;
5189 
5194  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
5195 
5199  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
5200 
5208  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
5209 
5213  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
5214 
5215  /* Sets the type of measurement to insert.
5216  * \param in_measurement_type The type of measurement to insert.*/
5217  void SetMeasurementType(MeasurementType in_measurement_type);
5218 
5221  MeasurementType GetMeasurementType();
5222 
5223  /* Whether measurable geometry should be highlighted when mousing over it
5224  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
5225  void SetMouseOverHighlighting(bool in_highlighting);
5226 
5227  /* Whether measurable geometry should be highlighted when mousing over it
5228  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
5229  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
5230  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5231 
5232  /* Whether measurable geometry is highlighted when mousing over it
5233  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
5234  bool GetMouseOverHighlighting();
5235 
5236  /* Returns the highlight option kit currently used for mouse over highlighting.
5237  * \return the highlight option kit currently used for mouse over highlighting. */
5238  HighlightOptionsKit GetHighlightOptions();
5239 
5240  /* Whether a measurement is currently being inserted or edited.
5241  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
5242  bool IsMeasurementActive();
5243 
5244  private:
5245  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5246  {
5247  Circle,
5248  Line,
5249  Generic,
5250  };
5251 
5252  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5253  {
5254  public:
5255  Surface();
5256 
5257  enum class SurfaceType
5258  {
5259  Plane,
5260  ConeOrCylinder,
5261  Unsupported,
5262  };
5263 
5264  SurfaceType surface_type; //the type of surface being measured
5265  Point center; //the center point of the surface
5266  Vector normal; //the center line of surfaces of type Cylinder or Cone
5267  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5268  ComponentPath path; //the component path to this surface
5269  };
5270 
5271  //bookkeeping
5272  MeasurementType measurement_type; //the type of measurement to be inserted
5273  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5274  TouchID tracked_touch_id;
5275  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5276  bool operator_active; //whether a measurement is in progress
5277  bool end_measurement; //whether we should end the current measurement
5278  CanvasArray canvases; //canvases related to the view where this operator is attached
5279 
5280  //measurement anchors
5281  size_t anchors; //valid for point-to-point and face-angle measurements
5282  bool anchors_in_place; //true if all the anchors have been placed
5283  Point first_click_position; //position of the first anchor
5284  Point second_click_position; //position of the second anchor
5285 
5286  //geometry for linear measurements
5287  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5288  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5289  LineKey distance_line; //a line representing the distance measured
5290  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5291  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5292  Point distance_point_one; //intersection of leader_line_one and distance_line
5293  Point distance_point_two; //intersection of leader_line_two and distance_line
5294  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5295  TextKey text; //text representing the measurement and units
5296  UTF8 text_string; //the contents of the text
5297  Vector measurement_direction; //the direction of the measurement
5298  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5299  Vector explicit_direction; //used if use_explicit_direction is true
5300 
5301  //geometry for radius measurement
5302  MarkerKey center_marker; //marker representing the center of the circle
5303  Point circle_center; //circle center
5304  float radius; //circle radius
5305 
5306  //edge specific data
5307  LineKey edge_line; //the edge being measured
5308  double edge_length; //length of the measured edge
5309  EdgeType edge_type; //the type of edge being measured
5310 
5311  //feature-to-feature specific data
5312  Surface surface_one; //data related to first selected surface
5313  Surface surface_two; //data related to second selected surface
5314  Plane measurement_plane; //the measurement plane
5315  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5316 
5317  //angle specific data
5318  Vector leader_line_one_direction; //the direction of the first leader line
5319  Vector leader_line_two_direction; //the direction of the second leader line
5320  Vector first_face_normal; //the normal of the first selected face
5321  Vector second_face_normal; //the normal of the second selected face
5322  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'
5323  CircularArcKey measurement_arc; //an arc representing the measured angle
5324  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5325  Vector mid_point_direction;
5326 
5327  //selection kits
5328  SelectionOptionsKit point_to_point_selection;
5329  SelectionOptionsKit edge_radius_selection;
5330  SelectionOptionsKit feature_to_feature_selection;
5331  SelectionOptionsKit angle_selection;
5332 
5333  //highlighting
5334  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5335  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5336  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5337  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5338  KeyPath highlighted_path; //highlighted_path
5339  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5340  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5341 
5342  //input handling
5343  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5344  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5345  bool InputUp(WindowKey & in_window);
5346  void ResetMeasurement();
5347 
5348  //inserting measurements
5349  void InsertPointToPointMeasurement(Point const & in_world_point);
5350  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5351  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5352  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5353  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5354  void InvertMeasuredAngle(WindowKey & in_window);
5355  void AdjustLineToCursor(Point const & cursor_position);
5356 
5357  //saving measurements
5358  void TagMeasurement();
5359  void TagPointToPointMeasurement();
5360  void TagEdgeMeasurement();
5361  void TagRadiusMeasurement();
5362  void TagGenericEdgeMeasurement();
5363  void TagFeatureToFeatureMeasurement();
5364  void TagAngleMeasurement();
5365 
5366  //restoring measurements
5367  void RestoreMeasurement(SegmentKey const & measurement_segment);
5368  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5369  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5370  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5371  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5372  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5373  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5374  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5375 
5376  //topology functions
5377  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5378  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5379  void PlaneToCenterLineDistance();
5380  void PlaneToPlaneDistance();
5381  void LineToLineDistance();
5382  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);
5383  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5384  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5385  bool IsPlane(Exchange::Component const & face_component);
5386  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5387  };
5388 
5389 private:
5391  Exchange();
5392 };
5393 
5394 }
5395 
5396 #endif
Definition: hps.h:6162
Definition: sprk_exchange.h:4054
Level
Definition: sprk_exchange.h:841
ConstructionEntities
Definition: sprk_exchange.h:993
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3808
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:944
Definition: sprk.h:264
HPS::Type ObjectType() const
Definition: sprk_exchange.h:270
Definition: sprk_exchange.h:1109
Definition: sprk_exchange.h:4936
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5642
Units
Definition: sprk_exchange.h:63
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2835
Definition: sprk.h:100
Definition: sprk_exchange.h:591
Version
Definition: sprk_exchange.h:1014
Definition: sprk_exchange.h:3107
Definition: sprk_exchange.h:851
Definition: sprk_exchange.h:690
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4955
HPS::Type ObjectType() const
Definition: sprk_exchange.h:672
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4691
SurfaceType
Definition: sprk_exchange.h:773
Definition: hps.h:1672
Format
Definition: sprk_exchange.h:931
HPS::Type ObjectType() const
Definition: sprk_exchange.h:718
Definition: sprk_exchange.h:4675
Definition: sprk.h:234
Definition: hps.h:44911
Format
Definition: sprk_exchange.h:1114
Definition: hps.h:7671
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4070
Type
Definition: sprk_exchange.h:832
Definition: hps.h:15731
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3631
Definition: sprk_exchange.h:447
Definition: sprk_exchange.h:531
Definition: sprk_exchange.h:297
HPS::Type ObjectType() const
Definition: sprk_exchange.h:428
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:5185
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3925
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5013
HPS::Type ObjectType() const
Definition: sprk_exchange.h:132
Definition: sprk_exchange.h:1330
Definition: sprk_exchange.h:238
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4429
HPS::Type ObjectType() const
Definition: sprk_exchange.h:323
Definition: sprk_exchange.h:3792
Merging
Definition: sprk_exchange.h:2844
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2879
Field
Definition: sprk_exchange.h:921
Definition: hps.h:39199
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1063
Definition: sprk_exchange.h:3514
Definition: sprk_exchange.h:2857
Limit
Definition: sprk_exchange.h:856
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4226
Definition: hps.h:4353
TessellationLevel
Definition: sprk_exchange.h:903
Definition: sprk_exchange.h:827
Definition: sprk_exchange.h:4413
Definition: sprk_exchange.h:111
Definition: sprk_exchange.h:916
Definition: hps.h:4292
Definition: hps.h:7044
Definition: hps.h:44302
Definition: sprk_exchange.h:402
UnloadMode
Definition: sprk_exchange.h:80
Definition: hps.h:41129
Definition: hps.h:44698
AnnotationCaptureFitting
Definition: sprk_exchange.h:820
Definition: sprk_exchange.h:4575
Definition: sprk_exchange.h:889
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3530
Definition: hps.h:15141
Event * Clone() const
Definition: sprk_exchange.h:5075
intptr_t GetChannel() const
Definition: hps.h:6295
Definition: sprk_exchange.h:1009
SessionColor
Definition: sprk_exchange.h:968
Definition: sprk.h:1718
Definition: hps.h:45017
LoadStatus
Definition: sprk_exchange.h:95
Definition: hps.h:42111
Definition: hps.h:43967
CurveType
Definition: sprk_exchange.h:796
Definition: sprk_exchange.h:491
Definition: hps.h:6262
Definition: hps.h:13439
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4808
Definition: sprk_exchange.h:5169
Definition: sprk.h:472
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1576
BRepCompression
Definition: sprk_exchange.h:949
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:746
Definition: sprk.h:2032
ComponentType
Definition: sprk.h:1723
Accuracy
Definition: sprk_exchange.h:873
Definition: sprk_exchange.h:3390
Definition: sprk_exchange.h:3615
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1352
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5059
Definition: sprk.h:2343
FamilyTable
Definition: sprk_exchange.h:981
Content
Definition: sprk_exchange.h:894
Definition: sprk_exchange.h:1554
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3129
HPS::Type ObjectType() const
Definition: sprk_exchange.h:619
Definition: sprk.h:2442
static MouseButtons ButtonLeft()
Definition: hps.h:44420
Definition: hps.h:7590
Definition: sprk_exchange.h:963
AccurateEdges
Definition: sprk_exchange.h:2826
Event * Clone() const
Definition: sprk_exchange.h:5029
HPS::Type ObjectType() const
Definition: sprk_exchange.h:473
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4591
Definition: hps.h:9176
HPS::Type ObjectType() const
Definition: sprk_exchange.h:205
Definition: sprk_exchange.h:644
Definition: hps.h:23161
Healing
Definition: sprk_exchange.h:2817
Definition: sprk.h:2528
Definition: hps.h:29391
ImportMode
Definition: sprk_exchange.h:761
Definition: sprk_exchange.h:1026
Definition: hps.h:515
Definition: sprk.h:1092
Definition: sprk_exchange.h:2812
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:3909
Definition: sprk_exchange.h:173
Definition: hps.h:38696
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3406
Definition: sprk_exchange.h:4792
HPS::Type ObjectType() const
Definition: sprk_exchange.h:559
Definition: hps.h:39793
Definition: sprk_exchange.h:4210