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 
18 #ifdef _MSC_VER
19 #ifndef STATIC_APP
20 # ifdef SPRK_EXCHANGE
21 # define EXCHANGE_API __declspec (dllexport)
22 # else
23 # define EXCHANGE_API __declspec (dllimport)
24 # endif
25 #endif
26 #else
27 # include <stddef.h>
28 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
29 # ifndef STATIC_APP
30 # define EXCHANGE_API __attribute__ ((visibility ("default")))
31 # endif
32 # endif
33 #endif
34 
35 #ifndef EXCHANGE_API
36 # define EXCHANGE_API
37 #endif
38 
39 namespace HPS
40 {
41 
43 class EXCHANGE_API Exchange
44 {
45 public:
46 
47  class Component;
48  class Configuration;
49  class Sheet;
51  class TranslationNotifier;
54  class ReloadNotifier;
55 
56  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
57  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
58  typedef HPS::IntArray ParasolidEntityArray;
59 
62  enum class Units
63  {
64  Unknown,
65  Point,
66  Inch,
67  Millimeter,
68  Centimeter,
69  Pica,
70  Foot,
71  Yard,
72  Meter,
73  Kilometer,
74  Mile
75  };
76 
79  enum class UnloadMode
80  {
83  ExchangeAndVisualization,
84 
89  ExchangeOnly,
90  };
91 
94  enum class LoadStatus
95  {
97  Unknown,
99  Loaded,
101  VisualizationOnly,
103  PartiallyLoaded,
105  NotLoaded
106  };
107 
110  class EXCHANGE_API Component : public HPS::Component
111  {
112  public:
114  Component();
115 
119  Component(HPS::Component const & in_that);
120 
123  Component(Exchange::Component const & in_that);
124 
127  Component(Exchange::Component && in_that);
128 
129  virtual ~Component();
130 
131  HPS::Type ObjectType() const { return HPS::Type::ExchangeComponent; }
132 
133 #if !defined(_MSC_VER) || _MSC_VER >= 1900
134  Component & operator=(Component const & in_that) = default;
135 #endif
136 
140  Component & operator=(Exchange::Component && in_that);
141 
142 
145  A3DEntity * GetExchangeEntity() const;
146 
147 
153  void Tessellate(TessellationOptionsKit const & in_options);
154 
161  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
162 
169  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
170  };
171 
172  class EXCHANGE_API ProductOccurrence : public Exchange::Component
173  {
174  public:
177 
181  ProductOccurrence(HPS::Component const & in_that);
182 
186  ProductOccurrence(Component const & in_that);
187 
190  ProductOccurrence(ProductOccurrence const & in_sheet);
191 
196 
200  ProductOccurrence & operator=(ProductOccurrence && in_that);
201 
202  virtual ~ProductOccurrence();
203 
204  HPS::Type ObjectType() const { return HPS::Type::ExchangeProductOccurrence; }
205 
209  bool Equals(ProductOccurrence const & in_kit) const;
210 
214  bool operator==(ProductOccurrence const & in_kit) const;
215 
219  bool operator!=(ProductOccurrence const & in_kit) const;
220 
226  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
227 
233  LoadStatus GetLoadStatus() const;
234  };
235 
237  class EXCHANGE_API Sheet : public Exchange::Component
238  {
239  public:
241  Sheet();
242 
246  Sheet(HPS::Component const & in_that);
247 
251  Sheet(Component const & in_that);
252 
255  Sheet(Sheet const & in_sheet);
256 
260  Sheet(Sheet && in_that);
261 
265  Sheet & operator=(Sheet && in_that);
266 
267  virtual ~Sheet();
268 
269  HPS::Type ObjectType() const { return HPS::Type::ExchangeSheet; }
270 
274  bool Equals(Sheet const & in_kit) const;
275 
276 #if !defined(_MSC_VER) || _MSC_VER >= 1900
277  Sheet & operator=(Sheet const & in_that) = default;
278 #endif
279 
283  bool operator==(Sheet const & in_kit) const;
284 
288  bool operator!=(Sheet const & in_kit) const;
289 
290  /* Activates this sheet */
291  HPS::View Activate();
292  };
293 
296  class EXCHANGE_API CADModel : public HPS::CADModel
297  {
298  public:
300  CADModel();
301 
305  CADModel(Component const & in_that);
306 
310  CADModel(HPS::CADModel const & in_that);
311 
314  CADModel(Exchange::CADModel const & in_that);
315 
318  CADModel(Exchange::CADModel && in_that);
319 
320  virtual ~CADModel();
321 
322  HPS::Type ObjectType() const { return HPS::Type::ExchangeCADModel; }
323 
324 #if !defined(_MSC_VER) || _MSC_VER >= 1900
325  CADModel & operator=(Exchange::CADModel const & in_that) = default;
326 #endif
327 
331  CADModel & operator=(Exchange::CADModel && in_that);
332 
333 
336  A3DEntity * GetExchangeEntity() const;
337 
341  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
342 
348  bool GetEntityOwnership() const;
349 
350 
354  UTF8Array GetCurrentConfiguration() const;
355 
359  ConfigurationArray GetConfigurations() const;
360 
361  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
362  * \return The list of sheets for this CADModel */
363  SheetArray GetSheets() const;
364 
370  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
371 
376  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
377 
383  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
384 
390  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
391 
396  void Tessellate(TessellationOptionsKit const & in_options);
397  };
398 
401  class EXCHANGE_API Capture : public HPS::Capture
402  {
403  public:
405  Capture();
406 
410  Capture(Component const & in_that);
411 
415  Capture(HPS::Capture const & in_that);
416 
419  Capture(Exchange::Capture const & in_that);
420 
423  Capture(Exchange::Capture && in_that);
424 
425  virtual ~Capture();
426 
427  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
428 
429 #if !defined(_MSC_VER) || _MSC_VER >= 1900
430  Capture & operator=(Exchange::Capture const & in_that) = default;
431 #endif
432 
436  Capture & operator=(Exchange::Capture && in_that);
437 
438 
441  A3DEntity * GetExchangeEntity() const;
442  };
443 
446  class EXCHANGE_API Filter : public HPS::Filter
447  {
448  public:
450  Filter();
451 
455  Filter(Component const & in_that);
456 
460  Filter(HPS::Filter const & in_that);
461 
464  Filter(Exchange::Filter const & in_that);
465 
468  Filter(Exchange::Filter && in_that);
469 
470  virtual ~Filter();
471 
472  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
473 
474 #if !defined(_MSC_VER) || _MSC_VER >= 1900
475  Filter & operator=(Exchange::Filter const & in_that) = default;
476 #endif
477 
481  Filter & operator=(Exchange::Filter && in_that);
482 
483 
486  A3DEntity * GetExchangeEntity() const;
487  };
488 
490  class EXCHANGE_API Factory : public Sprocket
491  {
492  public:
497  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
498 
504  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
505 
509  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
510 
517  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
518 
522  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
523 
524  private:
526  Factory();
527  };
528 
530  class EXCHANGE_API ImportNotifier : public IONotifier
531  {
532  public:
534  ImportNotifier();
535 
538  ImportNotifier(ImportNotifier const & in_that);
539 
544  ImportNotifier(IONotifier const & in_that);
545 
549  ImportNotifier(ImportNotifier && in_that);
550 
554  ImportNotifier & operator=(ImportNotifier && in_that);
555 
556  virtual ~ImportNotifier();
557 
558  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
559 
563  ImportNotifier & operator=(ImportNotifier const & in_that);
564 
567  void Assign(ImportNotifier const & in_that);
568 
571  Exchange::CADModel GetCADModel() const;
572 
575  Time GetImportTime() const;
576 
579  Time GetParseTime() const;
580  };
581 
583  class EXCHANGE_API TranslationNotifier : public IONotifier
584  {
585  public:
588 
591  TranslationNotifier(TranslationNotifier const & in_that);
592 
597  TranslationNotifier(IONotifier const & in_that);
598 
603 
607  TranslationNotifier & operator=(TranslationNotifier && in_that);
608 
609  virtual ~TranslationNotifier();
610 
611  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
612 
616  TranslationNotifier & operator=(TranslationNotifier const & in_that);
617 
620  void Assign(TranslationNotifier const & in_that);
621 
624  Exchange::ParasolidEntityArray GetParasolidParts() const;
625 
628  HPS::Time GetImportTime() const;
629 
632  HPS::Time GetTranslationTime() const;
633  };
634 
636  class EXCHANGE_API ExportNotifier : public IONotifier
637  {
638  public:
640  ExportNotifier();
641 
644  ExportNotifier(ExportNotifier const & in_that);
645 
650  ExportNotifier(IONotifier const & in_that);
651 
655  ExportNotifier(ExportNotifier && in_that);
656 
660  ExportNotifier & operator=(ExportNotifier && in_that);
661 
662  virtual ~ExportNotifier();
663 
664  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
665 
669  ExportNotifier & operator=(ExportNotifier const & in_that);
670 
673  void Assign(ExportNotifier const & in_that);
674 
678  A3DAsmModelFile * GetModelFile() const;
679  };
680 
682  class EXCHANGE_API ReloadNotifier : public IONotifier
683  {
684  public:
686  ReloadNotifier();
687 
690  ReloadNotifier(ReloadNotifier const & in_that);
691 
696  ReloadNotifier(IONotifier const & in_that);
697 
701  ReloadNotifier(ReloadNotifier && in_that);
702 
706  ReloadNotifier & operator=(ReloadNotifier && in_that);
707 
708  virtual ~ReloadNotifier();
709 
710  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
711 
715  ReloadNotifier & operator=(ReloadNotifier const & in_that);
716 
719  void Assign(ReloadNotifier const & in_that);
720  };
721 
722 
723  class ImportOptionsKit;
724  class ModelFileImportOptionsKit;
725  class ExportACISOptionsKit;
726  class ExportIGESOptionsKit;
727  class ExportJTOptionsKit;
728  class ExportPRCOptionsKit;
729  class ExportSTEPOptionsKit;
730  class ExportSTLOptionsKit;
731  class ExportU3DOptionsKit;
732  class ExportXMLOptionsKit;
733 
734 
737  enum class BRepMode
738  {
741  TessellationOnly,
744  BRepOnly,
747  BRepAndTessellation,
748  };
749 
752  enum class ImportMode
753  {
756  Complete,
759  Incremental,
760  };
761 
764  enum class SurfaceType
765  {
766  Blend01,
767  Blend02,
768  Blend03,
769  Blend04,
770  NURBS,
771  Cone,
772  Cylinder,
773  Offset,
774  Pipe,
775  Plane,
776  Ruled,
777  Sphere,
778  Revolution,
779  Extrusion,
780  FromCurve,
781  Torus,
782  Transform,
783  };
784 
787  enum class CurveType
788  {
789  Blend,
790  NURBS,
791  Circle,
792  Composite,
793  CurveOnSurface,
794  Ellipse,
795  Equation,
796  Helix,
797  Hyperbola,
798  Intersection,
799  Line,
800  Offset,
801  Parabola,
802  Polyline,
803  Transform,
804  };
805 
806  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
807  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
808 
812  {
813  PMIOnly,
814  ModelAndPMI
815  };
816 
818  class EXCHANGE_API Tessellation
819  {
820  public:
823  enum class Type
824  {
825  Standard,
826  Custom
827  };
828 
829 
832  enum class Level
833  {
834  ExtraLow,
835  Low,
836  Medium,
837  High,
838  ExtraHigh,
839  };
840 
842  class EXCHANGE_API Chord
843  {
844  public:
847  enum class Limit
848  {
851  Ratio,
854  Height
855  };
856 
857  private:
859  Chord();
860  };
861 
864  enum class Accuracy
865  {
868  Standard,
871  Accurate
872  };
873 
874  private:
876  Tessellation();
877  };
878 
880  class EXCHANGE_API JT
881  {
882  public:
885  enum class Content
886  {
887  Geometry,
888  Tessellation,
889  GeometryAndTessellation
890  };
891 
894  enum class TessellationLevel
895  {
896  Low,
897  Medium,
898  High,
899  };
900 
901  private:
903  JT();
904  };
905 
907  class EXCHANGE_API STEP
908  {
909  public:
912  enum class Field
913  {
914  ProductName,
915  NextAssemblyUsageOccurrenceID,
916  NextAssemblyUsageOccurrenceName,
917  NextAssemblyUsageOccurrenceDescription
918  };
919 
922  enum class Format
923  {
924  AP203,
925  AP214,
926  AP242,
927  };
928 
929  private:
931  STEP();
932  };
933 
935  class EXCHANGE_API PRC
936  {
937  public:
940  enum class BRepCompression
941  {
942  None,
943  Low,
944  Medium,
945  High
946  };
947 
948  private:
950  PRC();
951  };
952 
954  class EXCHANGE_API ProE
955  {
956  public:
959  enum class SessionColor
960  {
962  LastCreoVersion,
964  ExchangeDefault,
967  UserDefined
968  };
969 
972  enum class FamilyTable
973  {
975  BRepOnly,
977  BRepOrTessellation,
979  BRepOrTessellationOrGeneric
980  };
981 
985  {
987  On,
989  Off,
991  AsDatum,
992  };
993 
994  private:
996  ProE();
997  };
998 
1000  class EXCHANGE_API U3D
1001  {
1002  public:
1005  enum class Version
1006  {
1007  ECMA1,
1008  ECMA3
1009  };
1010 
1011  private:
1013  U3D();
1014  };
1015 
1017  class EXCHANGE_API Configuration : public HPS::Sprocket
1018  {
1019  public:
1021  Configuration();
1022 
1025  Configuration(char const * in_name);
1026 
1031  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1032 
1036  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1037 
1040  Configuration(Configuration const & in_configuration);
1041 
1045  Configuration(Configuration && in_that);
1046 
1050  Configuration & operator=(Configuration && in_that);
1051 
1052  virtual ~Configuration();
1053 
1054  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
1055 
1056 
1059  void Set(Configuration const & in_kit);
1060 
1063  void Show(Configuration & out_kit) const;
1064 
1068  Configuration & operator=(Configuration const & in_kit);
1069 
1072  bool Empty() const;
1073 
1077  bool Equals(Configuration const & in_kit) const;
1078 
1082  bool operator==(Configuration const & in_kit) const;
1083 
1087  bool operator!=(Configuration const & in_kit) const;
1088 
1089 
1092  HPS::UTF8 GetName() const;
1093 
1096  ConfigurationArray GetSubconfigurations() const;
1097  };
1098 
1100  class EXCHANGE_API File
1101  {
1102  public:
1105  enum class Format
1106  {
1107  Unsupported,
1108  ACIS,
1109  CADDS,
1110  CATIAV4,
1111  CATIAV5,
1112  CGR,
1113  COLLADA,
1114  CreoProE,
1115  IDEAS,
1116  IFC,
1117  IGES,
1118  Inventor,
1119  JT,
1120  KeyholeMarkupLanguage,
1121  LatticeXVL,
1122  OneSpaceDesigner,
1123  Parasolid,
1124  PDF,
1125  PRC,
1126  Rhino,
1127  NXUnigraphics,
1128  SolidEdge,
1129  SolidWorks,
1130  STEP,
1131  StereoLithography,
1132  ThreeDStudioMax,
1133  ThreeDXML,
1134  Universal3D,
1135  VDAFS,
1136  VRML,
1137  WavefrontObject,
1138  };
1139 
1141  static Format GetFormat(char const * in_file_name);
1142 
1146  static ConfigurationArray GetConfigurations(char const * in_file_name);
1147 
1159  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);
1160 
1166  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1167 
1174  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1175 
1182  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1183 
1191  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1192 
1199  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1200 
1201 
1208  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1209 
1214  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1215 
1220  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1221 
1226  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1227 
1232  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1233 
1239  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1240 
1246  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1247 
1254  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1255 
1262  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1263 
1267  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1268 
1273  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1274 
1278  static ExportNotifier ExportPRC(KeyPath const & in_source);
1279 
1284  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1285 
1290  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1291 
1296  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1297 
1301  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1302 
1307  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1308 
1309  private:
1311  File();
1312  };
1313 
1315  class EXCHANGE_API NURBSConversionOptionsKit : public HPS::Sprocket
1316  {
1317  public:
1320 
1324 
1329 
1333  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1334 
1335  virtual ~NURBSConversionOptionsKit();
1336 
1337  HPS::Type ObjectType() const { return HPS::Type::ExchangeNURBSConversionOptionsKit; }
1338 
1341  void Set(NURBSConversionOptionsKit const & in_kit);
1342 
1345  void Show(NURBSConversionOptionsKit & out_kit) const;
1346 
1350  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1351 
1354  bool Empty() const;
1355 
1359  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1360 
1364  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1365 
1369  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1370 
1374  static NURBSConversionOptionsKit GetDefault();
1375 
1380  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1381 
1386  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1387 
1392  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1393 
1398  NURBSConversionOptionsKit & SetClosedSurfaceSplitting(bool in_state);
1399 
1404  NURBSConversionOptionsKit & SetPeriodicSurfaceSplitting(bool in_state);
1405 
1410  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1411 
1416  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1417 
1423  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1424 
1431  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1432 
1438  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1439 
1446  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1447 
1448 
1451  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1452 
1455  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1456 
1459  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1460 
1463  NURBSConversionOptionsKit & UnsetClosedSurfaceSplitting();
1464 
1467  NURBSConversionOptionsKit & UnsetPeriodicSurfaceSplitting();
1468 
1471  NURBSConversionOptionsKit & UnsetParameterization();
1472 
1475  NURBSConversionOptionsKit & UnsetTolerance();
1476 
1479  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1480 
1483  NURBSConversionOptionsKit & UnsetAllowedCurves();
1484 
1487  NURBSConversionOptionsKit & UnsetEverything();
1488 
1489 
1490 
1494  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1495 
1499  bool Show3DCurvesComputation(bool & out_state) const;
1500 
1505  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1506 
1510  bool ShowClosedSurfaceSplitting(bool & out_state) const;
1511 
1515  bool ShowPeriodicSurfaceSplitting(bool & out_state) const;
1516 
1520  bool ShowParameterization(bool & out_state) const;
1521 
1525  bool ShowTolerance(double & out_tolerance) const;
1526 
1530  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1531 
1535  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1536  };
1537 
1539  class EXCHANGE_API ImportOptionsKit : public HPS::Sprocket
1540  {
1541  public:
1543  ImportOptionsKit();
1544 
1547  ImportOptionsKit(ImportOptionsKit const & in_kit);
1548 
1552  ImportOptionsKit(ImportOptionsKit && in_that);
1553 
1557  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1558 
1559  virtual ~ImportOptionsKit();
1560 
1561  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1562 
1566  static ImportOptionsKit GetDefault();
1567 
1570  void Set(ImportOptionsKit const & in_kit);
1571 
1574  void Show(ImportOptionsKit & out_kit) const;
1575 
1579  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1580 
1583  bool Empty() const;
1584 
1588  bool Equals(ImportOptionsKit const & in_kit) const;
1589 
1593  bool operator==(ImportOptionsKit const & in_kit) const;
1594 
1598  bool operator!=(ImportOptionsKit const & in_kit) const;
1599 
1600 
1606  ImportOptionsKit & SetBRepData(bool in_state);
1607 
1613  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1614 
1620  ImportOptionsKit & SetSolids(bool in_state);
1621 
1627  ImportOptionsKit & SetSurfaces(bool in_state);
1628 
1634  ImportOptionsKit & SetWireframes(bool in_state);
1635 
1641  ImportOptionsKit & SetPMI(bool in_state);
1642 
1649  ImportOptionsKit & SetAttributes(bool in_state);
1650 
1656  ImportOptionsKit & SetHiddenObjects(bool in_state);
1657 
1663  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1664 
1670  ImportOptionsKit & SetActiveFilter(bool in_state);
1671 
1677  ImportOptionsKit & SetDefaultUnits(Units in_units);
1678 
1684  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1685 
1692  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1693 
1699  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1700 
1706  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1707 
1712  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1713 
1721  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1722 
1728  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1729 
1735  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1736 
1743  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1744 
1752  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1753 
1759  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1760 
1766  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1767 
1773  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1774 
1779  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1780 
1787  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1788 
1794  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1795 
1804  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1805 
1814  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1815 
1821  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1822 
1827  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1828 
1833  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1834 
1840  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1841 
1846  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1847 
1853  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1854 
1861  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1862 
1869  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1870 
1878  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1879 
1886  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1887 
1893  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1894 
1900  ImportOptionsKit & SetProECodePageName(char const * in_name);
1901 
1907  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1908 
1914  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1915 
1921  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1922 
1929  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
1930 
1937  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
1938 
1945  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
1946 
1953  ImportOptionsKit & SetProEHomeView(bool in_state);
1954 
1961  ImportOptionsKit & SetProEExplodedViews(bool in_state);
1962 
1969  ImportOptionsKit & SetProEDatum(bool in_state);
1970 
1971 
1978  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
1979 
1986  ImportOptionsKit & SetProESkeletons(bool in_state);
1987 
1994  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
1995 
2001  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2002 
2008  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2009 
2015  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2016 
2022  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2023 
2029  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2030 
2036  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2037 
2044  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2045 
2051  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2052 
2058  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2059 
2066  ImportOptionsKit & SetIFCEdges(bool in_state);
2067 
2073  ImportOptionsKit & SetIFCMetadata(bool in_state);
2074 
2080  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2081 
2087  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2088 
2094  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2095 
2099  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2100 
2112  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2113 
2125  ImportOptionsKit & SetMode(ImportMode in_mode);
2126 
2136  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2137 
2145  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2146 
2153  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2154 
2158  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2159 
2163  ImportOptionsKit & UnsetBRepData();
2164 
2167  ImportOptionsKit & UnsetBRepMode();
2168 
2171  ImportOptionsKit & UnsetSolids();
2172 
2175  ImportOptionsKit & UnsetSurfaces();
2176 
2179  ImportOptionsKit & UnsetWireframes();
2180 
2183  ImportOptionsKit & UnsetPMI();
2184 
2187  ImportOptionsKit & UnsetAttributes();
2188 
2191  ImportOptionsKit & UnsetHiddenObjects();
2192 
2195  ImportOptionsKit & UnsetConstructionAndReferences();
2196 
2199  ImportOptionsKit & UnsetActiveFilter();
2200 
2203  ImportOptionsKit & UnsetSewingTolerance();
2204 
2207  ImportOptionsKit & UnsetDefaultUnits();
2208 
2211  ImportOptionsKit & UnsetPMISubstitutionFont();
2212 
2215  ImportOptionsKit & UnsetPMIPrecision();
2216 
2219  ImportOptionsKit & UnsetPMIDefaultUnits();
2220 
2223  ImportOptionsKit & UnsetPMIDefaultColor();
2224 
2227  ImportOptionsKit & UnsetTessellationLevel();
2228 
2231  ImportOptionsKit & UnsetTessellationAccuracy();
2232 
2235  ImportOptionsKit & UnsetTessellationCleanup();
2236 
2239  ImportOptionsKit & UnsetPMIFlipping();
2240 
2243  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2244 
2247  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2248 
2251  ImportOptionsKit & UnsetTextureDirectories();
2252 
2255  ImportOptionsKit & UnsetSearchDirectories();
2256 
2259  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2260 
2263  ImportOptionsKit & UnsetConfiguration();
2264 
2267  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2268 
2271  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2272 
2275  ImportOptionsKit & UnsetCatiaV5Cache();
2276 
2279  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2280 
2283  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2284 
2287  ImportOptionsKit & UnsetProECodePageName();
2288 
2291  ImportOptionsKit & UnsetProEDimensionTolerance();
2292 
2295  ImportOptionsKit & UnsetProESubpartPMI();
2296 
2299  ImportOptionsKit & UnsetProESessionColor();
2300 
2303  ImportOptionsKit & UnsetProEDatum();
2304 
2307  ImportOptionsKit & UnsetProEHomeView();
2308 
2311  ImportOptionsKit & UnsetProEExplodedViews();
2312 
2315  ImportOptionsKit & UnsetProEMissingBoolean();
2316 
2319  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2320 
2323  ImportOptionsKit & UnsetProEFamilyTreeSource();
2324 
2327  ImportOptionsKit & UnsetProEConstructionEntities();
2328 
2331  ImportOptionsKit & UnsetProESkeletons();
2332 
2335  ImportOptionsKit & UnsetSTEPNamePreference();
2336 
2339  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2340 
2343  ImportOptionsKit & UnsetSTEPCodePageName();
2344 
2347  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2348 
2351  ImportOptionsKit & UnsetSTEPOrientationHealing();
2352 
2355  ImportOptionsKit & UnsetSTEPValidationProperties();
2356 
2359  ImportOptionsKit & UnsetIFCCodePageName();
2360 
2363  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2364 
2367  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2368 
2371  ImportOptionsKit & UnsetIFCFaceOptimization();
2372 
2375  ImportOptionsKit & UnsetIFCEdges();
2376 
2379  ImportOptionsKit & UnsetIFCMetadata();
2380 
2383  ImportOptionsKit & UnsetPDF3DStreamIndex();
2384 
2387  ImportOptionsKit & UnsetJTTessellationLevel();
2388 
2391  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2392 
2395  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2396 
2399  ImportOptionsKit & UnsetLocation();
2400 
2403  ImportOptionsKit & UnsetMode();
2404 
2407  ImportOptionsKit & UnsetIncrementalComponentPaths();
2408 
2411  ImportOptionsKit & UnsetNURBSConversion();
2412 
2415  ImportOptionsKit & UnsetEverything();
2416 
2417 
2422  bool ShowBRepData(bool & out_state) const;
2423 
2427  bool ShowBRepMode(BRepMode & out_mode) const;
2428 
2432  bool ShowSolids(bool & out_state) const;
2433 
2437  bool ShowSurfaces(bool & out_state) const;
2438 
2442  bool ShowWireframes(bool & out_state) const;
2443 
2447  bool ShowPMI(bool & out_state) const;
2448 
2452  bool ShowAttributes(bool & out_state) const;
2453 
2457  bool ShowHiddenObjects(bool & out_state) const;
2458 
2462  bool ShowConstructionAndReferences(bool & out_state) const;
2463 
2467  bool ShowActiveFilter(bool & out_state) const;
2468 
2472  bool ShowSewingTolerance(double & out_tolerance) const;
2473 
2477  bool ShowDefaultUnits(Units & out_units) const;
2478 
2483  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2484 
2488  bool ShowPMIPrecision(size_t & out_precision) const;
2489 
2493  bool ShowPMIDefaultUnits(Units & out_units) const;
2494 
2499  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2500 
2508  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2509 
2514  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2515 
2519  bool ShowTessellationCleanup(bool & out_cleanup) const;
2520 
2524  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2525 
2529  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2530 
2534  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2535 
2539  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2540 
2546  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2547 
2551  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2552 
2556  bool ShowConfiguration(UTF8Array & out_configuration) const;
2557 
2561  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2562 
2566  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2567 
2572  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2573 
2578  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2579 
2583  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2584 
2588  bool ShowProECodePageName(UTF8 & out_name) const;
2589 
2593  bool ShowProEDimensionTolerance(bool & out_state) const;
2594 
2598  bool ShowProESubpartPMI(bool & out_state) const;
2599 
2603  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2604 
2608  bool ShowProEDatum(bool & out_state) const;
2609 
2613  bool ShowProEHomeView(bool & out_state) const;
2614 
2618  bool ShowProEExplodedViews(bool & out_state) const;
2619 
2623  bool ShowProEMissingBoolean(bool & out_state) const;
2624 
2628  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2629 
2633  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2634 
2638  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2639 
2643  bool ShowProESkeletons(bool & out_state) const;
2644 
2648  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2649 
2653  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2654 
2658  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2659 
2663  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2664 
2668  bool ShowSTEPOrientationHealing(bool & out_state) const;
2669 
2673  bool ShowSTEPValidationProperties(bool & out_state) const;
2674 
2678  bool ShowIFCCodePageName(UTF8 & out_name) const;
2679 
2683  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2684 
2688  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2689 
2693  bool ShowIFCFaceOptimization(bool & out_state) const;
2694 
2698  bool ShowIFCEdges(bool & out_state) const;
2699 
2703  bool ShowIFCMetadata(bool & out_state) const;
2704 
2708  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2709 
2713  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2714 
2718  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2719 
2723  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2724 
2729  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2730 
2734  bool ShowMode(ImportMode & out_mode) const;
2735 
2739  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2740 
2744  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2745  };
2746 
2748  class EXCHANGE_API Translation
2749  {
2750  public:
2753  enum class Healing
2754  {
2755  Off,
2756  On,
2757  OnlyIfNotParasolid,
2758  };
2759 
2762  enum class AccurateEdges
2763  {
2764  Off,
2765  On,
2766  OnlyIfNotParasolid,
2767  };
2768 
2771  enum class Simplification
2772  {
2773  Off,
2774  On,
2775  OnlyIfNotParasolid,
2776  };
2777 
2780  enum class Merging
2781  {
2782  Off,
2783  On,
2784  OnlyIfNotParasolid,
2785  };
2786 
2787  private:
2789  Translation();
2790  };
2791 
2793  class EXCHANGE_API TranslationOptionsKit : public HPS::Sprocket
2794  {
2795  public:
2798 
2802 
2807 
2811  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2812 
2813  virtual ~TranslationOptionsKit();
2814 
2815  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2816 
2820  static TranslationOptionsKit GetDefault();
2821 
2824  void Set(TranslationOptionsKit const & in_kit);
2825 
2828  void Show(TranslationOptionsKit & out_kit) const;
2829 
2833  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2834 
2837  bool Empty() const;
2838 
2842  bool Equals(TranslationOptionsKit const & in_kit) const;
2843 
2847  bool operator==(TranslationOptionsKit const & in_kit) const;
2848 
2852  bool operator!=(TranslationOptionsKit const & in_kit) const;
2853 
2859  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2860 
2866  TranslationOptionsKit & SetTessellation(bool in_state);
2867 
2873  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2874 
2878  TranslationOptionsKit & SetApplication(char const * in_name);
2879 
2883  TranslationOptionsKit & SetVersion(char const * in_version);
2884 
2888  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2889 
2893  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2894 
2898  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
2899 
2903  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
2904 
2909  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
2910 
2914  TranslationOptionsKit & SetDisjointFaces(bool in_state);
2915 
2918  TranslationOptionsKit & UnsetSolidsAsFaces();
2919 
2922  TranslationOptionsKit & UnsetTessellation();
2923 
2926  TranslationOptionsKit & UnsetHiddenObjects();
2927 
2930  TranslationOptionsKit & UnsetApplication();
2931 
2934  TranslationOptionsKit & UnsetVersion();
2935 
2938  TranslationOptionsKit & UnsetHealing();
2939 
2942  TranslationOptionsKit & UnsetAccurateEdges();
2943 
2946  TranslationOptionsKit & UnsetSimplification();
2947 
2950  TranslationOptionsKit & UnsetEntityMerging();
2951 
2954  TranslationOptionsKit & UnsetSewing();
2955 
2958  TranslationOptionsKit & UnsetDisjointFaces();
2959 
2962  TranslationOptionsKit & UnsetEverything();
2963 
2964 
2968  bool ShowSolidsAsFaces(bool & out_state) const;
2969 
2973  bool ShowTessellation(bool & out_state) const;
2974 
2978  bool ShowHiddenObjects(bool & out_state) const;
2979 
2983  bool ShowApplication(UTF8 & out_name) const;
2984 
2988  bool ShowVersion(UTF8 & out_version) const;
2989 
2993  bool ShowHealing(Translation::Healing & out_healing) const;
2994 
2998  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
2999 
3003  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3004 
3008  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3009 
3014  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3015 
3019  bool ShowDisjointFaces(bool & out_state) const;
3020  };
3021 
3022 
3023 
3028  class EXCHANGE_API ModelFileImportOptionsKit : public HPS::Sprocket
3029  {
3030  public:
3033 
3037 
3042 
3046  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3047 
3048  virtual ~ModelFileImportOptionsKit();
3049 
3050  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
3051 
3055  static ModelFileImportOptionsKit GetDefault();
3056 
3059  void Set(ModelFileImportOptionsKit const & in_kit);
3060 
3063  void Show(ModelFileImportOptionsKit & out_kit) const;
3064 
3068  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3069 
3072  bool Empty() const;
3073 
3077  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3078 
3082  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3083 
3087  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3088 
3089 
3090  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3091  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3092  * \return A reference to this ImportOptionsKit.
3093  */
3094  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3095 
3101  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3102 
3109  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3110 
3118  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3119 
3120  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3121  * \warning Setting this option to true will cause future exports to output without tessellation data.
3122  * \param in_cleanup Whether to clean up tessellation data from representation items.
3123  * \return A reference to this ImportOptionsKit.
3124  */
3125  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3126 
3132  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3133 
3139  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3140 
3147  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3148 
3152  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3153 
3166  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3167 
3173  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3174 
3178  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3179 
3180 
3183  ModelFileImportOptionsKit & UnsetTessellationLevel();
3184 
3187  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3188 
3191  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3192 
3195  ModelFileImportOptionsKit & UnsetPMIFlipping();
3196 
3199  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3200 
3203  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3204 
3207  ModelFileImportOptionsKit & UnsetIFCEdges();
3208 
3211  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3212 
3215  ModelFileImportOptionsKit & UnsetLocation();
3216 
3219  ModelFileImportOptionsKit & UnsetSewingTolerance();
3220 
3223  ModelFileImportOptionsKit & UnsetNURBSConversion();
3224 
3227  ModelFileImportOptionsKit & UnsetEverything();
3228 
3229 
3237  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3238 
3243  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3244 
3248  bool ShowTessellationCleanup(bool & out_cleanup) const;
3249 
3253  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3254 
3258  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3259 
3263  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3264 
3268  bool ShowIFCEdges(bool & out_state) const;
3269 
3273  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3274 
3279  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3280 
3284  bool ShowSewingTolerance(double & out_tolerance) const;
3285 
3289  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3290  };
3291 
3292 
3294  class EXCHANGE_API ExportACISOptionsKit : public HPS::Sprocket
3295  {
3296  public:
3299 
3303 
3307 
3308  virtual ~ExportACISOptionsKit();
3309 
3310  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
3311 
3315  static ExportACISOptionsKit GetDefault();
3316 
3319  void Set(ExportACISOptionsKit const & in_kit);
3320 
3323  void Show(ExportACISOptionsKit & out_kit) const;
3324 
3328  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3329 
3333  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3334 
3337  bool Empty() const;
3338 
3342  bool Equals(ExportACISOptionsKit const & in_kit) const;
3343 
3347  bool operator==(ExportACISOptionsKit const & in_kit) const;
3348 
3352  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3353 
3354 
3360  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3361 
3367  ExportACISOptionsKit & SetBinary(bool in_state);
3368 
3369 
3372  ExportACISOptionsKit & UnsetMillimeterUnits();
3373 
3376  ExportACISOptionsKit & UnsetBinary();
3377 
3380  ExportACISOptionsKit & UnsetEverything();
3381 
3382 
3386  bool ShowMillimeterUnits(bool & out_state) const;
3387 
3391  bool ShowBinary(bool & out_state) const;
3392  };
3393 
3395  class EXCHANGE_API ExportIGESOptionsKit : public HPS::Sprocket
3396  {
3397  public:
3400 
3404 
3408 
3409  virtual ~ExportIGESOptionsKit();
3410 
3411  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
3412 
3416  static ExportIGESOptionsKit GetDefault();
3417 
3420  void Set(ExportIGESOptionsKit const & in_kit);
3421 
3424  void Show(ExportIGESOptionsKit & out_kit) const;
3425 
3429  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
3430 
3434  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
3435 
3438  bool Empty() const;
3439 
3443  bool Equals(ExportIGESOptionsKit const & in_kit) const;
3444 
3448  bool operator==(ExportIGESOptionsKit const & in_kit) const;
3449 
3453  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
3454 
3455 
3461  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3462 
3468  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
3469 
3475  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
3476 
3482  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
3483 
3489  ExportIGESOptionsKit & SetTessellation(bool in_state);
3490 
3494  ExportIGESOptionsKit & SetApplication(char const * in_name);
3495 
3499  ExportIGESOptionsKit & SetVersion(char const * in_version);
3500 
3501 
3504  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
3505 
3508  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
3509 
3512  ExportIGESOptionsKit & UnsetSolidsAsFaces();
3513 
3516  ExportIGESOptionsKit & UnsetHiddenObjects();
3517 
3520  ExportIGESOptionsKit & UnsetTessellation();
3521 
3524  ExportIGESOptionsKit & UnsetApplication();
3525 
3528  ExportIGESOptionsKit & UnsetVersion();
3529 
3532  ExportIGESOptionsKit & UnsetEverything();
3533 
3534 
3538  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3539 
3543  bool ShowFacetedAsWireframe(bool & out_state) const;
3544 
3548  bool ShowSolidsAsFaces(bool & out_state) const;
3549 
3553  bool ShowHiddenObjects(bool & out_state) const;
3554 
3558  bool ShowTessellation(bool & out_state) const;
3559 
3563  bool ShowApplication(UTF8 & out_name) const;
3564 
3568  bool ShowVersion(UTF8 & out_version) const;
3569  };
3570 
3572  class EXCHANGE_API ExportJTOptionsKit : public HPS::Sprocket
3573  {
3574  public:
3577 
3580  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3581 
3585 
3586  virtual ~ExportJTOptionsKit();
3587 
3588  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
3589 
3593  static ExportJTOptionsKit GetDefault();
3594 
3597  void Set(ExportJTOptionsKit const & in_kit);
3598 
3601  void Show(ExportJTOptionsKit & out_kit) const;
3602 
3606  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3607 
3611  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3612 
3615  bool Empty() const;
3616 
3620  bool Equals(ExportJTOptionsKit const & in_kit) const;
3621 
3625  bool operator==(ExportJTOptionsKit const & in_kit) const;
3626 
3630  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3631 
3632 
3638  ExportJTOptionsKit & SetContent(JT::Content in_content);
3639 
3645  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3646 
3652  ExportJTOptionsKit & SetPMI(bool in_state);
3653 
3654 
3657  ExportJTOptionsKit & UnsetContent();
3658 
3661  ExportJTOptionsKit & UnsetHiddenObjects();
3662 
3665  ExportJTOptionsKit & UnsetPMI();
3666 
3669  ExportJTOptionsKit & UnsetEverything();
3670 
3671 
3675  bool ShowContent(JT::Content & out_content) const;
3676 
3680  bool ShowHiddenObjects(bool & out_state) const;
3681 
3685  bool ShowPMI(bool & out_state) const;
3686  };
3687 
3689  class EXCHANGE_API ExportParasolidOptionsKit : public HPS::Sprocket
3690  {
3691  public:
3694 
3698 
3702 
3703  virtual ~ExportParasolidOptionsKit();
3704 
3705  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
3706 
3710  static ExportParasolidOptionsKit GetDefault();
3711 
3714  void Set(ExportParasolidOptionsKit const & in_kit);
3715 
3718  void Show(ExportParasolidOptionsKit & out_kit) const;
3719 
3723  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
3724 
3728  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
3729 
3732  bool Empty() const;
3733 
3737  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
3738 
3742  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
3743 
3747  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
3748 
3749 
3755  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
3756 
3762  ExportParasolidOptionsKit & SetTessellation(bool in_state);
3763 
3769  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
3770 
3774  ExportParasolidOptionsKit & SetApplication(char const * in_name);
3775 
3779  ExportParasolidOptionsKit & SetVersion(char const * in_version);
3780 
3781 
3784  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
3785 
3788  ExportParasolidOptionsKit & UnsetTessellation();
3789 
3792  ExportParasolidOptionsKit & UnsetHiddenObjects();
3793 
3796  ExportParasolidOptionsKit & UnsetApplication();
3797 
3800  ExportParasolidOptionsKit & UnsetVersion();
3801 
3804  ExportParasolidOptionsKit & UnsetEverything();
3805 
3806 
3810  bool ShowSolidsAsFaces(bool & out_state) const;
3811 
3815  bool ShowTessellation(bool & out_state) const;
3816 
3820  bool ShowHiddenObjects(bool & out_state) const;
3821 
3825  bool ShowApplication(UTF8 & out_name) const;
3826 
3830  bool ShowVersion(UTF8 & out_version) const;
3831  };
3832 
3834  class EXCHANGE_API ExportPRCOptionsKit : public HPS::Sprocket
3835  {
3836  public:
3839 
3842  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3843 
3847 
3848  virtual ~ExportPRCOptionsKit();
3849 
3850  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
3851 
3855  static ExportPRCOptionsKit GetDefault();
3856 
3859  void Set(ExportPRCOptionsKit const & in_kit);
3860 
3863  void Show(ExportPRCOptionsKit & out_kit) const;
3864 
3868  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
3869 
3873  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
3874 
3877  bool Empty() const;
3878 
3882  bool Equals(ExportPRCOptionsKit const & in_kit) const;
3883 
3887  bool operator==(ExportPRCOptionsKit const & in_kit) const;
3888 
3892  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
3893 
3894 
3900  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
3901 
3908  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
3909 
3915  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
3916 
3922  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
3923 
3928  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3929 
3935  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
3936 
3937 
3940  ExportPRCOptionsKit & UnsetTessellationCompression();
3941 
3944  ExportPRCOptionsKit & UnsetBRepCompression();
3945 
3948  ExportPRCOptionsKit & UnsetBRepRemoval();
3949 
3952  ExportPRCOptionsKit & UnsetAttributeRemoval();
3953 
3956  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
3957 
3960  ExportPRCOptionsKit & UnsetEverything();
3961 
3962 
3966  bool ShowTessellationCompression(bool & out_state) const;
3967 
3971  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
3972 
3976  bool ShowBRepRemoval(bool & out_state) const;
3977 
3981  bool ShowAttributeRemoval(bool & out_state) const;
3982 
3986  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3987  };
3988 
3990  class EXCHANGE_API ExportSTEPOptionsKit : public HPS::Sprocket
3991  {
3992  public:
3995 
3999 
4003 
4004  virtual ~ExportSTEPOptionsKit();
4005 
4006  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
4007 
4011  static ExportSTEPOptionsKit GetDefault();
4012 
4015  void Set(ExportSTEPOptionsKit const & in_kit);
4016 
4019  void Show(ExportSTEPOptionsKit & out_kit) const;
4020 
4024  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4025 
4029  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4030 
4033  bool Empty() const;
4034 
4038  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4039 
4043  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4044 
4048  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4049 
4050 
4056  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4057 
4063  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4064 
4070  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4071 
4077  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4078 
4082  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4083 
4087  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4088 
4092  ExportSTEPOptionsKit & SetPMI(bool in_state);
4093 
4097  ExportSTEPOptionsKit & SetCurves(bool in_state);
4098 
4102  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4103 
4104 
4107  ExportSTEPOptionsKit & UnsetFormat();
4108 
4111  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
4112 
4115  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
4116 
4119  ExportSTEPOptionsKit & UnsetNameShortening();
4120 
4123  ExportSTEPOptionsKit & UnsetApplication();
4124 
4127  ExportSTEPOptionsKit & UnsetVersion();
4128 
4131  ExportSTEPOptionsKit & UnsetPMI();
4132 
4135  ExportSTEPOptionsKit & UnsetCurves();
4136 
4139  ExportSTEPOptionsKit & UnsetAttributes();
4140 
4143  ExportSTEPOptionsKit & UnsetEverything();
4144 
4145 
4149  bool ShowFormat(STEP::Format & out_format) const;
4150 
4154  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4155 
4159  bool ShowFacetedAsWireframe(bool & out_state) const;
4160 
4164  bool ShowNameShortening(bool & out_state) const;
4165 
4169  bool ShowApplication(UTF8 & out_name) const;
4170 
4174  bool ShowVersion(UTF8 & out_version) const;
4175 
4179  bool ShowPMI(bool & out_state) const;
4180 
4184  bool ShowCurves(bool & out_state) const;
4185 
4189  bool ShowAttributes(bool & out_state) const;
4190  };
4191 
4193  class EXCHANGE_API ExportSTLOptionsKit : public HPS::Sprocket
4194  {
4195  public:
4198 
4201  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4202 
4206 
4207  virtual ~ExportSTLOptionsKit();
4208 
4209  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
4210 
4214  static ExportSTLOptionsKit GetDefault();
4215 
4218  void Set(ExportSTLOptionsKit const & in_kit);
4219 
4222  void Show(ExportSTLOptionsKit & out_kit) const;
4223 
4227  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4228 
4232  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4233 
4236  bool Empty() const;
4237 
4241  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4242 
4246  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4247 
4251  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4252 
4253 
4259  ExportSTLOptionsKit & SetBinary(bool in_state);
4260 
4266  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4267 
4274  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4275 
4281  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4282 
4288  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4289 
4296  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4297 
4298 
4301  ExportSTLOptionsKit & UnsetBinary();
4302 
4305  ExportSTLOptionsKit & UnsetTessellationLevel();
4306 
4309  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4310 
4313  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4314 
4317  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4318 
4321  ExportSTLOptionsKit & UnsetEverything();
4322 
4323 
4327  bool ShowBinary(bool & out_state) const;
4328 
4336  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4337 
4341  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4342 
4346  bool ShowCurrentTessellationRetention(bool & out_state) const;
4347 
4351  bool ShowMaximumEdgeLength(double & out_length) const;
4352  };
4353 
4355  class EXCHANGE_API ExportU3DOptionsKit : public HPS::Sprocket
4356  {
4357  public:
4360 
4363  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4364 
4368 
4369  virtual ~ExportU3DOptionsKit();
4370 
4371  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
4372 
4376  static ExportU3DOptionsKit GetDefault();
4377 
4380  void Set(ExportU3DOptionsKit const & in_kit);
4381 
4384  void Show(ExportU3DOptionsKit & out_kit) const;
4385 
4389  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4390 
4394  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4395 
4398  bool Empty() const;
4399 
4403  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4404 
4408  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4409 
4413  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4414 
4415 
4421  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4422 
4427  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4428 
4429 
4432  ExportU3DOptionsKit & UnsetVersion();
4433 
4436  ExportU3DOptionsKit & UnsetCompression();
4437 
4440  ExportU3DOptionsKit & UnsetEverything();
4441 
4442 
4446  bool ShowVersion(U3D::Version & out_version) const;
4447 
4451  bool ShowCompression(unsigned char & out_level) const;
4452  };
4453 
4455  class EXCHANGE_API ExportXMLOptionsKit : public HPS::Sprocket
4456  {
4457  public:
4460 
4463  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4464 
4468 
4469  virtual ~ExportXMLOptionsKit();
4470 
4471  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
4472 
4476  static ExportXMLOptionsKit GetDefault();
4477 
4480  void Set(ExportXMLOptionsKit const & in_kit);
4481 
4484  void Show(ExportXMLOptionsKit & out_kit) const;
4485 
4489  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4490 
4494  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4495 
4498  bool Empty() const;
4499 
4503  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4504 
4508  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4509 
4513  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4514 
4515 
4521  ExportXMLOptionsKit & SetMetadata(bool in_state);
4522 
4528  ExportXMLOptionsKit & SetTransformations(bool in_state);
4529 
4535  ExportXMLOptionsKit & SetMaterials(bool in_state);
4536 
4537 
4540  ExportXMLOptionsKit & UnsetMetadata();
4541 
4544  ExportXMLOptionsKit & UnsetTransformations();
4545 
4548  ExportXMLOptionsKit & UnsetMaterials();
4549 
4552  ExportXMLOptionsKit & UnsetEverything();
4553 
4554 
4558  bool ShowMetadata(bool & out_state) const;
4559 
4563  bool ShowTransformations(bool & out_state) const;
4564 
4568  bool ShowMaterials(bool & out_state) const;
4569  };
4570 
4572  class EXCHANGE_API TessellationOptionsKit : public HPS::Sprocket
4573  {
4574  public:
4577 
4581 
4585 
4586  virtual ~TessellationOptionsKit();
4587 
4588  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
4589 
4593  static TessellationOptionsKit GetDefault();
4594 
4597  void Set(TessellationOptionsKit const & in_kit);
4598 
4601  void Show(TessellationOptionsKit & out_kit) const;
4602 
4606  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4607 
4611  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
4612 
4615  bool Empty() const;
4616 
4620  bool Equals(TessellationOptionsKit const & in_kit) const;
4621 
4625  bool operator==(TessellationOptionsKit const & in_kit) const;
4626 
4630  bool operator!=(TessellationOptionsKit const & in_kit) const;
4631 
4632 
4636  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
4637 
4644  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4645 
4651  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
4652 
4656  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
4657 
4661  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4662 
4663 
4666  TessellationOptionsKit & UnsetLevel();
4667 
4670  TessellationOptionsKit & UnsetAccuracy();
4671 
4674  TessellationOptionsKit & UnsetUVPointPreservation();
4675 
4678  TessellationOptionsKit & UnsetMaximumEdgeLength();
4679 
4682  TessellationOptionsKit & UnsetEverything();
4683 
4684 
4692  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4693 
4698  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
4699 
4703  bool ShowUVPointPreservation(bool & out_state) const;
4704 
4708  bool ShowMaximumEdgeLength(double & out_length) const;
4709  };
4710 
4716  class EXCHANGE_API CommonMeasurementOperator : public Operator
4717  {
4718  public:
4719  enum class Tags
4720  {
4721  Name = 0,
4722  MeasurementType,
4723  Radius,
4724  Inverted,
4725  VectorX,
4726  VectorY,
4727  VectorZ,
4728  };
4729 
4731 
4732  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4733 
4735  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
4736 
4737  virtual void OnViewAttached() OVERRIDE;
4738  virtual void OnViewDetached() OVERRIDE;
4739 
4740  Exchange::CADModel GetCADModel() const;
4741  void SetCADModel(Exchange::CADModel const & in_cad_model);
4742 
4744  size_t GetPrecision() const;
4745 
4748  void SetPrecision(size_t in_precision);
4749 
4751  MaterialMappingKit GetMaterial() const;
4752 
4755  void SetMaterial(MaterialMappingKit const & in_material_mapping);
4756 
4758  TextAttributeKit GetTextAttributes() const;
4759 
4762  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
4763 
4765  SegmentKey GetMeasurementSegment() const;
4766 
4768  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
4769 
4770  /* Deletes all measurements */
4771  void DeleteMeasurements();
4772 
4773  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
4774  {
4775  public:
4778  {
4779  channel = GetClassID();
4780  consumable = false;
4781  }
4782 
4783  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
4784  {
4785  channel = GetClassID();
4786  consumable = false;
4787  measurement_key = in_measurement_key;
4788  view = in_view;
4789  }
4790 
4793  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
4794  {
4795  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
4796  {
4797  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
4798  measurement_key = that.measurement_key;
4799  view = that.view;
4800  }
4801  else
4802  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4803  }
4804 
4806 
4809  Event * Clone() const
4810  {
4811  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
4812  return new_event;
4813  }
4814 
4815  Key measurement_key;
4816  View view;
4817  };
4818 
4819  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
4820  {
4821  public:
4824  {
4825  channel = GetClassID();
4826  consumable = false;
4827  }
4828 
4829  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
4830  {
4831  channel = GetClassID();
4832  consumable = false;
4833  measurement_name = in_measurement_name;
4834  view = in_view;
4835  }
4836 
4839  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
4840  {
4841  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
4842  {
4843  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
4844  measurement_name = that.measurement_name;
4845  view = that.view;
4846  }
4847  else
4848  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4849  }
4850 
4852 
4855  Event * Clone() const
4856  {
4857  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
4858  return new_event;
4859  }
4860 
4861  UTF8 measurement_name;
4862  View view;
4863  };
4864 
4865  protected:
4866  Exchange::CADModel cad_model;
4867  size_t measurement_precision;
4868  UTF8 units;
4869  MaterialMappingKit materials;
4870  TextAttributeKit text_attributes;
4871  SegmentKey measurement_segment;
4872  GlyphDefinition left_arrow;
4873  GlyphDefinition right_arrow;
4874  SelectionOptionsKit selection_options;
4875  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
4876  Vector camera_direction;
4877  PortfolioKey portfolio;
4878  SegmentKey style_segment;
4879  HighlightOptionsKit highlight_options;
4880 
4881  static size_t length_measurement_index;
4882  static size_t radius_measurement_index;
4883  static size_t distance_measurement_index;
4884  static size_t angle_measurement_index;
4885 
4886  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
4887  void GetUnits();
4888  void SetGlyphColor();
4889  void GetCameraDirection();
4890  void SetupConstructionSegment();
4891  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
4892  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
4893  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
4894  float GetModelScale(Exchange::Component const & component);
4895  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
4896  };
4897 
4950  {
4951  public:
4952  enum class MeasurementType
4953  {
4954  PointToPoint,
4955  EdgeAndRadius,
4956  FeatureToFeature,
4957  FaceAngle,
4958  };
4959 
4961 
4962  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4963 
4965  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
4966 
4967  virtual void OnViewAttached() OVERRIDE;
4968  virtual void OnViewDetached() OVERRIDE;
4969 
4974  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
4975 
4979  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
4980 
4988  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
4989 
4993  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
4994 
4995  /* Sets the type of measurement to insert.
4996  * \param in_measurement_type The type of measurement to insert.*/
4997  void SetMeasurementType(MeasurementType in_measurement_type);
4998 
5001  MeasurementType GetMeasurementType();
5002 
5003  /* Whether measurable geometry should be highlighted when mousing over it
5004  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
5005  void SetMouseOverHighlighting(bool in_highlighting);
5006 
5007  /* Whether measurable geometry should be highlighted when mousing over it
5008  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
5009  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
5010  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5011 
5012  /* Whether measurable geometry is highlighted when mousing over it
5013  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
5014  bool GetMouseOverHighlighting();
5015 
5016  /* Returns the highlight option kit currently used for mouse over highlighting.
5017  * \return the highlight option kit currently used for mouse over highlighting. */
5018  HighlightOptionsKit GetHighlightOptions();
5019 
5020  /* Whether a measurement is currently being inserted or edited.
5021  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
5022  bool IsMeasurementActive();
5023 
5024  private:
5025  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5026  {
5027  Circle,
5028  Line,
5029  Generic,
5030  };
5031 
5032  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5033  {
5034  public:
5035  Surface();
5036 
5037  enum class SurfaceType
5038  {
5039  Plane,
5040  ConeOrCylinder,
5041  Unsupported,
5042  };
5043 
5044  SurfaceType surface_type; //the type of surface being measured
5045  Point center; //the center point of the surface
5046  Vector normal; //the center line of surfaces of type Cylinder or Cone
5047  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5048  ComponentPath path; //the component path to this surface
5049  };
5050 
5051  //bookkeeping
5052  MeasurementType measurement_type; //the type of measurement to be inserted
5053  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5054  TouchID tracked_touch_id;
5055  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5056  bool operator_active; //whether a measurement is in progress
5057  bool end_measurement; //whether we should end the current measurement
5058  CanvasArray canvases; //canvases related to the view where this operator is attached
5059 
5060  //measurement anchors
5061  size_t anchors; //valid for point-to-point and face-angle measurements
5062  bool anchors_in_place; //true if all the anchors have been placed
5063  Point first_click_position; //position of the first anchor
5064  Point second_click_position; //position of the second anchor
5065 
5066  //geometry for linear measurements
5067  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5068  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5069  LineKey distance_line; //a line representing the distance measured
5070  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5071  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5072  Point distance_point_one; //intersection of leader_line_one and distance_line
5073  Point distance_point_two; //intersection of leader_line_two and distance_line
5074  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5075  TextKey text; //text representing the measurement and units
5076  UTF8 text_string; //the contents of the text
5077  Vector measurement_direction; //the direction of the measurement
5078  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5079  Vector explicit_direction; //used if use_explicit_direction is true
5080 
5081  //geometry for radius measurement
5082  MarkerKey center_marker; //marker representing the center of the circle
5083  Point circle_center; //circle center
5084  float radius; //circle radius
5085 
5086  //edge specific data
5087  LineKey edge_line; //the edge being measured
5088  double edge_length; //length of the measured edge
5089  EdgeType edge_type; //the type of edge being measured
5090 
5091  //feature-to-feature specific data
5092  Surface surface_one; //data related to first selected surface
5093  Surface surface_two; //data related to second selected surface
5094  Plane measurement_plane; //the measurement plane
5095  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5096 
5097  //angle specific data
5098  Vector leader_line_one_direction; //the direction of the first leader line
5099  Vector leader_line_two_direction; //the direction of the second leader line
5100  Vector first_face_normal; //the normal of the first selected face
5101  Vector second_face_normal; //the normal of the second selected face
5102  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'
5103  CircularArcKey measurement_arc; //an arc representing the measured angle
5104  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5105  Vector mid_point_direction;
5106 
5107  //selection kits
5108  SelectionOptionsKit point_to_point_selection;
5109  SelectionOptionsKit edge_radius_selection;
5110  SelectionOptionsKit feature_to_feature_selection;
5111  SelectionOptionsKit angle_selection;
5112 
5113  //highlighting
5114  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5115  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5116  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5117  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5118  KeyPath highlighted_path; //highlighted_path
5119  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5120  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5121 
5122  //input handling
5123  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5124  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5125  bool InputUp(WindowKey & in_window);
5126  void ResetMeasurement();
5127 
5128  //inserting measurements
5129  void InsertPointToPointMeasurement(Point const & in_world_point);
5130  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5131  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5132  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5133  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5134  void InvertMeasuredAngle(WindowKey & in_window);
5135  void AdjustLineToCursor(Point const & cursor_position);
5136 
5137  //saving measurements
5138  void TagMeasurement();
5139  void TagPointToPointMeasurement();
5140  void TagEdgeMeasurement();
5141  void TagRadiusMeasurement();
5142  void TagGenericEdgeMeasurement();
5143  void TagFeatureToFeatureMeasurement();
5144  void TagAngleMeasurement();
5145 
5146  //restoring measurements
5147  void RestoreMeasurement(SegmentKey const & measurement_segment);
5148  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5149  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5150  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5151  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5152  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5153  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5154  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5155 
5156  //topology functions
5157  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5158  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5159  void PlaneToCenterLineDistance();
5160  void PlaneToPlaneDistance();
5161  void LineToLineDistance();
5162  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);
5163  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5164  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5165  bool IsPlane(Exchange::Component const & face_component);
5166  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5167  };
5168 
5169 private:
5171  Exchange();
5172 };
5173 
5174 }
5175 
5176 #endif
Definition: hps.h:6171
Definition: sprk_exchange.h:3834
Level
Definition: sprk_exchange.h:832
ConstructionEntities
Definition: sprk_exchange.h:984
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3588
Definition: sprk_exchange.h:43
Definition: sprk_exchange.h:935
Definition: sprk.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:269
Definition: sprk_exchange.h:1100
Definition: sprk_exchange.h:4716
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5680
Units
Definition: sprk_exchange.h:62
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2771
Definition: sprk.h:100
Definition: sprk_exchange.h:583
Version
Definition: sprk_exchange.h:1005
Definition: sprk_exchange.h:3028
Definition: sprk_exchange.h:842
Definition: sprk_exchange.h:682
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4735
HPS::Type ObjectType() const
Definition: sprk_exchange.h:664
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4471
SurfaceType
Definition: sprk_exchange.h:764
Definition: hps.h:1663
Format
Definition: sprk_exchange.h:922
HPS::Type ObjectType() const
Definition: sprk_exchange.h:710
Definition: sprk_exchange.h:4455
Definition: hps.h:44747
Format
Definition: sprk_exchange.h:1105
Definition: hps.h:7680
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3850
Type
Definition: sprk_exchange.h:823
Definition: hps.h:15670
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3411
Definition: sprk_exchange.h:446
Definition: sprk_exchange.h:530
Definition: sprk_exchange.h:296
HPS::Type ObjectType() const
Definition: sprk_exchange.h:427
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4965
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3705
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:4793
HPS::Type ObjectType() const
Definition: sprk_exchange.h:131
Definition: sprk_exchange.h:1315
Definition: sprk_exchange.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4209
HPS::Type ObjectType() const
Definition: sprk_exchange.h:322
Definition: sprk_exchange.h:3572
Merging
Definition: sprk_exchange.h:2780
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2815
Field
Definition: sprk_exchange.h:912
Definition: hps.h:39051
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1054
Definition: sprk_exchange.h:3294
Definition: sprk_exchange.h:2793
Limit
Definition: sprk_exchange.h:847
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4006
TessellationLevel
Definition: sprk_exchange.h:894
Definition: sprk_exchange.h:818
Definition: sprk_exchange.h:4193
Definition: sprk_exchange.h:110
Definition: sprk_exchange.h:907
Definition: hps.h:4334
Definition: hps.h:7053
Definition: hps.h:44138
Definition: sprk_exchange.h:401
UnloadMode
Definition: sprk_exchange.h:79
Definition: hps.h:40980
Definition: hps.h:44534
AnnotationCaptureFitting
Definition: sprk_exchange.h:811
Definition: sprk_exchange.h:4355
Definition: sprk_exchange.h:880
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3310
Definition: hps.h:15084
Event * Clone() const
Definition: sprk_exchange.h:4855
intptr_t GetChannel() const
Definition: hps.h:6304
Definition: sprk_exchange.h:1000
SessionColor
Definition: sprk_exchange.h:959
Definition: sprk.h:1636
Definition: hps.h:44857
LoadStatus
Definition: sprk_exchange.h:94
Definition: hps.h:41960
Definition: hps.h:43803
CurveType
Definition: sprk_exchange.h:787
Definition: sprk_exchange.h:490
Definition: hps.h:6271
Definition: hps.h:13390
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4588
Definition: sprk_exchange.h:4949
Definition: sprk.h:445
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1561
BRepCompression
Definition: sprk_exchange.h:940
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:737
Definition: sprk.h:1902
ComponentType
Definition: sprk.h:1641
Accuracy
Definition: sprk_exchange.h:864
Definition: sprk_exchange.h:3395
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1337
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:4839
Definition: sprk.h:2213
FamilyTable
Definition: sprk_exchange.h:972
Content
Definition: sprk_exchange.h:885
Definition: sprk_exchange.h:1539
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3050
HPS::Type ObjectType() const
Definition: sprk_exchange.h:611
Definition: sprk.h:2312
static MouseButtons ButtonLeft()
Definition: hps.h:44256
Definition: hps.h:7599
Definition: sprk_exchange.h:954
AccurateEdges
Definition: sprk_exchange.h:2762
Event * Clone() const
Definition: sprk_exchange.h:4809
HPS::Type ObjectType() const
Definition: sprk_exchange.h:472
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4371
Definition: hps.h:9179
HPS::Type ObjectType() const
Definition: sprk_exchange.h:204
Definition: sprk_exchange.h:636
Definition: hps.h:23017
Healing
Definition: sprk_exchange.h:2753
Definition: sprk.h:2398
Definition: hps.h:29247
ImportMode
Definition: sprk_exchange.h:752
Definition: sprk_exchange.h:1017
Definition: hps.h:515
Definition: sprk.h:1065
Definition: sprk_exchange.h:2748
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:3689
Definition: sprk_exchange.h:172
Definition: hps.h:38548
Definition: sprk_exchange.h:4572
HPS::Type ObjectType() const
Definition: sprk_exchange.h:558
Definition: hps.h:39645
Definition: sprk_exchange.h:3990