API Search || Global Search
sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
437 
442  void Tessellate(TessellationOptionsKit const & in_options);
443 
450  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
451  };
452 
455  class EXCHANGE_API Capture : public HPS::Capture
456  {
457  public:
459  Capture();
460 
464  Capture(Component const & in_that);
465 
469  Capture(HPS::Capture const & in_that);
470 
473  Capture(Exchange::Capture const & in_that);
474 
477  Capture(Exchange::Capture && in_that);
478 
479  virtual ~Capture();
480 
481  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
482  HPS::Type ObjectType() const { return staticType; }
483 
484 #if !defined(_MSC_VER) || _MSC_VER >= 1900
485  Capture & operator=(Exchange::Capture const & in_that) = default;
486 #endif
487 
491  Capture & operator=(Exchange::Capture && in_that);
492 
493 
496  A3DEntity * GetExchangeEntity() const;
497  };
498 
501  class EXCHANGE_API Filter : public HPS::Filter
502  {
503  public:
505  Filter();
506 
510  Filter(Component const & in_that);
511 
515  Filter(HPS::Filter const & in_that);
516 
519  Filter(Exchange::Filter const & in_that);
520 
523  Filter(Exchange::Filter && in_that);
524 
525  virtual ~Filter();
526 
527  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
528  HPS::Type ObjectType() const { return staticType; }
529 
530 #if !defined(_MSC_VER) || _MSC_VER >= 1900
531  Filter & operator=(Exchange::Filter const & in_that) = default;
532 #endif
533 
537  Filter & operator=(Exchange::Filter && in_that);
538 
539 
542  A3DEntity * GetExchangeEntity() const;
543  };
544 
546  class EXCHANGE_API Factory : public Sprocket
547  {
548  public:
553  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
554 
560  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
561 
565  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
566 
573  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
574 
578  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
579 
584  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
585 
586  private:
588  Factory();
589  };
590 
592  class EXCHANGE_API ImportNotifier : public IONotifier
593  {
594  public:
596  ImportNotifier();
597 
600  ImportNotifier(ImportNotifier const & in_that);
601 
606  ImportNotifier(IONotifier const & in_that);
607 
611  ImportNotifier(ImportNotifier && in_that);
612 
616  ImportNotifier & operator=(ImportNotifier && in_that);
617 
618  virtual ~ImportNotifier();
619 
620  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
621  HPS::Type ObjectType() const { return staticType; };
622 
626  ImportNotifier & operator=(ImportNotifier const & in_that);
627 
630  void Assign(ImportNotifier const & in_that);
631 
634  Exchange::CADModel GetCADModel() const;
635 
641  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
642 
645  Time GetImportTime() const;
646 
649  Time GetParseTime() const;
650  };
651 
653  class EXCHANGE_API TranslationNotifier : public IONotifier
654  {
655  public:
658 
661  TranslationNotifier(TranslationNotifier const & in_that);
662 
667  TranslationNotifier(IONotifier const & in_that);
668 
673 
677  TranslationNotifier & operator=(TranslationNotifier && in_that);
678 
679  virtual ~TranslationNotifier();
680 
681  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
682  HPS::Type ObjectType() const { return staticType; };
683 
687  TranslationNotifier & operator=(TranslationNotifier const & in_that);
688 
691  void Assign(TranslationNotifier const & in_that);
692 
695  Exchange::ParasolidEntityArray GetParasolidParts() const;
696 
699  HPS::Time GetImportTime() const;
700 
703  HPS::Time GetTranslationTime() const;
704  };
705 
707  class EXCHANGE_API ExportNotifier : public IONotifier
708  {
709  public:
711  ExportNotifier();
712 
715  ExportNotifier(ExportNotifier const & in_that);
716 
721  ExportNotifier(IONotifier const & in_that);
722 
726  ExportNotifier(ExportNotifier && in_that);
727 
731  ExportNotifier & operator=(ExportNotifier && in_that);
732 
733  virtual ~ExportNotifier();
734 
735  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
736  HPS::Type ObjectType() const { return staticType; };
737 
741  ExportNotifier & operator=(ExportNotifier const & in_that);
742 
745  void Assign(ExportNotifier const & in_that);
746 
750  A3DAsmModelFile * GetModelFile() const;
751  };
752 
754  class EXCHANGE_API ReloadNotifier : public IONotifier
755  {
756  public:
758  ReloadNotifier();
759 
762  ReloadNotifier(ReloadNotifier const & in_that);
763 
768  ReloadNotifier(IONotifier const & in_that);
769 
773  ReloadNotifier(ReloadNotifier && in_that);
774 
778  ReloadNotifier & operator=(ReloadNotifier && in_that);
779 
780  virtual ~ReloadNotifier();
781 
782  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
783  HPS::Type ObjectType() const { return staticType; };
784 
788  ReloadNotifier & operator=(ReloadNotifier const & in_that);
789 
792  void Assign(ReloadNotifier const & in_that);
793  };
794 
795 
796  class ImportOptionsKit;
797  class ModelFileImportOptionsKit;
798 
799 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
800  class Export3MFOptionsKit;
801  class ExportACISOptionsKit;
802  class ExportJTOptionsKit;
803  class ExportPRCOptionsKit;
804  class ExportSTLOptionsKit;
805  class ExportU3DOptionsKit;
806  class ExportXMLOptionsKit;
807 #endif
808 
809 #if !defined(TARGET_OS_ANDROID)
810  class ExportSTEPOptionsKit;
811  class ExportIGESOptionsKit;
812 #endif
813 
816  enum class BRepMode
817  {
820  TessellationOnly,
823  BRepOnly,
826  BRepAndTessellation,
827  };
828 
831  enum class ImportMode
832  {
835  Complete,
838  Incremental,
839  };
840 
843  enum class SurfaceType
844  {
845  Blend01,
846  Blend02,
847  Blend03,
848  Blend04,
849  NURBS,
850  Cone,
851  Cylinder,
852  Offset,
853  Pipe,
854  Plane,
855  Ruled,
856  Sphere,
857  Revolution,
858  Extrusion,
859  FromCurve,
860  Torus,
861  Transform,
862  };
863 
866  enum class CurveType
867  {
868  Blend,
869  NURBS,
870  Circle,
871  Composite,
872  CurveOnSurface,
873  Ellipse,
874  Equation,
875  Helix,
876  Hyperbola,
877  Intersection,
878  Line,
879  Offset,
880  Parabola,
881  Polyline,
882  Transform,
883  };
884 
885  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
886  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
887 
891  {
892  PMIOnly,
893  ModelAndPMI
894  };
895 
897  class EXCHANGE_API Tessellation
898  {
899  public:
902  enum class Type
903  {
904  Standard,
905  Custom
906  };
907 
908 
911  enum class Level
912  {
913  ExtraLow,
914  Low,
915  Medium,
916  High,
917  ExtraHigh,
918  };
919 
921  class EXCHANGE_API Chord
922  {
923  public:
926  enum class Limit
927  {
930  Ratio,
933  Height
934  };
935 
936  private:
938  Chord();
939  };
940 
943  enum class Accuracy
944  {
947  Standard,
950  Accurate,
952  GridAccurate
953  };
954 
955  private:
957  Tessellation();
958  };
959 
961  class EXCHANGE_API JT
962  {
963  public:
966  enum class Content
967  {
968  Geometry,
969  Tessellation,
970  GeometryAndTessellation
971  };
972 
975  enum class TessellationLevel
976  {
977  Low,
978  Medium,
979  High,
980  };
981 
984  enum class Version
985  {
986  JT81,
987  JT95,
988  };
989 
990  private:
992  JT();
993  };
994 
996  class EXCHANGE_API STEP
997  {
998  public:
1001  enum class Field
1002  {
1003  ProductName,
1004  NextAssemblyUsageOccurrenceID,
1005  NextAssemblyUsageOccurrenceName,
1006  NextAssemblyUsageOccurrenceDescription
1007  };
1008 
1011  enum class Format
1012  {
1013  AP203,
1014  AP214,
1015  AP242,
1016  };
1017 
1018  private:
1020  STEP();
1021  };
1022 
1024  class EXCHANGE_API PRC
1025  {
1026  public:
1029  enum class BRepCompression
1030  {
1031  None,
1032  Low,
1033  Medium,
1034  High
1035  };
1036 
1037  private:
1039  PRC();
1040  };
1041 
1043  class EXCHANGE_API ProE
1044  {
1045  public:
1048  enum class SessionColor
1049  {
1051  LastCreoVersion,
1053  ExchangeDefault,
1056  UserDefined
1057  };
1058 
1061  enum class FamilyTable
1062  {
1064  BRepOnly,
1066  BRepOrTessellation,
1068  BRepOrTessellationOrGeneric
1069  };
1070 
1074  {
1076  On,
1078  Off,
1080  AsDatum,
1081  };
1082 
1083  private:
1085  ProE();
1086  };
1087 
1089  class EXCHANGE_API U3D
1090  {
1091  public:
1094  enum class Version
1095  {
1096  ECMA1,
1097  ECMA3
1098  };
1099 
1100  private:
1102  U3D();
1103  };
1104 
1106  class EXCHANGE_API Configuration : public HPS::Sprocket
1107  {
1108  public:
1110  Configuration();
1111 
1114  Configuration(char const * in_name);
1115 
1120  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1121 
1125  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1126 
1129  Configuration(Configuration const & in_configuration);
1130 
1134  Configuration(Configuration && in_that);
1135 
1139  Configuration & operator=(Configuration && in_that);
1140 
1141  virtual ~Configuration();
1142 
1143  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1144  HPS::Type ObjectType() const { return staticType; }
1145 
1146 
1149  void Set(Configuration const & in_kit);
1150 
1153  void Show(Configuration & out_kit) const;
1154 
1158  Configuration & operator=(Configuration const & in_kit);
1159 
1162  bool Empty() const;
1163 
1167  bool Equals(Configuration const & in_kit) const;
1168 
1172  bool operator==(Configuration const & in_kit) const;
1173 
1177  bool operator!=(Configuration const & in_kit) const;
1178 
1179 
1182  HPS::UTF8 GetName() const;
1183 
1186  ConfigurationArray GetSubconfigurations() const;
1187  };
1188 
1190  class EXCHANGE_API File
1191  {
1192  public:
1195  enum class Format
1196  {
1197  Unsupported,
1198  ACIS,
1199  CADDS,
1200  CATIAV4,
1201  CATIAV5,
1202  CGR,
1203  COLLADA,
1204  CreoProE,
1205  DWG,
1206  DXF,
1207  IDEAS,
1208  IFC,
1209  IGES,
1210  Inventor,
1211  JT,
1212  KeyholeMarkupLanguage,
1213  LatticeXVL,
1214  OneSpaceDesigner,
1215  Parasolid,
1216  PDF,
1217  PRC,
1218  Rhino,
1219  NXUnigraphics,
1220  SolidEdge,
1221  SolidWorks,
1222  STEP,
1223  StereoLithography,
1224  ThreeDStudioMax,
1225  ThreeDXML,
1226  Universal3D,
1227  VDAFS,
1228  VRML,
1229  WavefrontObject,
1230  Revit,
1231  GLTF,
1232  DWF,
1233  FBX,
1234  STEPXML,
1235  };
1236 
1238  static Format GetFormat(char const * in_file_name);
1239 
1243  static ConfigurationArray GetConfigurations(char const * in_file_name);
1244 
1256  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);
1257 
1263  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1264 
1271  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1272 
1279  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1280 
1288  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1289 
1296  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1297 
1298 
1305  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1306 
1307 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1308 
1312  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1313 
1319  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1320 
1327  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1328 
1334  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1335 
1340  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1341 
1346  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1347 
1353  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1354 
1360  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1361 
1368  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1369 
1376  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1377 
1381  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1382 
1387  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1388 
1392  static ExportNotifier ExportPRC(KeyPath const & in_source);
1393 
1398  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1399 
1404  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1405 
1409  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1410 
1415  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1416 #endif
1417 
1418 #if TARGET_OS_ANDROID == 0
1419 
1423  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1424 
1429  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1430 
1435  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1436 #endif
1437 
1438  private:
1440  File();
1441  };
1442 
1444  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1445  {
1446  public:
1449 
1453 
1458 
1462  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1463 
1464  virtual ~NURBSConversionOptionsKit();
1465 
1466  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1467  HPS::Type ObjectType() const { return staticType; }
1468 
1471  void Set(NURBSConversionOptionsKit const & in_kit);
1472 
1475  void Show(NURBSConversionOptionsKit & out_kit) const;
1476 
1480  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1481 
1484  bool Empty() const;
1485 
1489  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1490 
1494  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1495 
1499  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1500 
1504  static NURBSConversionOptionsKit GetDefault();
1505 
1510  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1511 
1516  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1517 
1522  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1523 
1528  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1529 
1534  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1535 
1540  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1541 
1546  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1547 
1553  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1554 
1561  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1562 
1568  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1569 
1576  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1577 
1578 
1581  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1582 
1585  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1586 
1589  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1590 
1593  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1594 
1597  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1598 
1601  NURBSConversionOptionsKit & UnsetParameterization();
1602 
1605  NURBSConversionOptionsKit & UnsetTolerance();
1606 
1609  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1610 
1613  NURBSConversionOptionsKit & UnsetAllowedCurves();
1614 
1617  NURBSConversionOptionsKit & UnsetEverything();
1618 
1619 
1620 
1624  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1625 
1629  bool Show3DCurvesComputation(bool & out_state) const;
1630 
1635  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1636 
1640  bool ShowClosedFaceSplitting(bool & out_state) const;
1641 
1645  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1646 
1650  bool ShowParameterization(bool & out_state) const;
1651 
1655  bool ShowTolerance(double & out_tolerance) const;
1656 
1660  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1661 
1665  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1666  };
1667 
1669  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1670  {
1671  public:
1673  ImportOptionsKit();
1674 
1677  ImportOptionsKit(ImportOptionsKit const & in_kit);
1678 
1682  ImportOptionsKit(ImportOptionsKit && in_that);
1683 
1687  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1688 
1689  virtual ~ImportOptionsKit();
1690 
1691  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1692  HPS::Type ObjectType() const { return staticType; }
1693 
1697  static ImportOptionsKit GetDefault();
1698 
1701  void Set(ImportOptionsKit const & in_kit);
1702 
1705  void Show(ImportOptionsKit & out_kit) const;
1706 
1710  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1711 
1714  bool Empty() const;
1715 
1719  bool Equals(ImportOptionsKit const & in_kit) const;
1720 
1724  bool operator==(ImportOptionsKit const & in_kit) const;
1725 
1729  bool operator!=(ImportOptionsKit const & in_kit) const;
1730 
1731 
1737  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1738 
1744  ImportOptionsKit & SetSolids(bool in_state);
1745 
1751  ImportOptionsKit & SetSurfaces(bool in_state);
1752 
1758  ImportOptionsKit & SetWireframes(bool in_state);
1759 
1765  ImportOptionsKit & SetPMI(bool in_state);
1766 
1773  ImportOptionsKit & SetAttributes(bool in_state);
1774 
1780  ImportOptionsKit & SetHiddenObjects(bool in_state);
1781 
1787  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1788 
1794  ImportOptionsKit & SetActiveFilter(bool in_state);
1795 
1803  ImportOptionsKit & SetFeatureTrees(bool in_state);
1804 
1810  ImportOptionsKit & SetDrawings(bool in_state);
1811 
1817  ImportOptionsKit & SetDefaultUnits(Units in_units);
1818 
1823  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1824 
1830  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1831 
1838  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1839 
1846  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1847 
1853  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1854 
1860  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1861 
1869  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1870 
1877  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1878 
1886  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1887 
1895  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1896 
1902  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1903 
1909  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1910 
1917  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1918 
1930  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
1931 
1937  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1938 
1944  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1945 
1951  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1952 
1957  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1958 
1965  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1966 
1972  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1973 
1982  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1983 
1992  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1993 
1999  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2000 
2005  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2006 
2013  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2014 
2019  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2020 
2026  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2027 
2032  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2033 
2039  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2040 
2047  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2048 
2055  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2056 
2064  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2065 
2072  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2073 
2079  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2080 
2086  ImportOptionsKit & SetProECodePageName(char const * in_name);
2087 
2093  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2094 
2100  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2101 
2107  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2108 
2115  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2116 
2123  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2124 
2131  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2132 
2139  ImportOptionsKit & SetProEHomeView(bool in_state);
2140 
2147  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2148 
2155  ImportOptionsKit & SetProEDatum(bool in_state);
2156 
2157 
2164  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2165 
2172  ImportOptionsKit & SetProESkeletons(bool in_state);
2173 
2180  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2181 
2187  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2188 
2194  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2195 
2201  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2202 
2208  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2209 
2215  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2216 
2222  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2223 
2230  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2231 
2237  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2238 
2244  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2245 
2252  ImportOptionsKit & SetIFCEdges(bool in_state);
2253 
2259  ImportOptionsKit & SetIFCMetadata(bool in_state);
2260 
2266  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2267 
2273  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2274 
2280  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2281 
2287  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2288 
2294  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2295 
2302  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2303 
2307  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2308 
2320  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2321 
2333  ImportOptionsKit & SetMode(ImportMode in_mode);
2334 
2344  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2345 
2353  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2354 
2361  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2362 
2366  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2367 
2372  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2373 
2376  ImportOptionsKit & UnsetBRepMode();
2377 
2380  ImportOptionsKit & UnsetSolids();
2381 
2384  ImportOptionsKit & UnsetSurfaces();
2385 
2388  ImportOptionsKit & UnsetWireframes();
2389 
2392  ImportOptionsKit & UnsetPMI();
2393 
2396  ImportOptionsKit & UnsetAttributes();
2397 
2400  ImportOptionsKit & UnsetHiddenObjects();
2401 
2404  ImportOptionsKit & UnsetConstructionAndReferences();
2405 
2408  ImportOptionsKit & UnsetActiveFilter();
2409 
2412  ImportOptionsKit & UnsetDrawings();
2413 
2416  ImportOptionsKit & UnsetFeatureTrees();
2417 
2420  ImportOptionsKit & UnsetSewingTolerance();
2421 
2424  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2425 
2428  ImportOptionsKit & UnsetDefaultUnits();
2429 
2432  ImportOptionsKit & UnsetMultiProcessCount();
2433 
2436  ImportOptionsKit & UnsetPMISubstitutionFont();
2437 
2440  ImportOptionsKit & UnsetPMIPrecision();
2441 
2444  ImportOptionsKit & UnsetPMIDefaultUnits();
2445 
2448  ImportOptionsKit & UnsetPMIDefaultColor();
2449 
2452  ImportOptionsKit & UnsetTessellationLevel();
2453 
2456  ImportOptionsKit & UnsetTessellationAccuracy();
2457 
2460  ImportOptionsKit & UnsetTessellationCleanup();
2461 
2464  ImportOptionsKit & UnsetPMIFlipping();
2465 
2468  ImportOptionsKit & UnsetRemovedViews();
2469 
2472  ImportOptionsKit & UnsetExternalProductOccurrence();
2473 
2476  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2477 
2480  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2481 
2484  ImportOptionsKit & UnsetTextureDirectories();
2485 
2488  ImportOptionsKit & UnsetSearchDirectories();
2489 
2492  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2493 
2496  ImportOptionsKit & UnsetSearchRootDirectory();
2497 
2500  ImportOptionsKit & UnsetConfiguration();
2501 
2504  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2505 
2508  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2509 
2512  ImportOptionsKit & UnsetCatiaV5Cache();
2513 
2516  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2517 
2520  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2521 
2524  ImportOptionsKit & UnsetProECodePageName();
2525 
2528  ImportOptionsKit & UnsetProEDimensionTolerance();
2529 
2532  ImportOptionsKit & UnsetProESubpartPMI();
2533 
2536  ImportOptionsKit & UnsetProESessionColor();
2537 
2540  ImportOptionsKit & UnsetProEDatum();
2541 
2544  ImportOptionsKit & UnsetProEHomeView();
2545 
2548  ImportOptionsKit & UnsetProEExplodedViews();
2549 
2552  ImportOptionsKit & UnsetProEMissingBoolean();
2553 
2556  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2557 
2560  ImportOptionsKit & UnsetProEFamilyTreeSource();
2561 
2564  ImportOptionsKit & UnsetProEConstructionEntities();
2565 
2568  ImportOptionsKit & UnsetProESkeletons();
2569 
2572  ImportOptionsKit & UnsetSTEPNamePreference();
2573 
2576  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2577 
2580  ImportOptionsKit & UnsetSTEPCodePageName();
2581 
2584  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2585 
2588  ImportOptionsKit & UnsetSTEPOrientationHealing();
2589 
2592  ImportOptionsKit & UnsetSTEPValidationProperties();
2593 
2596  ImportOptionsKit & UnsetIFCCodePageName();
2597 
2600  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2601 
2604  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2605 
2608  ImportOptionsKit & UnsetIFCFaceOptimization();
2609 
2612  ImportOptionsKit & UnsetIFCEdges();
2613 
2616  ImportOptionsKit & UnsetIFCMetadata();
2617 
2620  ImportOptionsKit & UnsetPDF3DStreamIndex();
2621 
2624  ImportOptionsKit & UnsetJTTessellationLevel();
2625 
2628  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2629 
2632  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2633 
2636  ImportOptionsKit & UnsetPRCReadHelper();
2637 
2640  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2641 
2644  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2645 
2648  ImportOptionsKit & UnsetLocation();
2649 
2652  ImportOptionsKit & UnsetMode();
2653 
2656  ImportOptionsKit & UnsetIncrementalComponentPaths();
2657 
2660  ImportOptionsKit & UnsetNURBSConversion();
2661 
2664  ImportOptionsKit & UnsetGeometryDefaultColor();
2665 
2668  ImportOptionsKit & UnsetEverything();
2669 
2673  bool ShowBRepMode(BRepMode & out_mode) const;
2674 
2678  bool ShowSolids(bool & out_state) const;
2679 
2683  bool ShowSurfaces(bool & out_state) const;
2684 
2688  bool ShowWireframes(bool & out_state) const;
2689 
2693  bool ShowPMI(bool & out_state) const;
2694 
2698  bool ShowAttributes(bool & out_state) const;
2699 
2703  bool ShowHiddenObjects(bool & out_state) const;
2704 
2708  bool ShowConstructionAndReferences(bool & out_state) const;
2709 
2713  bool ShowActiveFilter(bool & out_state) const;
2714 
2718  bool ShowDrawings(bool & out_state) const;
2719 
2723  bool ShowFeatureTrees(bool & out_state) const;
2724 
2728  bool ShowSewingTolerance(double & out_tolerance) const;
2729 
2733  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2734 
2738  bool ShowDefaultUnits(Units & out_units) const;
2739 
2743  bool ShowMultiProcessCount(unsigned int & out_count) const;
2744 
2749  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2750 
2754  bool ShowPMIPrecision(size_t & out_precision) const;
2755 
2759  bool ShowPMIDefaultUnits(Units & out_units) const;
2760 
2765  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2766 
2774  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2775 
2782  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2783 
2787  bool ShowTessellationCleanup(bool & out_cleanup) const;
2788 
2792  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2793 
2797  bool ShowRemovedViews(bool & out_read_removed_views) const;
2798 
2802  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2803 
2807  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2808 
2812  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2813 
2817  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2818 
2824  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2825 
2829  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2830 
2835  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2836 
2840  bool ShowConfiguration(UTF8Array & out_configuration) const;
2841 
2845  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2846 
2850  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2851 
2856  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2857 
2862  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2863 
2867  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2868 
2872  bool ShowProECodePageName(UTF8 & out_name) const;
2873 
2877  bool ShowProEDimensionTolerance(bool & out_state) const;
2878 
2882  bool ShowProESubpartPMI(bool & out_state) const;
2883 
2887  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2888 
2892  bool ShowProEDatum(bool & out_state) const;
2893 
2897  bool ShowProEHomeView(bool & out_state) const;
2898 
2902  bool ShowProEExplodedViews(bool & out_state) const;
2903 
2907  bool ShowProEMissingBoolean(bool & out_state) const;
2908 
2912  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2913 
2917  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2918 
2922  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2923 
2927  bool ShowProESkeletons(bool & out_state) const;
2928 
2932  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2933 
2937  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2938 
2942  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2943 
2947  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2948 
2952  bool ShowSTEPOrientationHealing(bool & out_state) const;
2953 
2957  bool ShowSTEPValidationProperties(bool & out_state) const;
2958 
2962  bool ShowIFCCodePageName(UTF8 & out_name) const;
2963 
2967  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2968 
2972  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2973 
2977  bool ShowIFCFaceOptimization(bool & out_state) const;
2978 
2982  bool ShowIFCEdges(bool & out_state) const;
2983 
2987  bool ShowIFCMetadata(bool & out_state) const;
2988 
2992  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2993 
2997  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2998 
3002  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3003 
3007  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3008 
3012  bool ShowPRCReadHelper(bool & out_use_helper) const;
3013 
3017  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3018 
3022  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3023 
3028  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3029 
3033  bool ShowMode(ImportMode & out_mode) const;
3034 
3038  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3039 
3043  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3044 
3048  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3049  };
3050 
3052  class EXCHANGE_API Translation
3053  {
3054  public:
3057  enum class Healing
3058  {
3059  Off,
3060  On,
3061  OnlyIfNotParasolid,
3062  };
3063 
3066  enum class AccurateEdges
3067  {
3068  Off,
3069  On,
3070  OnlyIfNotParasolid,
3071  };
3072 
3075  enum class Simplification
3076  {
3077  Off,
3078  On,
3079  OnlyIfNotParasolid,
3080  };
3081 
3084  enum class Merging
3085  {
3086  Off,
3087  On,
3088  OnlyIfNotParasolid,
3089  };
3090 
3091  private:
3093  Translation();
3094  };
3095 
3097  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3098  {
3099  public:
3102 
3106 
3111 
3115  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3116 
3117  virtual ~TranslationOptionsKit();
3118 
3119  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3120  HPS::Type ObjectType() const { return staticType; }
3121 
3125  static TranslationOptionsKit GetDefault();
3126 
3129  void Set(TranslationOptionsKit const & in_kit);
3130 
3133  void Show(TranslationOptionsKit & out_kit) const;
3134 
3138  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3139 
3142  bool Empty() const;
3143 
3147  bool Equals(TranslationOptionsKit const & in_kit) const;
3148 
3152  bool operator==(TranslationOptionsKit const & in_kit) const;
3153 
3157  bool operator!=(TranslationOptionsKit const & in_kit) const;
3158 
3164  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3165 
3171  TranslationOptionsKit & SetTessellation(bool in_state);
3172 
3178  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3179 
3183  TranslationOptionsKit & SetApplication(char const * in_name);
3184 
3188  TranslationOptionsKit & SetVersion(char const * in_version);
3189 
3195  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3196 
3200  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3201 
3205  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3206 
3210  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3211 
3215  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3216 
3221  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3222 
3226  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3227 
3230  TranslationOptionsKit & UnsetSolidsAsFaces();
3231 
3234  TranslationOptionsKit & UnsetTessellation();
3235 
3238  TranslationOptionsKit & UnsetHiddenObjects();
3239 
3242  TranslationOptionsKit & UnsetApplication();
3243 
3246  TranslationOptionsKit & UnsetVersion();
3247 
3250  TranslationOptionsKit & UnsetHealing();
3251 
3254  TranslationOptionsKit & UnsetAccurateEdges();
3255 
3258  TranslationOptionsKit & UnsetSimplification();
3259 
3262  TranslationOptionsKit & UnsetEntityMerging();
3263 
3266  TranslationOptionsKit & UnsetSewing();
3267 
3270  TranslationOptionsKit & UnsetDisjointFaces();
3271 
3274  TranslationOptionsKit& UnsetExplodeMultiBodies();
3275 
3278  TranslationOptionsKit & UnsetEverything();
3279 
3280 
3284  bool ShowSolidsAsFaces(bool & out_state) const;
3285 
3289  bool ShowTessellation(bool & out_state) const;
3290 
3294  bool ShowHiddenObjects(bool & out_state) const;
3295 
3299  bool ShowApplication(UTF8 & out_name) const;
3300 
3304  bool ShowVersion(UTF8 & out_version) const;
3305 
3309  bool ShowExplodeMultiBodies(bool& out_state) const;
3310 
3314  bool ShowHealing(Translation::Healing & out_healing) const;
3315 
3319  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3320 
3324  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3325 
3329  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3330 
3335  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3336 
3340  bool ShowDisjointFaces(bool & out_state) const;
3341 
3346  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3347 
3350  TranslationOptionsKit & UnsetMultiProcessCount();
3351 
3355  bool ShowMultiProcessCount(unsigned int & out_count) const;
3356  };
3357 
3358 
3359 
3364  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3365  {
3366  public:
3369 
3373 
3378 
3382  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3383 
3384  virtual ~ModelFileImportOptionsKit();
3385 
3386  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3387  HPS::Type ObjectType() const { return staticType; }
3388 
3392  static ModelFileImportOptionsKit GetDefault();
3393 
3396  void Set(ModelFileImportOptionsKit const & in_kit);
3397 
3400  void Show(ModelFileImportOptionsKit & out_kit) const;
3401 
3405  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3406 
3409  bool Empty() const;
3410 
3414  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3415 
3419  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3420 
3424  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3425 
3426 
3427  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3428  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3429  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3430  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3431  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3432  * \return A reference to this ImportOptionsKit.
3433  */
3434  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3435 
3441  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3442 
3449  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3450 
3462  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double accurate_grid_maximum_stitch_length = 0.0);
3463 
3464  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3465  * \warning Setting this option to true will cause future exports to output without tessellation data.
3466  * \param in_cleanup Whether to clean up tessellation data from representation items.
3467  * \return A reference to this ImportOptionsKit.
3468  */
3469  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3470 
3476  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3477 
3483  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3484 
3491  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3492 
3496  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3497 
3510  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3511 
3517  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3518 
3525  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3526 
3530  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3531 
3536  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3537 
3538 
3541  ModelFileImportOptionsKit & UnsetTessellationLevel();
3542 
3545  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3546 
3549  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3550 
3553  ModelFileImportOptionsKit & UnsetPMIFlipping();
3554 
3557  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3558 
3561  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3562 
3565  ModelFileImportOptionsKit & UnsetIFCEdges();
3566 
3569  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3570 
3573  ModelFileImportOptionsKit & UnsetLocation();
3574 
3577  ModelFileImportOptionsKit & UnsetSewingTolerance();
3578 
3581  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3582 
3585  ModelFileImportOptionsKit & UnsetNURBSConversion();
3586 
3589  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3590 
3593  ModelFileImportOptionsKit & UnsetEverything();
3594 
3595 
3603  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3604 
3611  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3612 
3616  bool ShowTessellationCleanup(bool & out_cleanup) const;
3617 
3621  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3622 
3626  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3627 
3631  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3632 
3636  bool ShowIFCEdges(bool & out_state) const;
3637 
3641  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3642 
3647  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3648 
3652  bool ShowSewingTolerance(double & out_tolerance) const;
3653 
3654 
3658  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3659 
3663  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3664 
3668  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3669  };
3670 
3671 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3672 
3673  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3674  {
3675  public:
3678 
3681  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3682 
3686 
3687  virtual ~Export3MFOptionsKit();
3688 
3689  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3690  HPS::Type ObjectType() const { return staticType; }
3691 
3695  static Export3MFOptionsKit GetDefault();
3696 
3699  void Set(Export3MFOptionsKit const & in_kit);
3700 
3703  void Show(Export3MFOptionsKit& out_kit) const;
3704 
3708  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3709 
3713  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3714 
3717  bool Empty() const;
3718 
3722  bool Equals(Export3MFOptionsKit const & in_kit) const;
3723 
3727  bool operator==(Export3MFOptionsKit const & in_kit) const;
3728 
3732  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3733 
3738  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3739 
3745  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3746 
3749  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3750 
3754  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3755 
3760  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3761 
3764  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3765 
3770  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3771 
3775  Export3MFOptionsKit & SetDescription(char const * in_description);
3776 
3779  Export3MFOptionsKit & UnsetDescription();
3780 
3784  bool ShowDescription(HPS::UTF8 & out_state) const;
3785 
3789  Export3MFOptionsKit & SetCopyright(char const * in_state);
3790 
3793  Export3MFOptionsKit & UnsetCopyright();
3794 
3798  bool ShowCopyright(HPS::UTF8 & out_state) const;
3799 
3803  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3804 
3807  Export3MFOptionsKit & UnsetLicenseTerms();
3808 
3812  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3813 
3816  Export3MFOptionsKit & UnsetEverything();
3817  };
3818 
3820  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3821  {
3822  public:
3825 
3829 
3833 
3834  virtual ~ExportACISOptionsKit();
3835 
3836  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
3837  HPS::Type ObjectType() const { return staticType; }
3838 
3842  static ExportACISOptionsKit GetDefault();
3843 
3846  void Set(ExportACISOptionsKit const & in_kit);
3847 
3850  void Show(ExportACISOptionsKit & out_kit) const;
3851 
3855  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3856 
3860  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3861 
3864  bool Empty() const;
3865 
3869  bool Equals(ExportACISOptionsKit const & in_kit) const;
3870 
3874  bool operator==(ExportACISOptionsKit const & in_kit) const;
3875 
3879  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3880 
3881 
3887  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3888 
3894  ExportACISOptionsKit & SetBinary(bool in_state);
3895 
3896 
3899  ExportACISOptionsKit & UnsetMillimeterUnits();
3900 
3903  ExportACISOptionsKit & UnsetBinary();
3904 
3907  ExportACISOptionsKit & UnsetEverything();
3908 
3909 
3913  bool ShowMillimeterUnits(bool & out_state) const;
3914 
3918  bool ShowBinary(bool & out_state) const;
3919  };
3920 
3922  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3923  {
3924  public:
3927 
3930  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3931 
3935 
3936  virtual ~ExportJTOptionsKit();
3937 
3938  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
3939  HPS::Type ObjectType() const { return staticType; }
3940 
3944  static ExportJTOptionsKit GetDefault();
3945 
3948  void Set(ExportJTOptionsKit const & in_kit);
3949 
3952  void Show(ExportJTOptionsKit & out_kit) const;
3953 
3957  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3958 
3962  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3963 
3966  bool Empty() const;
3967 
3971  bool Equals(ExportJTOptionsKit const & in_kit) const;
3972 
3976  bool operator==(ExportJTOptionsKit const & in_kit) const;
3977 
3981  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3982 
3983 
3989  ExportJTOptionsKit & SetContent(JT::Content in_content);
3990 
3996  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3997 
4003  ExportJTOptionsKit & SetPMI(bool in_state);
4004 
4010  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4011 
4012 
4015  ExportJTOptionsKit & UnsetContent();
4016 
4019  ExportJTOptionsKit & UnsetHiddenObjects();
4020 
4023  ExportJTOptionsKit & UnsetPMI();
4024 
4027  ExportJTOptionsKit & UnsetVersion();
4028 
4031  ExportJTOptionsKit & UnsetEverything();
4032 
4033 
4037  bool ShowContent(JT::Content & out_content) const;
4038 
4042  bool ShowHiddenObjects(bool & out_state) const;
4043 
4047  bool ShowPMI(bool & out_state) const;
4048 
4052  bool ShowVersion(JT::Version & out_version) const;
4053  };
4054 
4056  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4057  {
4058  public:
4061 
4064  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4065 
4069 
4070  virtual ~ExportPRCOptionsKit();
4071 
4072  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4073  HPS::Type ObjectType() const { return staticType; }
4074 
4078  static ExportPRCOptionsKit GetDefault();
4079 
4082  void Set(ExportPRCOptionsKit const & in_kit);
4083 
4086  void Show(ExportPRCOptionsKit & out_kit) const;
4087 
4091  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4092 
4096  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4097 
4100  bool Empty() const;
4101 
4105  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4106 
4110  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4111 
4115  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4116 
4117 
4123  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4124 
4131  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4132 
4138  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4139 
4145  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4146 
4151  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4152 
4158  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4159 
4160 
4163  ExportPRCOptionsKit & UnsetTessellationCompression();
4164 
4167  ExportPRCOptionsKit & UnsetBRepCompression();
4168 
4171  ExportPRCOptionsKit & UnsetBRepRemoval();
4172 
4175  ExportPRCOptionsKit & UnsetAttributeRemoval();
4176 
4179  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4180 
4183  ExportPRCOptionsKit & UnsetEverything();
4184 
4185 
4189  bool ShowTessellationCompression(bool & out_state) const;
4190 
4194  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4195 
4199  bool ShowBRepRemoval(bool & out_state) const;
4200 
4204  bool ShowAttributeRemoval(bool & out_state) const;
4205 
4209  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4210  };
4211 
4213  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4214  {
4215  public:
4218 
4221  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4222 
4226 
4227  virtual ~ExportSTLOptionsKit();
4228 
4229  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4230  HPS::Type ObjectType() const { return staticType; }
4231 
4235  static ExportSTLOptionsKit GetDefault();
4236 
4239  void Set(ExportSTLOptionsKit const & in_kit);
4240 
4243  void Show(ExportSTLOptionsKit & out_kit) const;
4244 
4248  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4249 
4253  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4254 
4257  bool Empty() const;
4258 
4262  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4263 
4267  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4268 
4272  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4273 
4274 
4280  ExportSTLOptionsKit & SetBinary(bool in_state);
4281 
4287  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4288 
4295  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4296 
4302  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4303 
4309  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4310 
4317  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4318 
4328  ExportSTLOptionsKit & SetUnits(Units in_units);
4329 
4330 
4333  ExportSTLOptionsKit & UnsetBinary();
4334 
4337  ExportSTLOptionsKit & UnsetTessellationLevel();
4338 
4341  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4342 
4345  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4346 
4349  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4350 
4353  ExportSTLOptionsKit & UnsetUnits();
4354 
4357  ExportSTLOptionsKit & UnsetEverything();
4358 
4359 
4363  bool ShowBinary(bool & out_state) const;
4364 
4372  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4373 
4377  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4378 
4382  bool ShowCurrentTessellationRetention(bool & out_state) const;
4383 
4387  bool ShowMaximumEdgeLength(double & out_length) const;
4388 
4392  bool ShowUnits(Units & out_units) const;
4393  };
4394 
4396  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4397  {
4398  public:
4401 
4404  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4405 
4409 
4410  virtual ~ExportU3DOptionsKit();
4411 
4412  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4413  HPS::Type ObjectType() const { return staticType; }
4414 
4418  static ExportU3DOptionsKit GetDefault();
4419 
4422  void Set(ExportU3DOptionsKit const & in_kit);
4423 
4426  void Show(ExportU3DOptionsKit & out_kit) const;
4427 
4431  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4432 
4436  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4437 
4440  bool Empty() const;
4441 
4445  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4446 
4450  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4451 
4455  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4456 
4457 
4463  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4464 
4469  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4470 
4471 
4474  ExportU3DOptionsKit & UnsetVersion();
4475 
4478  ExportU3DOptionsKit & UnsetCompression();
4479 
4482  ExportU3DOptionsKit & UnsetEverything();
4483 
4484 
4488  bool ShowVersion(U3D::Version & out_version) const;
4489 
4493  bool ShowCompression(unsigned char & out_level) const;
4494  };
4495 
4497  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4498  {
4499  public:
4502 
4505  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4506 
4510 
4511  virtual ~ExportXMLOptionsKit();
4512 
4513  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4514  HPS::Type ObjectType() const { return staticType; }
4515 
4519  static ExportXMLOptionsKit GetDefault();
4520 
4523  void Set(ExportXMLOptionsKit const & in_kit);
4524 
4527  void Show(ExportXMLOptionsKit & out_kit) const;
4528 
4532  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4533 
4537  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4538 
4541  bool Empty() const;
4542 
4546  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4547 
4551  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4552 
4556  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4557 
4558 
4564  ExportXMLOptionsKit & SetMetadata(bool in_state);
4565 
4571  ExportXMLOptionsKit & SetTransformations(bool in_state);
4572 
4578  ExportXMLOptionsKit & SetMaterials(bool in_state);
4579 
4580 
4583  ExportXMLOptionsKit & UnsetMetadata();
4584 
4587  ExportXMLOptionsKit & UnsetTransformations();
4588 
4591  ExportXMLOptionsKit & UnsetMaterials();
4592 
4595  ExportXMLOptionsKit & UnsetEverything();
4596 
4597 
4601  bool ShowMetadata(bool & out_state) const;
4602 
4606  bool ShowTransformations(bool & out_state) const;
4607 
4611  bool ShowMaterials(bool & out_state) const;
4612  };
4613 #endif
4614 
4615 #if !defined(TARGET_OS_ANDROID)
4616 
4617  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4618  {
4619  public:
4622 
4626 
4630 
4631  virtual ~ExportIGESOptionsKit();
4632 
4633  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4634  HPS::Type ObjectType() const { return staticType; }
4635 
4639  static ExportIGESOptionsKit GetDefault();
4640 
4643  void Set(ExportIGESOptionsKit const & in_kit);
4644 
4647  void Show(ExportIGESOptionsKit & out_kit) const;
4648 
4652  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4653 
4657  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4658 
4661  bool Empty() const;
4662 
4666  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4667 
4671  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4672 
4676  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4677 
4678 
4684  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4685 
4691  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4692 
4698  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4699 
4705  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4706 
4712  ExportIGESOptionsKit & SetTessellation(bool in_state);
4713 
4717  ExportIGESOptionsKit & SetApplication(char const * in_name);
4718 
4722  ExportIGESOptionsKit & SetVersion(char const * in_version);
4723 
4724 
4727  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4728 
4731  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
4732 
4735  ExportIGESOptionsKit & UnsetSolidsAsFaces();
4736 
4739  ExportIGESOptionsKit & UnsetHiddenObjects();
4740 
4743  ExportIGESOptionsKit & UnsetTessellation();
4744 
4747  ExportIGESOptionsKit & UnsetApplication();
4748 
4751  ExportIGESOptionsKit & UnsetVersion();
4752 
4755  ExportIGESOptionsKit & UnsetEverything();
4756 
4757 
4761  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4762 
4766  bool ShowFacetedAsWireframe(bool & out_state) const;
4767 
4771  bool ShowSolidsAsFaces(bool & out_state) const;
4772 
4776  bool ShowHiddenObjects(bool & out_state) const;
4777 
4781  bool ShowTessellation(bool & out_state) const;
4782 
4786  bool ShowApplication(UTF8 & out_name) const;
4787 
4791  bool ShowVersion(UTF8 & out_version) const;
4792  };
4793 
4795  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
4796  {
4797  public:
4800 
4804 
4808 
4809  virtual ~ExportParasolidOptionsKit();
4810 
4811  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
4812  HPS::Type ObjectType() const { return staticType; }
4813 
4817  static ExportParasolidOptionsKit GetDefault();
4818 
4821  void Set(ExportParasolidOptionsKit const & in_kit);
4822 
4825  void Show(ExportParasolidOptionsKit & out_kit) const;
4826 
4830  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4831 
4835  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4836 
4839  bool Empty() const;
4840 
4844  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4845 
4849  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4850 
4854  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4855 
4856 
4862  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4863 
4869  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4870 
4876  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4877 
4881  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4882 
4886  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4887 
4893  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
4894 
4897  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4898 
4901  ExportParasolidOptionsKit & UnsetTessellation();
4902 
4905  ExportParasolidOptionsKit & UnsetHiddenObjects();
4906 
4909  ExportParasolidOptionsKit & UnsetApplication();
4910 
4913  ExportParasolidOptionsKit & UnsetVersion();
4914 
4917  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
4918 
4921  ExportParasolidOptionsKit & UnsetEverything();
4922 
4923 
4927  bool ShowSolidsAsFaces(bool & out_state) const;
4928 
4932  bool ShowTessellation(bool & out_state) const;
4933 
4937  bool ShowHiddenObjects(bool & out_state) const;
4938 
4942  bool ShowApplication(UTF8 & out_name) const;
4943 
4947  bool ShowVersion(UTF8 & out_version) const;
4948 
4952  bool ShowExplodeMultiBodies(bool& out_state) const;
4953  };
4954 
4956  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4957  {
4958  public:
4961 
4965 
4969 
4970  virtual ~ExportSTEPOptionsKit();
4971 
4972  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
4973  HPS::Type ObjectType() const { return staticType; }
4974 
4978  static ExportSTEPOptionsKit GetDefault();
4979 
4982  void Set(ExportSTEPOptionsKit const & in_kit);
4983 
4986  void Show(ExportSTEPOptionsKit & out_kit) const;
4987 
4991  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4992 
4996  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4997 
5000  bool Empty() const;
5001 
5005  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5006 
5010  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5011 
5015  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5016 
5017 
5023  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5024 
5030  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5031 
5037  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5038 
5044  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5045 
5049  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5050 
5054  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5055 
5059  ExportSTEPOptionsKit & SetPMI(bool in_state);
5060 
5064  ExportSTEPOptionsKit & SetCurves(bool in_state);
5065 
5069  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5070 
5074  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5075 
5079  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5080 
5083  ExportSTEPOptionsKit & UnsetFormat();
5084 
5087  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5088 
5091  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5092 
5095  ExportSTEPOptionsKit & UnsetNameShortening();
5096 
5099  ExportSTEPOptionsKit & UnsetApplication();
5100 
5103  ExportSTEPOptionsKit & UnsetVersion();
5104 
5107  ExportSTEPOptionsKit & UnsetPMI();
5108 
5111  ExportSTEPOptionsKit & UnsetCurves();
5112 
5115  ExportSTEPOptionsKit & UnsetAttributes();
5116 
5119  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5120 
5123  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5124 
5127  ExportSTEPOptionsKit & UnsetEverything();
5128 
5129 
5133  bool ShowFormat(STEP::Format & out_format) const;
5134 
5138  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5139 
5143  bool ShowFacetedAsWireframe(bool & out_state) const;
5144 
5148  bool ShowNameShortening(bool & out_state) const;
5149 
5153  bool ShowApplication(UTF8 & out_name) const;
5154 
5158  bool ShowVersion(UTF8 & out_version) const;
5159 
5163  bool ShowPMI(bool & out_state) const;
5164 
5168  bool ShowCurves(bool & out_state) const;
5169 
5173  bool ShowAttributes(bool & out_state) const;
5174 
5178  bool ShowPMIWithSemantic(bool & out_state) const;
5179 
5183  bool ShowPMIAsTessellated(bool & out_state) const;
5184  };
5185 #endif
5186 
5188  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5189  {
5190  public:
5193 
5197 
5201 
5202  virtual ~TessellationOptionsKit();
5203 
5204  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5205  HPS::Type ObjectType() const { return staticType; }
5206 
5210  static TessellationOptionsKit GetDefault();
5211 
5214  void Set(TessellationOptionsKit const & in_kit);
5215 
5218  void Show(TessellationOptionsKit & out_kit) const;
5219 
5223  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5224 
5228  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5229 
5232  bool Empty() const;
5233 
5237  bool Equals(TessellationOptionsKit const & in_kit) const;
5238 
5242  bool operator==(TessellationOptionsKit const & in_kit) const;
5243 
5247  bool operator!=(TessellationOptionsKit const & in_kit) const;
5248 
5249 
5253  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5254 
5261  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5262 
5272  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
5273 
5277  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5278 
5282  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5283 
5284 
5287  TessellationOptionsKit & UnsetLevel();
5288 
5291  TessellationOptionsKit & UnsetAccuracy();
5292 
5295  TessellationOptionsKit & UnsetUVPointPreservation();
5296 
5299  TessellationOptionsKit & UnsetMaximumEdgeLength();
5300 
5303  TessellationOptionsKit & UnsetEverything();
5304 
5305 
5313  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5314 
5321  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5322 
5326  bool ShowUVPointPreservation(bool & out_state) const;
5327 
5331  bool ShowMaximumEdgeLength(double & out_length) const;
5332  };
5333 
5339  class EXCHANGE_API CommonMeasurementOperator : public Operator
5340  {
5341  public:
5342  enum class Tags
5343  {
5344  Name = 0,
5345  MeasurementType,
5346  Radius,
5347  Inverted,
5348  VectorX,
5349  VectorY,
5350  VectorZ,
5351  };
5352 
5354 
5355  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5356 
5358  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5359 
5360  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5361  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5362 
5363  Exchange::CADModel GetCADModel() const;
5364  void SetCADModel(Exchange::CADModel const & in_cad_model);
5365 
5367  size_t GetPrecision() const;
5368 
5371  void SetPrecision(size_t in_precision);
5372 
5374  MaterialMappingKit GetMaterial() const;
5375 
5378  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5379 
5381  TextAttributeKit GetTextAttributes() const;
5382 
5385  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5386 
5388  SegmentKey GetMeasurementSegment() const;
5389 
5391  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5392 
5393  /* Deletes all measurements */
5394  void DeleteMeasurements();
5395 
5396  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5397  {
5398  public:
5401  {
5402  channel = GetClassID();
5403  consumable = false;
5404  }
5405 
5406  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5407  {
5408  channel = GetClassID();
5409  consumable = false;
5410  measurement_key = in_measurement_key;
5411  view = in_view;
5412  }
5413 
5416  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5417  {
5418  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5419  {
5420  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5421  measurement_key = that.measurement_key;
5422  view = that.view;
5423  }
5424  else
5425  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5426  }
5427 
5429 
5432  Event * Clone() const
5433  {
5434  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5435  return new_event;
5436  }
5437 
5438  Key measurement_key;
5439  View view;
5440  };
5441 
5442  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5443  {
5444  public:
5447  {
5448  channel = GetClassID();
5449  consumable = false;
5450  }
5451 
5452  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5453  {
5454  channel = GetClassID();
5455  consumable = false;
5456  measurement_name = in_measurement_name;
5457  view = in_view;
5458  }
5459 
5462  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5463  {
5464  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5465  {
5466  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5467  measurement_name = that.measurement_name;
5468  view = that.view;
5469  }
5470  else
5471  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5472  }
5473 
5475 
5478  Event * Clone() const
5479  {
5480  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5481  return new_event;
5482  }
5483 
5484  UTF8 measurement_name;
5485  View view;
5486  };
5487 
5488  protected:
5489  Exchange::CADModel cad_model;
5490  size_t measurement_precision;
5491  UTF8 units;
5492  MaterialMappingKit materials;
5493  TextAttributeKit text_attributes;
5494  SegmentKey measurement_segment;
5495  GlyphDefinition left_arrow;
5496  GlyphDefinition right_arrow;
5497  SelectionOptionsKit selection_options;
5498  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5499  Vector camera_direction;
5500  PortfolioKey portfolio;
5501  SegmentKey style_segment;
5502  HighlightOptionsKit highlight_options;
5503 
5504  static size_t length_measurement_index;
5505  static size_t radius_measurement_index;
5506  static size_t distance_measurement_index;
5507  static size_t angle_measurement_index;
5508 
5509  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5510  void GetUnits();
5511  void SetGlyphColor();
5512  void GetCameraDirection();
5513  void SetupConstructionSegment();
5514  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5515  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5516  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5517  float GetModelScale(Exchange::Component const & component);
5518  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5519  };
5520 
5574  {
5575  public:
5576  enum class MeasurementType
5577  {
5578  PointToPoint,
5579  EdgeAndRadius,
5580  FeatureToFeature,
5581  FaceAngle,
5582  };
5583 
5585 
5586  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5587 
5589  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5590 
5591  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5592  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5593 
5598  virtual bool OnMouseDown(MouseState const & in_state) override;
5599 
5603  virtual bool OnMouseUp(MouseState const & in_state) override;
5604 
5610  virtual bool OnMouseMove(MouseState const & in_state) override;
5611 
5616  virtual bool OnTouchDown(TouchState const & in_state) override;
5617 
5621  virtual bool OnTouchUp(TouchState const & in_state) override;
5622 
5628  virtual bool OnTouchMove(TouchState const & in_state) override;
5629 
5633  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5634 
5637  void SetMeasurementType(MeasurementType in_measurement_type);
5638 
5641  MeasurementType GetMeasurementType();
5642 
5645  void SetMouseOverHighlighting(bool in_highlighting);
5646 
5650  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5651 
5654  bool GetMouseOverHighlighting();
5655 
5658  HighlightOptionsKit GetHighlightOptions();
5659 
5662  bool IsMeasurementActive();
5663 
5665  void DeleteLastMeasurement();
5666 
5667  private:
5668  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5669  {
5670  Circle,
5671  Line,
5672  Generic,
5673  };
5674 
5675  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5676  {
5677  public:
5678  Surface();
5679 
5680  enum class SurfaceType
5681  {
5682  Plane,
5683  ConeOrCylinder,
5684  Unsupported,
5685  };
5686 
5687  SurfaceType surface_type; //the type of surface being measured
5688  Point center; //the center point of the surface
5689  Vector normal; //the center line of surfaces of type Cylinder or Cone
5690  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5691  ComponentPath path; //the ComponentPath to this surface
5692  };
5693 
5694  //bookkeeping
5695  MeasurementType measurement_type; //the type of measurement to be inserted
5696  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5697  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5698  TouchID current_touch_id; //the ID of the touch being processed
5699  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5700  bool operator_active; //whether a measurement is in progress
5701  bool end_measurement; //whether we should end the current measurement
5702  CanvasArray canvases; //canvases related to the view where this operator is attached
5703 
5704  //measurement anchors
5705  size_t anchors; //valid for point-to-point and face-angle measurements
5706  bool anchors_in_place; //true if all the anchors have been placed
5707  Point first_click_position; //position of the first anchor
5708  Point second_click_position; //position of the second anchor
5709 
5710  //geometry for linear measurements
5711  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5712  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5713  LineKey distance_line; //a line representing the distance measured
5714  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5715  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5716  Point distance_point_one; //intersection of leader_line_one and distance_line
5717  Point distance_point_two; //intersection of leader_line_two and distance_line
5718  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5719  TextKey text; //text representing the measurement and units
5720  UTF8 text_string; //the contents of the text
5721  Vector measurement_direction; //the direction of the measurement
5722  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5723  Vector explicit_direction; //used if use_explicit_direction is true
5724 
5725  //geometry for radius measurement
5726  MarkerKey center_marker; //marker representing the center of the circle
5727  Point circle_center; //circle center
5728  float radius; //circle radius
5729 
5730  //edge specific data
5731  LineKey edge_line; //the edge being measured
5732  double edge_length; //length of the measured edge
5733  EdgeType edge_type; //the type of edge being measured
5734 
5735  //feature-to-feature specific data
5736  Surface surface_one; //data related to first selected surface
5737  Surface surface_two; //data related to second selected surface
5738  Plane measurement_plane; //the measurement plane
5739  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5740 
5741  //angle specific data
5742  Vector leader_line_one_direction; //the direction of the first leader line
5743  Vector leader_line_two_direction; //the direction of the second leader line
5744  Vector first_face_normal; //the normal of the first selected face
5745  Vector second_face_normal; //the normal of the second selected face
5746  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'
5747  CircularArcKey measurement_arc; //an arc representing the measured angle
5748  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5749  Vector mid_point_direction;
5750 
5751  //selection kits
5752  SelectionOptionsKit point_to_point_selection;
5753  SelectionOptionsKit edge_radius_selection;
5754  SelectionOptionsKit feature_to_feature_selection;
5755  SelectionOptionsKit angle_selection;
5756 
5757  //highlighting
5758  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5759  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5760  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5761  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5762  KeyPath highlighted_path; //highlighted_path
5763  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5764  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5765 
5766  //input handling
5767  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5768  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5769  bool InputUp(WindowKey & in_window);
5770  void ResetMeasurement();
5771 
5772  //inserting measurements
5773  void InsertPointToPointMeasurement(Point const & in_world_point);
5774  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5775  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5776  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5777  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5778  void InvertMeasuredAngle(WindowKey & in_window);
5779  void AdjustLineToCursor(Point const & cursor_position);
5780 
5781  //saving measurements
5782  void TagMeasurement();
5783  void TagPointToPointMeasurement();
5784  void TagEdgeMeasurement();
5785  void TagRadiusMeasurement();
5786  void TagGenericEdgeMeasurement();
5787  void TagFeatureToFeatureMeasurement();
5788  void TagAngleMeasurement();
5789 
5790  //restoring measurements
5791  void RestoreMeasurement(SegmentKey const & measurement_segment);
5792  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5793  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5794  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5795  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5796  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5797  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5798  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5799 
5800  //topology functions
5801  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5802  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5803  void PlaneToCenterLineDistance();
5804  void PlaneToPlaneDistance();
5805  void LineToLineDistance();
5806  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);
5807  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5808  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5809  bool IsPlane(Exchange::Component const & face_component);
5810  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5811  };
5812 
5813 private:
5815  Exchange();
5816 };
5817 
5818 }
5819 
5820 #endif
Definition: hps.h:6261
Definition: sprk_exchange.h:4056
Level
Definition: sprk_exchange.h:911
ConstructionEntities
Definition: sprk_exchange.h:1073
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3939
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1024
Definition: sprk.h:273
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
Definition: sprk_exchange.h:1190
Definition: sprk_exchange.h:5339
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5865
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:67
Simplification
Definition: sprk_exchange.h:3075
Definition: sprk.h:106
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5358
Definition: sprk_exchange.h:653
Version
Definition: sprk_exchange.h:1094
Definition: sprk_exchange.h:3364
Definition: sprk_exchange.h:921
Definition: sprk_exchange.h:754
HPS::Type ObjectType() const
Definition: sprk_exchange.h:736
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4514
SurfaceType
Definition: sprk_exchange.h:843
Definition: hps.h:1740
Format
Definition: sprk_exchange.h:1011
HPS::Type ObjectType() const
Definition: sprk_exchange.h:783
Definition: sprk_exchange.h:4497
Definition: sprk.h:242
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6727
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6703
Definition: hps.h:48690
Format
Definition: sprk_exchange.h:1195
Definition: hps.h:7768
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4073
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6697
Type
Definition: sprk_exchange.h:902
Definition: hps.h:16417
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4634
Definition: sprk_exchange.h:501
Definition: sprk_exchange.h:592
Definition: sprk_exchange.h:334
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4812
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5416
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
Definition: sprk_exchange.h:1444
Definition: sprk_exchange.h:274
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4230
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
Definition: sprk_exchange.h:3922
Merging
Definition: sprk_exchange.h:3084
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3120
Field
Definition: sprk_exchange.h:1001
Definition: hps.h:48588
Definition: hps.h:41976
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1144
Definition: sprk_exchange.h:3820
Definition: sprk_exchange.h:3097
Limit
Definition: sprk_exchange.h:926
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4973
Definition: hps.h:4539
TessellationLevel
Definition: sprk_exchange.h:975
Definition: sprk_exchange.h:897
Definition: sprk_exchange.h:4213
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:996
Definition: hps.h:4478
Definition: hps.h:7139
Definition: hps.h:48059
Definition: sprk_exchange.h:455
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:43984
Definition: hps.h:48475
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:890
Definition: sprk_exchange.h:4396
Definition: sprk_exchange.h:961
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3837
Definition: hps.h:15804
Event * Clone() const
Definition: sprk_exchange.h:5478
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6683
intptr_t GetChannel() const
Definition: hps.h:6378
Definition: sprk_exchange.h:1089
SessionColor
Definition: sprk_exchange.h:1048
Definition: sprk.h:1781
Definition: hps.h:48797
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:45183
Definition: hps.h:47566
CurveType
Definition: sprk_exchange.h:866
Definition: sprk_exchange.h:546
Definition: hps.h:6345
Definition: hps.h:14052
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5205
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6695
Definition: sprk_exchange.h:5573
Definition: sprk.h:487
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1692
BRepCompression
Definition: sprk_exchange.h:1029
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:816
Definition: sprk.h:2161
ComponentType
Definition: sprk.h:1797
Accuracy
Definition: sprk_exchange.h:943
Definition: sprk_exchange.h:3673
Definition: sprk_exchange.h:4617
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1467
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5462
Definition: sprk.h:2660
FamilyTable
Definition: sprk_exchange.h:1061
Content
Definition: sprk_exchange.h:966
Definition: sprk_exchange.h:1669
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3387
HPS::Type ObjectType() const
Definition: sprk_exchange.h:682
Definition: sprk.h:2760
static MouseButtons ButtonLeft()
Definition: hps.h:48177
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5589
Definition: hps.h:7686
Definition: sprk_exchange.h:1043
AccurateEdges
Definition: sprk_exchange.h:3066
Event * Clone() const
Definition: sprk_exchange.h:5432
HPS::Type ObjectType() const
Definition: sprk_exchange.h:528
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4413
Definition: hps.h:9399
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
Definition: sprk_exchange.h:707
Definition: hps.h:24604
Healing
Definition: sprk_exchange.h:3057
Definition: sprk.h:2847
Definition: hps.h:31037
ImportMode
Definition: sprk_exchange.h:831
Definition: sprk_exchange.h:1106
Definition: hps.h:513
Definition: sprk.h:1110
Definition: sprk_exchange.h:3052
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:4795
Definition: sprk_exchange.h:203
Definition: hps.h:41472
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3690
Version
Definition: sprk_exchange.h:984
Definition: sprk_exchange.h:5188
HPS::Type ObjectType() const
Definition: sprk_exchange.h:621
Definition: hps.h:42607
Definition: sprk_exchange.h:4956