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  };
175 
176  class EXCHANGE_API ProductOccurrence : public Exchange::Component
177  {
178  public:
181 
185  ProductOccurrence(HPS::Component const & in_that);
186 
190  ProductOccurrence(Component const & in_that);
191 
194  ProductOccurrence(ProductOccurrence const & in_sheet);
195 
200 
204  ProductOccurrence & operator=(ProductOccurrence && in_that);
205 
206  virtual ~ProductOccurrence();
207 
208  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
209  HPS::Type ObjectType() const { return staticType; }
210 
214  bool Equals(ProductOccurrence const & in_kit) const;
215 
219  bool operator==(ProductOccurrence const & in_kit) const;
220 
224  bool operator!=(ProductOccurrence const & in_kit) const;
225 
231  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
232 
238  LoadStatus GetLoadStatus() const;
239  };
240 
242  class EXCHANGE_API Sheet : public Exchange::Component
243  {
244  public:
246  Sheet();
247 
251  Sheet(HPS::Component const & in_that);
252 
256  Sheet(Component const & in_that);
257 
260  Sheet(Sheet const & in_sheet);
261 
265  Sheet(Sheet && in_that);
266 
270  Sheet & operator=(Sheet && in_that);
271 
272  virtual ~Sheet();
273 
274  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
275  HPS::Type ObjectType() const { return staticType; }
276 
280  bool Equals(Sheet const & in_kit) const;
281 
282 #if !defined(_MSC_VER) || _MSC_VER >= 1900
283  Sheet & operator=(Sheet const & in_that) = default;
284 #endif
285 
289  bool operator==(Sheet const & in_kit) const;
290 
294  bool operator!=(Sheet const & in_kit) const;
295 
296  /* Activates this sheet */
297  HPS::View Activate();
298  };
299 
302  class EXCHANGE_API CADModel : public HPS::CADModel
303  {
304  public:
306  CADModel();
307 
311  CADModel(Component const & in_that);
312 
316  CADModel(HPS::CADModel const & in_that);
317 
320  CADModel(Exchange::CADModel const & in_that);
321 
324  CADModel(Exchange::CADModel && in_that);
325 
326  virtual ~CADModel();
327 
328  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
329  HPS::Type ObjectType() const { return staticType; }
330 
331 #if !defined(_MSC_VER) || _MSC_VER >= 1900
332  CADModel & operator=(Exchange::CADModel const & in_that) = default;
333 #endif
334 
338  CADModel & operator=(Exchange::CADModel && in_that);
339 
340 
343  A3DEntity * GetExchangeEntity() const;
344 
348  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
349 
355  bool GetEntityOwnership() const;
356 
357 
361  UTF8Array GetCurrentConfiguration() const;
362 
366  ConfigurationArray GetConfigurations() const;
367 
368  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
369  * \return The list of sheets for this CADModel */
370  SheetArray GetSheets() const;
371 
377  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
378 
383  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
384 
390  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
391 
397  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
398 
404  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
405 
410  void Tessellate(TessellationOptionsKit const & in_options);
411  };
412 
415  class EXCHANGE_API Capture : public HPS::Capture
416  {
417  public:
419  Capture();
420 
424  Capture(Component const & in_that);
425 
429  Capture(HPS::Capture const & in_that);
430 
433  Capture(Exchange::Capture const & in_that);
434 
437  Capture(Exchange::Capture && in_that);
438 
439  virtual ~Capture();
440 
441  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
442  HPS::Type ObjectType() const { return staticType; }
443 
444 #if !defined(_MSC_VER) || _MSC_VER >= 1900
445  Capture & operator=(Exchange::Capture const & in_that) = default;
446 #endif
447 
451  Capture & operator=(Exchange::Capture && in_that);
452 
453 
456  A3DEntity * GetExchangeEntity() const;
457  };
458 
461  class EXCHANGE_API Filter : public HPS::Filter
462  {
463  public:
465  Filter();
466 
470  Filter(Component const & in_that);
471 
475  Filter(HPS::Filter const & in_that);
476 
479  Filter(Exchange::Filter const & in_that);
480 
483  Filter(Exchange::Filter && in_that);
484 
485  virtual ~Filter();
486 
487  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
488  HPS::Type ObjectType() const { return staticType; }
489 
490 #if !defined(_MSC_VER) || _MSC_VER >= 1900
491  Filter & operator=(Exchange::Filter const & in_that) = default;
492 #endif
493 
497  Filter & operator=(Exchange::Filter && in_that);
498 
499 
502  A3DEntity * GetExchangeEntity() const;
503  };
504 
506  class EXCHANGE_API Factory : public Sprocket
507  {
508  public:
513  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
514 
520  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
521 
525  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
526 
533  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
534 
538  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
539 
540  private:
542  Factory();
543  };
544 
546  class EXCHANGE_API ImportNotifier : public IONotifier
547  {
548  public:
550  ImportNotifier();
551 
554  ImportNotifier(ImportNotifier const & in_that);
555 
560  ImportNotifier(IONotifier const & in_that);
561 
565  ImportNotifier(ImportNotifier && in_that);
566 
570  ImportNotifier & operator=(ImportNotifier && in_that);
571 
572  virtual ~ImportNotifier();
573 
574  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
575  HPS::Type ObjectType() const { return staticType; };
576 
580  ImportNotifier & operator=(ImportNotifier const & in_that);
581 
584  void Assign(ImportNotifier const & in_that);
585 
588  Exchange::CADModel GetCADModel() const;
589 
595  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
596 
599  Time GetImportTime() const;
600 
603  Time GetParseTime() const;
604  };
605 
607  class EXCHANGE_API TranslationNotifier : public IONotifier
608  {
609  public:
612 
615  TranslationNotifier(TranslationNotifier const & in_that);
616 
621  TranslationNotifier(IONotifier const & in_that);
622 
627 
631  TranslationNotifier & operator=(TranslationNotifier && in_that);
632 
633  virtual ~TranslationNotifier();
634 
635  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
636  HPS::Type ObjectType() const { return staticType; };
637 
641  TranslationNotifier & operator=(TranslationNotifier const & in_that);
642 
645  void Assign(TranslationNotifier const & in_that);
646 
649  Exchange::ParasolidEntityArray GetParasolidParts() const;
650 
653  HPS::Time GetImportTime() const;
654 
657  HPS::Time GetTranslationTime() const;
658  };
659 
661  class EXCHANGE_API ExportNotifier : public IONotifier
662  {
663  public:
665  ExportNotifier();
666 
669  ExportNotifier(ExportNotifier const & in_that);
670 
675  ExportNotifier(IONotifier const & in_that);
676 
680  ExportNotifier(ExportNotifier && in_that);
681 
685  ExportNotifier & operator=(ExportNotifier && in_that);
686 
687  virtual ~ExportNotifier();
688 
689  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
690  HPS::Type ObjectType() const { return staticType; };
691 
695  ExportNotifier & operator=(ExportNotifier const & in_that);
696 
699  void Assign(ExportNotifier const & in_that);
700 
704  A3DAsmModelFile * GetModelFile() const;
705  };
706 
708  class EXCHANGE_API ReloadNotifier : public IONotifier
709  {
710  public:
712  ReloadNotifier();
713 
716  ReloadNotifier(ReloadNotifier const & in_that);
717 
722  ReloadNotifier(IONotifier const & in_that);
723 
727  ReloadNotifier(ReloadNotifier && in_that);
728 
732  ReloadNotifier & operator=(ReloadNotifier && in_that);
733 
734  virtual ~ReloadNotifier();
735 
736  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
737  HPS::Type ObjectType() const { return staticType; };
738 
742  ReloadNotifier & operator=(ReloadNotifier const & in_that);
743 
746  void Assign(ReloadNotifier const & in_that);
747  };
748 
749 
750  class ImportOptionsKit;
752 
753 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
754  class Export3MFOptionsKit;
755  class ExportACISOptionsKit;
756  class ExportJTOptionsKit;
757  class ExportPRCOptionsKit;
758  class ExportSTLOptionsKit;
759  class ExportU3DOptionsKit;
760  class ExportXMLOptionsKit;
761 #endif
762 
763 #if !defined(TARGET_OS_ANDROID)
764  class ExportSTEPOptionsKit;
765  class ExportIGESOptionsKit;
766 #endif
767 
770  enum class BRepMode
771  {
774  TessellationOnly,
777  BRepOnly,
780  BRepAndTessellation,
781  };
782 
785  enum class ImportMode
786  {
789  Complete,
792  Incremental,
793  };
794 
797  enum class SurfaceType
798  {
799  Blend01,
800  Blend02,
801  Blend03,
802  Blend04,
803  NURBS,
804  Cone,
805  Cylinder,
806  Offset,
807  Pipe,
808  Plane,
809  Ruled,
810  Sphere,
811  Revolution,
812  Extrusion,
813  FromCurve,
814  Torus,
815  Transform,
816  };
817 
820  enum class CurveType
821  {
822  Blend,
823  NURBS,
824  Circle,
825  Composite,
826  CurveOnSurface,
827  Ellipse,
828  Equation,
829  Helix,
830  Hyperbola,
831  Intersection,
832  Line,
833  Offset,
834  Parabola,
835  Polyline,
836  Transform,
837  };
838 
839  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
840  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
841 
845  {
846  PMIOnly,
847  ModelAndPMI
848  };
849 
851  class EXCHANGE_API Tessellation
852  {
853  public:
856  enum class Type
857  {
858  Standard,
859  Custom
860  };
861 
862 
865  enum class Level
866  {
867  ExtraLow,
868  Low,
869  Medium,
870  High,
871  ExtraHigh,
872  };
873 
875  class EXCHANGE_API Chord
876  {
877  public:
880  enum class Limit
881  {
884  Ratio,
887  Height
888  };
889 
890  private:
892  Chord();
893  };
894 
897  enum class Accuracy
898  {
901  Standard,
904  Accurate
905  };
906 
907  private:
909  Tessellation();
910  };
911 
913  class EXCHANGE_API JT
914  {
915  public:
918  enum class Content
919  {
920  Geometry,
921  Tessellation,
922  GeometryAndTessellation
923  };
924 
927  enum class TessellationLevel
928  {
929  Low,
930  Medium,
931  High,
932  };
933 
936  enum class Version
937  {
938  JT81,
939  JT95,
940  };
941 
942  private:
944  JT();
945  };
946 
948  class EXCHANGE_API STEP
949  {
950  public:
953  enum class Field
954  {
955  ProductName,
956  NextAssemblyUsageOccurrenceID,
957  NextAssemblyUsageOccurrenceName,
958  NextAssemblyUsageOccurrenceDescription
959  };
960 
963  enum class Format
964  {
965  AP203,
966  AP214,
967  AP242,
968  };
969 
970  private:
972  STEP();
973  };
974 
976  class EXCHANGE_API PRC
977  {
978  public:
981  enum class BRepCompression
982  {
983  None,
984  Low,
985  Medium,
986  High
987  };
988 
989  private:
991  PRC();
992  };
993 
995  class EXCHANGE_API ProE
996  {
997  public:
1000  enum class SessionColor
1001  {
1003  LastCreoVersion,
1005  ExchangeDefault,
1008  UserDefined
1009  };
1010 
1013  enum class FamilyTable
1014  {
1016  BRepOnly,
1018  BRepOrTessellation,
1020  BRepOrTessellationOrGeneric
1021  };
1022 
1026  {
1028  On,
1030  Off,
1032  AsDatum,
1033  };
1034 
1035  private:
1037  ProE();
1038  };
1039 
1041  class EXCHANGE_API U3D
1042  {
1043  public:
1046  enum class Version
1047  {
1048  ECMA1,
1049  ECMA3
1050  };
1051 
1052  private:
1054  U3D();
1055  };
1056 
1058  class EXCHANGE_API Configuration : public HPS::Sprocket
1059  {
1060  public:
1062  Configuration();
1063 
1066  Configuration(char const * in_name);
1067 
1072  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1073 
1077  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1078 
1081  Configuration(Configuration const & in_configuration);
1082 
1086  Configuration(Configuration && in_that);
1087 
1091  Configuration & operator=(Configuration && in_that);
1092 
1093  virtual ~Configuration();
1094 
1095  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1096  HPS::Type ObjectType() const { return staticType; }
1097 
1098 
1101  void Set(Configuration const & in_kit);
1102 
1105  void Show(Configuration & out_kit) const;
1106 
1110  Configuration & operator=(Configuration const & in_kit);
1111 
1114  bool Empty() const;
1115 
1119  bool Equals(Configuration const & in_kit) const;
1120 
1124  bool operator==(Configuration const & in_kit) const;
1125 
1129  bool operator!=(Configuration const & in_kit) const;
1130 
1131 
1134  HPS::UTF8 GetName() const;
1135 
1138  ConfigurationArray GetSubconfigurations() const;
1139  };
1140 
1142  class EXCHANGE_API File
1143  {
1144  public:
1147  enum class Format
1148  {
1149  Unsupported,
1150  ACIS,
1151  CADDS,
1152  CATIAV4,
1153  CATIAV5,
1154  CGR,
1155  COLLADA,
1156  CreoProE,
1157  DWG,
1158  DXF,
1159  IDEAS,
1160  IFC,
1161  IGES,
1162  Inventor,
1163  JT,
1164  KeyholeMarkupLanguage,
1165  LatticeXVL,
1166  OneSpaceDesigner,
1167  Parasolid,
1168  PDF,
1169  PRC,
1170  Rhino,
1171  NXUnigraphics,
1172  SolidEdge,
1173  SolidWorks,
1174  STEP,
1175  StereoLithography,
1176  ThreeDStudioMax,
1177  ThreeDXML,
1178  Universal3D,
1179  VDAFS,
1180  VRML,
1181  WavefrontObject,
1182  };
1183 
1185  static Format GetFormat(char const * in_file_name);
1186 
1190  static ConfigurationArray GetConfigurations(char const * in_file_name);
1191 
1203  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);
1204 
1210  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1211 
1218  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1219 
1226  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1227 
1235  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1236 
1243  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1244 
1245 
1252  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1253 
1254 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1255 
1259  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1260 
1266  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1267 
1274  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1275 
1281  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1282 
1287  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1288 
1293  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1294 
1300  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1301 
1307  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1308 
1315  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1316 
1323  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1324 
1328  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1329 
1334  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1335 
1339  static ExportNotifier ExportPRC(KeyPath const & in_source);
1340 
1345  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1346 
1351  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1352 
1356  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1357 
1362  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1363 #endif
1364 
1365 #if TARGET_OS_ANDROID == 0
1366 
1370  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1371 
1376  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1377 
1382  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1383 #endif
1384 
1385  private:
1387  File();
1388  };
1389 
1391  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1392  {
1393  public:
1396 
1400 
1405 
1409  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1410 
1411  virtual ~NURBSConversionOptionsKit();
1412 
1413  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1414  HPS::Type ObjectType() const { return staticType; }
1415 
1418  void Set(NURBSConversionOptionsKit const & in_kit);
1419 
1422  void Show(NURBSConversionOptionsKit & out_kit) const;
1423 
1427  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1428 
1431  bool Empty() const;
1432 
1436  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1437 
1441  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1442 
1446  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1447 
1451  static NURBSConversionOptionsKit GetDefault();
1452 
1457  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1458 
1463  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1464 
1469  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1470 
1475  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1476 
1481  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1482 
1487  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1488 
1493  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1494 
1500  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1501 
1508  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1509 
1515  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1516 
1523  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1524 
1525 
1528  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1529 
1532  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1533 
1536  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1537 
1540  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1541 
1544  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1545 
1548  NURBSConversionOptionsKit & UnsetParameterization();
1549 
1552  NURBSConversionOptionsKit & UnsetTolerance();
1553 
1556  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1557 
1560  NURBSConversionOptionsKit & UnsetAllowedCurves();
1561 
1564  NURBSConversionOptionsKit & UnsetEverything();
1565 
1566 
1567 
1571  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1572 
1576  bool Show3DCurvesComputation(bool & out_state) const;
1577 
1582  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1583 
1587  bool ShowClosedFaceSplitting(bool & out_state) const;
1588 
1592  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1593 
1597  bool ShowParameterization(bool & out_state) const;
1598 
1602  bool ShowTolerance(double & out_tolerance) const;
1603 
1607  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1608 
1612  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1613  };
1614 
1616  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1617  {
1618  public:
1620  ImportOptionsKit();
1621 
1624  ImportOptionsKit(ImportOptionsKit const & in_kit);
1625 
1629  ImportOptionsKit(ImportOptionsKit && in_that);
1630 
1634  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1635 
1636  virtual ~ImportOptionsKit();
1637 
1638  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1639  HPS::Type ObjectType() const { return staticType; }
1640 
1644  static ImportOptionsKit GetDefault();
1645 
1648  void Set(ImportOptionsKit const & in_kit);
1649 
1652  void Show(ImportOptionsKit & out_kit) const;
1653 
1657  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1658 
1661  bool Empty() const;
1662 
1666  bool Equals(ImportOptionsKit const & in_kit) const;
1667 
1671  bool operator==(ImportOptionsKit const & in_kit) const;
1672 
1676  bool operator!=(ImportOptionsKit const & in_kit) const;
1677 
1678 
1684  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1685 
1691  ImportOptionsKit & SetSolids(bool in_state);
1692 
1698  ImportOptionsKit & SetSurfaces(bool in_state);
1699 
1705  ImportOptionsKit & SetWireframes(bool in_state);
1706 
1712  ImportOptionsKit & SetPMI(bool in_state);
1713 
1720  ImportOptionsKit & SetAttributes(bool in_state);
1721 
1727  ImportOptionsKit & SetHiddenObjects(bool in_state);
1728 
1734  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1735 
1741  ImportOptionsKit & SetActiveFilter(bool in_state);
1742 
1750  ImportOptionsKit & SetFeatureTrees(bool in_state);
1751 
1757  ImportOptionsKit & SetDrawings(bool in_state);
1758 
1764  ImportOptionsKit & SetDefaultUnits(Units in_units);
1765 
1770  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1771 
1777  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1778 
1785  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1786 
1792  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1793 
1799  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1800 
1808  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1809 
1817  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1818 
1824  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1825 
1831  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1832 
1839  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1840 
1848  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1849 
1855  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1856 
1862  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1863 
1869  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1870 
1875  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1876 
1883  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1884 
1890  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1891 
1900  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1901 
1910  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1911 
1917  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1918 
1923  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1924 
1931  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
1932 
1937  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1938 
1944  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1945 
1950  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1951 
1957  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1958 
1965  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1966 
1973  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1974 
1982  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1983 
1990  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1991 
1997  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1998 
2004  ImportOptionsKit & SetProECodePageName(char const * in_name);
2005 
2011  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2012 
2018  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2019 
2025  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2026 
2033  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2034 
2041  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2042 
2049  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2050 
2057  ImportOptionsKit & SetProEHomeView(bool in_state);
2058 
2065  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2066 
2073  ImportOptionsKit & SetProEDatum(bool in_state);
2074 
2075 
2082  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2083 
2090  ImportOptionsKit & SetProESkeletons(bool in_state);
2091 
2098  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2099 
2105  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2106 
2112  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2113 
2119  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2120 
2126  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2127 
2133  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2134 
2140  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2141 
2148  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2149 
2155  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2156 
2162  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2163 
2170  ImportOptionsKit & SetIFCEdges(bool in_state);
2171 
2177  ImportOptionsKit & SetIFCMetadata(bool in_state);
2178 
2184  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2185 
2191  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2192 
2198  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2199 
2205  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2206 
2210  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2211 
2223  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2224 
2236  ImportOptionsKit & SetMode(ImportMode in_mode);
2237 
2247  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2248 
2256  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2257 
2264  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2265 
2269  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2270 
2275  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2276 
2279  ImportOptionsKit & UnsetBRepMode();
2280 
2283  ImportOptionsKit & UnsetSolids();
2284 
2287  ImportOptionsKit & UnsetSurfaces();
2288 
2291  ImportOptionsKit & UnsetWireframes();
2292 
2295  ImportOptionsKit & UnsetPMI();
2296 
2299  ImportOptionsKit & UnsetAttributes();
2300 
2303  ImportOptionsKit & UnsetHiddenObjects();
2304 
2307  ImportOptionsKit & UnsetConstructionAndReferences();
2308 
2311  ImportOptionsKit & UnsetActiveFilter();
2312 
2315  ImportOptionsKit & UnsetDrawings();
2316 
2319  ImportOptionsKit & UnsetFeatureTrees();
2320 
2323  ImportOptionsKit & UnsetSewingTolerance();
2324 
2327  ImportOptionsKit & UnsetDefaultUnits();
2328 
2331  ImportOptionsKit & UnsetMultiProcessCount();
2332 
2335  ImportOptionsKit & UnsetPMISubstitutionFont();
2336 
2339  ImportOptionsKit & UnsetPMIPrecision();
2340 
2343  ImportOptionsKit & UnsetPMIDefaultUnits();
2344 
2347  ImportOptionsKit & UnsetPMIDefaultColor();
2348 
2351  ImportOptionsKit & UnsetTessellationLevel();
2352 
2355  ImportOptionsKit & UnsetTessellationAccuracy();
2356 
2359  ImportOptionsKit & UnsetTessellationCleanup();
2360 
2363  ImportOptionsKit & UnsetPMIFlipping();
2364 
2367  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2368 
2371  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2372 
2375  ImportOptionsKit & UnsetTextureDirectories();
2376 
2379  ImportOptionsKit & UnsetSearchDirectories();
2380 
2383  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2384 
2387  ImportOptionsKit & UnsetSearchRootDirectory();
2388 
2391  ImportOptionsKit & UnsetConfiguration();
2392 
2395  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2396 
2399  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2400 
2403  ImportOptionsKit & UnsetCatiaV5Cache();
2404 
2407  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2408 
2411  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2412 
2415  ImportOptionsKit & UnsetProECodePageName();
2416 
2419  ImportOptionsKit & UnsetProEDimensionTolerance();
2420 
2423  ImportOptionsKit & UnsetProESubpartPMI();
2424 
2427  ImportOptionsKit & UnsetProESessionColor();
2428 
2431  ImportOptionsKit & UnsetProEDatum();
2432 
2435  ImportOptionsKit & UnsetProEHomeView();
2436 
2439  ImportOptionsKit & UnsetProEExplodedViews();
2440 
2443  ImportOptionsKit & UnsetProEMissingBoolean();
2444 
2447  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2448 
2451  ImportOptionsKit & UnsetProEFamilyTreeSource();
2452 
2455  ImportOptionsKit & UnsetProEConstructionEntities();
2456 
2459  ImportOptionsKit & UnsetProESkeletons();
2460 
2463  ImportOptionsKit & UnsetSTEPNamePreference();
2464 
2467  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2468 
2471  ImportOptionsKit & UnsetSTEPCodePageName();
2472 
2475  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2476 
2479  ImportOptionsKit & UnsetSTEPOrientationHealing();
2480 
2483  ImportOptionsKit & UnsetSTEPValidationProperties();
2484 
2487  ImportOptionsKit & UnsetIFCCodePageName();
2488 
2491  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2492 
2495  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2496 
2499  ImportOptionsKit & UnsetIFCFaceOptimization();
2500 
2503  ImportOptionsKit & UnsetIFCEdges();
2504 
2507  ImportOptionsKit & UnsetIFCMetadata();
2508 
2511  ImportOptionsKit & UnsetPDF3DStreamIndex();
2512 
2515  ImportOptionsKit & UnsetJTTessellationLevel();
2516 
2519  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2520 
2523  ImportOptionsKit & UnsetPRCReadHelper();
2524 
2527  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2528 
2531  ImportOptionsKit & UnsetLocation();
2532 
2535  ImportOptionsKit & UnsetMode();
2536 
2539  ImportOptionsKit & UnsetIncrementalComponentPaths();
2540 
2543  ImportOptionsKit & UnsetNURBSConversion();
2544 
2547  ImportOptionsKit & UnsetGeometryDefaultColor();
2548 
2551  ImportOptionsKit & UnsetEverything();
2552 
2556  bool ShowBRepMode(BRepMode & out_mode) const;
2557 
2561  bool ShowSolids(bool & out_state) const;
2562 
2566  bool ShowSurfaces(bool & out_state) const;
2567 
2571  bool ShowWireframes(bool & out_state) const;
2572 
2576  bool ShowPMI(bool & out_state) const;
2577 
2581  bool ShowAttributes(bool & out_state) const;
2582 
2586  bool ShowHiddenObjects(bool & out_state) const;
2587 
2591  bool ShowConstructionAndReferences(bool & out_state) const;
2592 
2596  bool ShowActiveFilter(bool & out_state) const;
2597 
2601  bool ShowDrawings(bool & out_state) const;
2602 
2606  bool ShowFeatureTrees(bool & out_state) const;
2607 
2611  bool ShowSewingTolerance(double & out_tolerance) const;
2612 
2616  bool ShowDefaultUnits(Units & out_units) const;
2617 
2621  bool ShowMultiProcessCount(unsigned int & out_count) const;
2622 
2627  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2628 
2632  bool ShowPMIPrecision(size_t & out_precision) const;
2633 
2637  bool ShowPMIDefaultUnits(Units & out_units) const;
2638 
2643  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2644 
2652  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2653 
2658  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2659 
2663  bool ShowTessellationCleanup(bool & out_cleanup) const;
2664 
2668  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2669 
2673  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2674 
2678  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2679 
2683  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2684 
2690  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2691 
2695  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2696 
2701  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2702 
2706  bool ShowConfiguration(UTF8Array & out_configuration) const;
2707 
2711  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2712 
2716  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2717 
2722  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2723 
2728  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2729 
2733  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2734 
2738  bool ShowProECodePageName(UTF8 & out_name) const;
2739 
2743  bool ShowProEDimensionTolerance(bool & out_state) const;
2744 
2748  bool ShowProESubpartPMI(bool & out_state) const;
2749 
2753  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2754 
2758  bool ShowProEDatum(bool & out_state) const;
2759 
2763  bool ShowProEHomeView(bool & out_state) const;
2764 
2768  bool ShowProEExplodedViews(bool & out_state) const;
2769 
2773  bool ShowProEMissingBoolean(bool & out_state) const;
2774 
2778  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2779 
2783  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2784 
2788  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2789 
2793  bool ShowProESkeletons(bool & out_state) const;
2794 
2798  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2799 
2803  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2804 
2808  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2809 
2813  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2814 
2818  bool ShowSTEPOrientationHealing(bool & out_state) const;
2819 
2823  bool ShowSTEPValidationProperties(bool & out_state) const;
2824 
2828  bool ShowIFCCodePageName(UTF8 & out_name) const;
2829 
2833  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2834 
2838  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2839 
2843  bool ShowIFCFaceOptimization(bool & out_state) const;
2844 
2848  bool ShowIFCEdges(bool & out_state) const;
2849 
2853  bool ShowIFCMetadata(bool & out_state) const;
2854 
2858  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2859 
2863  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2864 
2868  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2869 
2873  bool ShowPRCReadHelper(bool & out_use_helper) const;
2874 
2878  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2879 
2884  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2885 
2889  bool ShowMode(ImportMode & out_mode) const;
2890 
2894  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2895 
2899  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2900 
2904  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
2905  };
2906 
2908  class EXCHANGE_API Translation
2909  {
2910  public:
2913  enum class Healing
2914  {
2915  Off,
2916  On,
2917  OnlyIfNotParasolid,
2918  };
2919 
2922  enum class AccurateEdges
2923  {
2924  Off,
2925  On,
2926  OnlyIfNotParasolid,
2927  };
2928 
2931  enum class Simplification
2932  {
2933  Off,
2934  On,
2935  OnlyIfNotParasolid,
2936  };
2937 
2940  enum class Merging
2941  {
2942  Off,
2943  On,
2944  OnlyIfNotParasolid,
2945  };
2946 
2947  private:
2949  Translation();
2950  };
2951 
2953  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
2954  {
2955  public:
2958 
2962 
2967 
2971  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2972 
2973  virtual ~TranslationOptionsKit();
2974 
2975  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
2976  HPS::Type ObjectType() const { return staticType; }
2977 
2981  static TranslationOptionsKit GetDefault();
2982 
2985  void Set(TranslationOptionsKit const & in_kit);
2986 
2989  void Show(TranslationOptionsKit & out_kit) const;
2990 
2994  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2995 
2998  bool Empty() const;
2999 
3003  bool Equals(TranslationOptionsKit const & in_kit) const;
3004 
3008  bool operator==(TranslationOptionsKit const & in_kit) const;
3009 
3013  bool operator!=(TranslationOptionsKit const & in_kit) const;
3014 
3020  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3021 
3027  TranslationOptionsKit & SetTessellation(bool in_state);
3028 
3034  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3035 
3039  TranslationOptionsKit & SetApplication(char const * in_name);
3040 
3044  TranslationOptionsKit & SetVersion(char const * in_version);
3045 
3049  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3050 
3054  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3055 
3059  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3060 
3064  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3065 
3070  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3071 
3075  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3076 
3079  TranslationOptionsKit & UnsetSolidsAsFaces();
3080 
3083  TranslationOptionsKit & UnsetTessellation();
3084 
3087  TranslationOptionsKit & UnsetHiddenObjects();
3088 
3091  TranslationOptionsKit & UnsetApplication();
3092 
3095  TranslationOptionsKit & UnsetVersion();
3096 
3099  TranslationOptionsKit & UnsetHealing();
3100 
3103  TranslationOptionsKit & UnsetAccurateEdges();
3104 
3107  TranslationOptionsKit & UnsetSimplification();
3108 
3111  TranslationOptionsKit & UnsetEntityMerging();
3112 
3115  TranslationOptionsKit & UnsetSewing();
3116 
3119  TranslationOptionsKit & UnsetDisjointFaces();
3120 
3123  TranslationOptionsKit & UnsetEverything();
3124 
3125 
3129  bool ShowSolidsAsFaces(bool & out_state) const;
3130 
3134  bool ShowTessellation(bool & out_state) const;
3135 
3139  bool ShowHiddenObjects(bool & out_state) const;
3140 
3144  bool ShowApplication(UTF8 & out_name) const;
3145 
3149  bool ShowVersion(UTF8 & out_version) const;
3150 
3154  bool ShowHealing(Translation::Healing & out_healing) const;
3155 
3159  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3160 
3164  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3165 
3169  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3170 
3175  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3176 
3180  bool ShowDisjointFaces(bool & out_state) const;
3181 
3186  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3187 
3190  TranslationOptionsKit & UnsetMultiProcessCount();
3191 
3195  bool ShowMultiProcessCount(unsigned int & out_count) const;
3196  };
3197 
3198 
3199 
3204  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3205  {
3206  public:
3209 
3213 
3218 
3222  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3223 
3224  virtual ~ModelFileImportOptionsKit();
3225 
3226  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3227  HPS::Type ObjectType() const { return staticType; }
3228 
3232  static ModelFileImportOptionsKit GetDefault();
3233 
3236  void Set(ModelFileImportOptionsKit const & in_kit);
3237 
3240  void Show(ModelFileImportOptionsKit & out_kit) const;
3241 
3245  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3246 
3249  bool Empty() const;
3250 
3254  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3255 
3259  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3260 
3264  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3265 
3266 
3267  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3268  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3269  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3270  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3271  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3272  * \return A reference to this ImportOptionsKit.
3273  */
3274  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3275 
3281  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3282 
3289  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3290 
3298  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3299 
3300  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3301  * \warning Setting this option to true will cause future exports to output without tessellation data.
3302  * \param in_cleanup Whether to clean up tessellation data from representation items.
3303  * \return A reference to this ImportOptionsKit.
3304  */
3305  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3306 
3312  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3313 
3319  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3320 
3327  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3328 
3332  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3333 
3346  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3347 
3353  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3354 
3358  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3359 
3364  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3365 
3366 
3369  ModelFileImportOptionsKit & UnsetTessellationLevel();
3370 
3373  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3374 
3377  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3378 
3381  ModelFileImportOptionsKit & UnsetPMIFlipping();
3382 
3385  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3386 
3389  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3390 
3393  ModelFileImportOptionsKit & UnsetIFCEdges();
3394 
3397  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3398 
3401  ModelFileImportOptionsKit & UnsetLocation();
3402 
3405  ModelFileImportOptionsKit & UnsetSewingTolerance();
3406 
3409  ModelFileImportOptionsKit & UnsetNURBSConversion();
3410 
3413  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3414 
3417  ModelFileImportOptionsKit & UnsetEverything();
3418 
3419 
3427  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3428 
3433  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3434 
3438  bool ShowTessellationCleanup(bool & out_cleanup) const;
3439 
3443  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3444 
3448  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3449 
3453  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3454 
3458  bool ShowIFCEdges(bool & out_state) const;
3459 
3463  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3464 
3469  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3470 
3474  bool ShowSewingTolerance(double & out_tolerance) const;
3475 
3479  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3480 
3484  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3485  };
3486 
3487 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3488 
3489  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3490  {
3491  public:
3494 
3497  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3498 
3502 
3503  virtual ~Export3MFOptionsKit();
3504 
3505  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3506  HPS::Type ObjectType() const { return staticType; }
3507 
3511  static Export3MFOptionsKit GetDefault();
3512 
3515  void Set(Export3MFOptionsKit const & in_kit);
3516 
3519  void Show(Export3MFOptionsKit& out_kit) const;
3520 
3524  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3525 
3529  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3530 
3533  bool Empty() const;
3534 
3538  bool Equals(Export3MFOptionsKit const & in_kit) const;
3539 
3543  bool operator==(Export3MFOptionsKit const & in_kit) const;
3544 
3548  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3549 
3554  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3555 
3561  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3562 
3565  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3566 
3570  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3571 
3576  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3577 
3580  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3581 
3586  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3587 
3591  Export3MFOptionsKit & SetDescription(char const * in_description);
3592 
3595  Export3MFOptionsKit & UnsetDescription();
3596 
3600  bool ShowDescription(HPS::UTF8 & out_state) const;
3601 
3605  Export3MFOptionsKit & SetCopyright(char const * in_state);
3606 
3609  Export3MFOptionsKit & UnsetCopyright();
3610 
3614  bool ShowCopyright(HPS::UTF8 & out_state) const;
3615 
3619  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3620 
3623  Export3MFOptionsKit & UnsetLicenseTerms();
3624 
3628  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3629 
3632  Export3MFOptionsKit & UnsetEverything();
3633  };
3634 
3636  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3637  {
3638  public:
3641 
3645 
3649 
3650  virtual ~ExportACISOptionsKit();
3651 
3652  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
3653  HPS::Type ObjectType() const { return staticType; }
3654 
3658  static ExportACISOptionsKit GetDefault();
3659 
3662  void Set(ExportACISOptionsKit const & in_kit);
3663 
3666  void Show(ExportACISOptionsKit & out_kit) const;
3667 
3671  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3672 
3676  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3677 
3680  bool Empty() const;
3681 
3685  bool Equals(ExportACISOptionsKit const & in_kit) const;
3686 
3690  bool operator==(ExportACISOptionsKit const & in_kit) const;
3691 
3695  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3696 
3697 
3703  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3704 
3710  ExportACISOptionsKit & SetBinary(bool in_state);
3711 
3712 
3715  ExportACISOptionsKit & UnsetMillimeterUnits();
3716 
3719  ExportACISOptionsKit & UnsetBinary();
3720 
3723  ExportACISOptionsKit & UnsetEverything();
3724 
3725 
3729  bool ShowMillimeterUnits(bool & out_state) const;
3730 
3734  bool ShowBinary(bool & out_state) const;
3735  };
3736 
3738  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3739  {
3740  public:
3743 
3746  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3747 
3751 
3752  virtual ~ExportJTOptionsKit();
3753 
3754  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
3755  HPS::Type ObjectType() const { return staticType; }
3756 
3760  static ExportJTOptionsKit GetDefault();
3761 
3764  void Set(ExportJTOptionsKit const & in_kit);
3765 
3768  void Show(ExportJTOptionsKit & out_kit) const;
3769 
3773  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3774 
3778  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3779 
3782  bool Empty() const;
3783 
3787  bool Equals(ExportJTOptionsKit const & in_kit) const;
3788 
3792  bool operator==(ExportJTOptionsKit const & in_kit) const;
3793 
3797  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3798 
3799 
3805  ExportJTOptionsKit & SetContent(JT::Content in_content);
3806 
3812  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3813 
3819  ExportJTOptionsKit & SetPMI(bool in_state);
3820 
3826  ExportJTOptionsKit & SetVersion(JT::Version in_version);
3827 
3828 
3831  ExportJTOptionsKit & UnsetContent();
3832 
3835  ExportJTOptionsKit & UnsetHiddenObjects();
3836 
3839  ExportJTOptionsKit & UnsetPMI();
3840 
3843  ExportJTOptionsKit & UnsetVersion();
3844 
3847  ExportJTOptionsKit & UnsetEverything();
3848 
3849 
3853  bool ShowContent(JT::Content & out_content) const;
3854 
3858  bool ShowHiddenObjects(bool & out_state) const;
3859 
3863  bool ShowPMI(bool & out_state) const;
3864 
3868  bool ShowVersion(JT::Version & out_version) const;
3869  };
3870 
3872  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
3873  {
3874  public:
3877 
3880  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3881 
3885 
3886  virtual ~ExportPRCOptionsKit();
3887 
3888  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
3889  HPS::Type ObjectType() const { return staticType; }
3890 
3894  static ExportPRCOptionsKit GetDefault();
3895 
3898  void Set(ExportPRCOptionsKit const & in_kit);
3899 
3902  void Show(ExportPRCOptionsKit & out_kit) const;
3903 
3907  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
3908 
3912  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
3913 
3916  bool Empty() const;
3917 
3921  bool Equals(ExportPRCOptionsKit const & in_kit) const;
3922 
3926  bool operator==(ExportPRCOptionsKit const & in_kit) const;
3927 
3931  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
3932 
3933 
3939  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
3940 
3947  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
3948 
3954  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
3955 
3961  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
3962 
3967  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3968 
3974  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
3975 
3976 
3979  ExportPRCOptionsKit & UnsetTessellationCompression();
3980 
3983  ExportPRCOptionsKit & UnsetBRepCompression();
3984 
3987  ExportPRCOptionsKit & UnsetBRepRemoval();
3988 
3991  ExportPRCOptionsKit & UnsetAttributeRemoval();
3992 
3995  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
3996 
3999  ExportPRCOptionsKit & UnsetEverything();
4000 
4001 
4005  bool ShowTessellationCompression(bool & out_state) const;
4006 
4010  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4011 
4015  bool ShowBRepRemoval(bool & out_state) const;
4016 
4020  bool ShowAttributeRemoval(bool & out_state) const;
4021 
4025  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4026  };
4027 
4029  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4030  {
4031  public:
4034 
4037  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4038 
4042 
4043  virtual ~ExportSTLOptionsKit();
4044 
4045  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4046  HPS::Type ObjectType() const { return staticType; }
4047 
4051  static ExportSTLOptionsKit GetDefault();
4052 
4055  void Set(ExportSTLOptionsKit const & in_kit);
4056 
4059  void Show(ExportSTLOptionsKit & out_kit) const;
4060 
4064  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4065 
4069  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4070 
4073  bool Empty() const;
4074 
4078  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4079 
4083  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4084 
4088  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4089 
4090 
4096  ExportSTLOptionsKit & SetBinary(bool in_state);
4097 
4103  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4104 
4111  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4112 
4118  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4119 
4125  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4126 
4133  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4134 
4144  ExportSTLOptionsKit & SetUnits(Units in_units);
4145 
4146 
4149  ExportSTLOptionsKit & UnsetBinary();
4150 
4153  ExportSTLOptionsKit & UnsetTessellationLevel();
4154 
4157  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4158 
4161  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4162 
4165  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4166 
4169  ExportSTLOptionsKit & UnsetUnits();
4170 
4173  ExportSTLOptionsKit & UnsetEverything();
4174 
4175 
4179  bool ShowBinary(bool & out_state) const;
4180 
4188  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4189 
4193  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4194 
4198  bool ShowCurrentTessellationRetention(bool & out_state) const;
4199 
4203  bool ShowMaximumEdgeLength(double & out_length) const;
4204 
4208  bool ShowUnits(Units & out_units) const;
4209  };
4210 
4212  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4213  {
4214  public:
4217 
4220  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4221 
4225 
4226  virtual ~ExportU3DOptionsKit();
4227 
4228  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4229  HPS::Type ObjectType() const { return staticType; }
4230 
4234  static ExportU3DOptionsKit GetDefault();
4235 
4238  void Set(ExportU3DOptionsKit const & in_kit);
4239 
4242  void Show(ExportU3DOptionsKit & out_kit) const;
4243 
4247  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4248 
4252  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4253 
4256  bool Empty() const;
4257 
4261  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4262 
4266  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4267 
4271  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4272 
4273 
4279  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4280 
4285  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4286 
4287 
4290  ExportU3DOptionsKit & UnsetVersion();
4291 
4294  ExportU3DOptionsKit & UnsetCompression();
4295 
4298  ExportU3DOptionsKit & UnsetEverything();
4299 
4300 
4304  bool ShowVersion(U3D::Version & out_version) const;
4305 
4309  bool ShowCompression(unsigned char & out_level) const;
4310  };
4311 
4313  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4314  {
4315  public:
4318 
4321  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4322 
4326 
4327  virtual ~ExportXMLOptionsKit();
4328 
4329  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4330  HPS::Type ObjectType() const { return staticType; }
4331 
4335  static ExportXMLOptionsKit GetDefault();
4336 
4339  void Set(ExportXMLOptionsKit const & in_kit);
4340 
4343  void Show(ExportXMLOptionsKit & out_kit) const;
4344 
4348  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4349 
4353  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4354 
4357  bool Empty() const;
4358 
4362  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4363 
4367  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4368 
4372  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4373 
4374 
4380  ExportXMLOptionsKit & SetMetadata(bool in_state);
4381 
4387  ExportXMLOptionsKit & SetTransformations(bool in_state);
4388 
4394  ExportXMLOptionsKit & SetMaterials(bool in_state);
4395 
4396 
4399  ExportXMLOptionsKit & UnsetMetadata();
4400 
4403  ExportXMLOptionsKit & UnsetTransformations();
4404 
4407  ExportXMLOptionsKit & UnsetMaterials();
4408 
4411  ExportXMLOptionsKit & UnsetEverything();
4412 
4413 
4417  bool ShowMetadata(bool & out_state) const;
4418 
4422  bool ShowTransformations(bool & out_state) const;
4423 
4427  bool ShowMaterials(bool & out_state) const;
4428  };
4429 #endif
4430 
4431 #if !defined(TARGET_OS_ANDROID)
4432 
4433  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4434  {
4435  public:
4438 
4442 
4446 
4447  virtual ~ExportIGESOptionsKit();
4448 
4449  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4450  HPS::Type ObjectType() const { return staticType; }
4451 
4455  static ExportIGESOptionsKit GetDefault();
4456 
4459  void Set(ExportIGESOptionsKit const & in_kit);
4460 
4463  void Show(ExportIGESOptionsKit & out_kit) const;
4464 
4468  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4469 
4473  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4474 
4477  bool Empty() const;
4478 
4482  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4483 
4487  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4488 
4492  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4493 
4494 
4500  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4501 
4507  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4508 
4514  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4515 
4521  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4522 
4528  ExportIGESOptionsKit & SetTessellation(bool in_state);
4529 
4533  ExportIGESOptionsKit & SetApplication(char const * in_name);
4534 
4538  ExportIGESOptionsKit & SetVersion(char const * in_version);
4539 
4540 
4543  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4544 
4547  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
4548 
4551  ExportIGESOptionsKit & UnsetSolidsAsFaces();
4552 
4555  ExportIGESOptionsKit & UnsetHiddenObjects();
4556 
4559  ExportIGESOptionsKit & UnsetTessellation();
4560 
4563  ExportIGESOptionsKit & UnsetApplication();
4564 
4567  ExportIGESOptionsKit & UnsetVersion();
4568 
4571  ExportIGESOptionsKit & UnsetEverything();
4572 
4573 
4577  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4578 
4582  bool ShowFacetedAsWireframe(bool & out_state) const;
4583 
4587  bool ShowSolidsAsFaces(bool & out_state) const;
4588 
4592  bool ShowHiddenObjects(bool & out_state) const;
4593 
4597  bool ShowTessellation(bool & out_state) const;
4598 
4602  bool ShowApplication(UTF8 & out_name) const;
4603 
4607  bool ShowVersion(UTF8 & out_version) const;
4608  };
4609 
4611  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
4612  {
4613  public:
4616 
4620 
4624 
4625  virtual ~ExportParasolidOptionsKit();
4626 
4627  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
4628  HPS::Type ObjectType() const { return staticType; }
4629 
4633  static ExportParasolidOptionsKit GetDefault();
4634 
4637  void Set(ExportParasolidOptionsKit const & in_kit);
4638 
4641  void Show(ExportParasolidOptionsKit & out_kit) const;
4642 
4646  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4647 
4651  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4652 
4655  bool Empty() const;
4656 
4660  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4661 
4665  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4666 
4670  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4671 
4672 
4678  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4679 
4685  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4686 
4692  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4693 
4697  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4698 
4702  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4703 
4704 
4707  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4708 
4711  ExportParasolidOptionsKit & UnsetTessellation();
4712 
4715  ExportParasolidOptionsKit & UnsetHiddenObjects();
4716 
4719  ExportParasolidOptionsKit & UnsetApplication();
4720 
4723  ExportParasolidOptionsKit & UnsetVersion();
4724 
4727  ExportParasolidOptionsKit & UnsetEverything();
4728 
4729 
4733  bool ShowSolidsAsFaces(bool & out_state) const;
4734 
4738  bool ShowTessellation(bool & out_state) const;
4739 
4743  bool ShowHiddenObjects(bool & out_state) const;
4744 
4748  bool ShowApplication(UTF8 & out_name) const;
4749 
4753  bool ShowVersion(UTF8 & out_version) const;
4754  };
4755 
4757  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4758  {
4759  public:
4762 
4766 
4770 
4771  virtual ~ExportSTEPOptionsKit();
4772 
4773  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
4774  HPS::Type ObjectType() const { return staticType; }
4775 
4779  static ExportSTEPOptionsKit GetDefault();
4780 
4783  void Set(ExportSTEPOptionsKit const & in_kit);
4784 
4787  void Show(ExportSTEPOptionsKit & out_kit) const;
4788 
4792  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4793 
4797  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4798 
4801  bool Empty() const;
4802 
4806  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4807 
4811  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4812 
4816  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4817 
4818 
4824  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4825 
4831  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4832 
4838  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4839 
4845  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4846 
4850  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4851 
4855  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4856 
4860  ExportSTEPOptionsKit & SetPMI(bool in_state);
4861 
4865  ExportSTEPOptionsKit & SetCurves(bool in_state);
4866 
4870  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4871 
4872 
4875  ExportSTEPOptionsKit & UnsetFormat();
4876 
4879  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
4880 
4883  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
4884 
4887  ExportSTEPOptionsKit & UnsetNameShortening();
4888 
4891  ExportSTEPOptionsKit & UnsetApplication();
4892 
4895  ExportSTEPOptionsKit & UnsetVersion();
4896 
4899  ExportSTEPOptionsKit & UnsetPMI();
4900 
4903  ExportSTEPOptionsKit & UnsetCurves();
4904 
4907  ExportSTEPOptionsKit & UnsetAttributes();
4908 
4911  ExportSTEPOptionsKit & UnsetEverything();
4912 
4913 
4917  bool ShowFormat(STEP::Format & out_format) const;
4918 
4922  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4923 
4927  bool ShowFacetedAsWireframe(bool & out_state) const;
4928 
4932  bool ShowNameShortening(bool & out_state) const;
4933 
4937  bool ShowApplication(UTF8 & out_name) const;
4938 
4942  bool ShowVersion(UTF8 & out_version) const;
4943 
4947  bool ShowPMI(bool & out_state) const;
4948 
4952  bool ShowCurves(bool & out_state) const;
4953 
4957  bool ShowAttributes(bool & out_state) const;
4958  };
4959 #endif
4960 
4962  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
4963  {
4964  public:
4967 
4971 
4975 
4976  virtual ~TessellationOptionsKit();
4977 
4978  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
4979  HPS::Type ObjectType() const { return staticType; }
4980 
4984  static TessellationOptionsKit GetDefault();
4985 
4988  void Set(TessellationOptionsKit const & in_kit);
4989 
4992  void Show(TessellationOptionsKit & out_kit) const;
4993 
4997  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4998 
5002  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5003 
5006  bool Empty() const;
5007 
5011  bool Equals(TessellationOptionsKit const & in_kit) const;
5012 
5016  bool operator==(TessellationOptionsKit const & in_kit) const;
5017 
5021  bool operator!=(TessellationOptionsKit const & in_kit) const;
5022 
5023 
5027  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5028 
5035  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5036 
5042  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
5043 
5047  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5048 
5052  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5053 
5054 
5057  TessellationOptionsKit & UnsetLevel();
5058 
5061  TessellationOptionsKit & UnsetAccuracy();
5062 
5065  TessellationOptionsKit & UnsetUVPointPreservation();
5066 
5069  TessellationOptionsKit & UnsetMaximumEdgeLength();
5070 
5073  TessellationOptionsKit & UnsetEverything();
5074 
5075 
5083  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5084 
5089  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
5090 
5094  bool ShowUVPointPreservation(bool & out_state) const;
5095 
5099  bool ShowMaximumEdgeLength(double & out_length) const;
5100  };
5101 
5107  class EXCHANGE_API CommonMeasurementOperator : public Operator
5108  {
5109  public:
5110  enum class Tags
5111  {
5112  Name = 0,
5113  MeasurementType,
5114  Radius,
5115  Inverted,
5116  VectorX,
5117  VectorY,
5118  VectorZ,
5119  };
5120 
5122 
5123  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5124 
5126  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5127 
5128  virtual void OnViewAttached() override;
5129  virtual void OnViewDetached() override;
5130 
5131  Exchange::CADModel GetCADModel() const;
5132  void SetCADModel(Exchange::CADModel const & in_cad_model);
5133 
5135  size_t GetPrecision() const;
5136 
5139  void SetPrecision(size_t in_precision);
5140 
5142  MaterialMappingKit GetMaterial() const;
5143 
5146  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5147 
5149  TextAttributeKit GetTextAttributes() const;
5150 
5153  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5154 
5156  SegmentKey GetMeasurementSegment() const;
5157 
5159  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5160 
5161  /* Deletes all measurements */
5162  void DeleteMeasurements();
5163 
5164  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5165  {
5166  public:
5169  {
5170  channel = GetClassID();
5171  consumable = false;
5172  }
5173 
5174  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5175  {
5176  channel = GetClassID();
5177  consumable = false;
5178  measurement_key = in_measurement_key;
5179  view = in_view;
5180  }
5181 
5184  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5185  {
5186  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5187  {
5188  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5189  measurement_key = that.measurement_key;
5190  view = that.view;
5191  }
5192  else
5193  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5194  }
5195 
5197 
5200  Event * Clone() const
5201  {
5202  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5203  return new_event;
5204  }
5205 
5206  Key measurement_key;
5207  View view;
5208  };
5209 
5210  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5211  {
5212  public:
5215  {
5216  channel = GetClassID();
5217  consumable = false;
5218  }
5219 
5220  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5221  {
5222  channel = GetClassID();
5223  consumable = false;
5224  measurement_name = in_measurement_name;
5225  view = in_view;
5226  }
5227 
5230  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5231  {
5232  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5233  {
5234  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5235  measurement_name = that.measurement_name;
5236  view = that.view;
5237  }
5238  else
5239  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5240  }
5241 
5243 
5246  Event * Clone() const
5247  {
5248  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5249  return new_event;
5250  }
5251 
5252  UTF8 measurement_name;
5253  View view;
5254  };
5255 
5256  protected:
5257  Exchange::CADModel cad_model;
5258  size_t measurement_precision;
5259  UTF8 units;
5260  MaterialMappingKit materials;
5261  TextAttributeKit text_attributes;
5262  SegmentKey measurement_segment;
5263  GlyphDefinition left_arrow;
5264  GlyphDefinition right_arrow;
5265  SelectionOptionsKit selection_options;
5266  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5267  Vector camera_direction;
5268  PortfolioKey portfolio;
5269  SegmentKey style_segment;
5270  HighlightOptionsKit highlight_options;
5271 
5272  static size_t length_measurement_index;
5273  static size_t radius_measurement_index;
5274  static size_t distance_measurement_index;
5275  static size_t angle_measurement_index;
5276 
5277  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5278  void GetUnits();
5279  void SetGlyphColor();
5280  void GetCameraDirection();
5281  void SetupConstructionSegment();
5282  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5283  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5284  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5285  float GetModelScale(Exchange::Component const & component);
5286  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5287  };
5288 
5342  {
5343  public:
5344  enum class MeasurementType
5345  {
5346  PointToPoint,
5347  EdgeAndRadius,
5348  FeatureToFeature,
5349  FaceAngle,
5350  };
5351 
5353 
5354  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5355 
5357  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5358 
5359  virtual void OnViewAttached() override;
5360  virtual void OnViewDetached() override;
5361 
5366  virtual bool OnMouseDown(MouseState const & in_state) override;
5367 
5371  virtual bool OnMouseUp(MouseState const & in_state) override;
5372 
5378  virtual bool OnMouseMove(MouseState const & in_state) override;
5379 
5384  virtual bool OnTouchDown(TouchState const & in_state) override;
5385 
5389  virtual bool OnTouchUp(TouchState const & in_state) override;
5390 
5396  virtual bool OnTouchMove(TouchState const & in_state) override;
5397 
5401  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5402 
5403  /* Sets the type of measurement to insert.
5404  * \param in_measurement_type The type of measurement to insert.*/
5405  void SetMeasurementType(MeasurementType in_measurement_type);
5406 
5409  MeasurementType GetMeasurementType();
5410 
5411  /* Whether measurable geometry should be highlighted when mousing over it
5412  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
5413  void SetMouseOverHighlighting(bool in_highlighting);
5414 
5415  /* Whether measurable geometry should be highlighted when mousing over it
5416  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
5417  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
5418  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5419 
5420  /* Whether measurable geometry is highlighted when mousing over it
5421  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
5422  bool GetMouseOverHighlighting();
5423 
5424  /* Returns the highlight option kit currently used for mouse over highlighting.
5425  * \return the highlight option kit currently used for mouse over highlighting. */
5426  HighlightOptionsKit GetHighlightOptions();
5427 
5428  /* Whether a measurement is currently being inserted or edited.
5429  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
5430  bool IsMeasurementActive();
5431 
5432  /* Delete the current measurement and brings the operator back to a state to start a new measurement */
5433  void DeleteLastMeasurement();
5434 
5435  private:
5436  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5437  {
5438  Circle,
5439  Line,
5440  Generic,
5441  };
5442 
5443  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5444  {
5445  public:
5446  Surface();
5447 
5448  enum class SurfaceType
5449  {
5450  Plane,
5451  ConeOrCylinder,
5452  Unsupported,
5453  };
5454 
5455  SurfaceType surface_type; //the type of surface being measured
5456  Point center; //the center point of the surface
5457  Vector normal; //the center line of surfaces of type Cylinder or Cone
5458  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5459  ComponentPath path; //the component path to this surface
5460  };
5461 
5462  //bookkeeping
5463  MeasurementType measurement_type; //the type of measurement to be inserted
5464  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5465  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5466  TouchID current_touch_id; //the ID of the touch being processed
5467  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5468  bool operator_active; //whether a measurement is in progress
5469  bool end_measurement; //whether we should end the current measurement
5470  CanvasArray canvases; //canvases related to the view where this operator is attached
5471 
5472  //measurement anchors
5473  size_t anchors; //valid for point-to-point and face-angle measurements
5474  bool anchors_in_place; //true if all the anchors have been placed
5475  Point first_click_position; //position of the first anchor
5476  Point second_click_position; //position of the second anchor
5477 
5478  //geometry for linear measurements
5479  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5480  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5481  LineKey distance_line; //a line representing the distance measured
5482  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5483  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5484  Point distance_point_one; //intersection of leader_line_one and distance_line
5485  Point distance_point_two; //intersection of leader_line_two and distance_line
5486  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5487  TextKey text; //text representing the measurement and units
5488  UTF8 text_string; //the contents of the text
5489  Vector measurement_direction; //the direction of the measurement
5490  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5491  Vector explicit_direction; //used if use_explicit_direction is true
5492 
5493  //geometry for radius measurement
5494  MarkerKey center_marker; //marker representing the center of the circle
5495  Point circle_center; //circle center
5496  float radius; //circle radius
5497 
5498  //edge specific data
5499  LineKey edge_line; //the edge being measured
5500  double edge_length; //length of the measured edge
5501  EdgeType edge_type; //the type of edge being measured
5502 
5503  //feature-to-feature specific data
5504  Surface surface_one; //data related to first selected surface
5505  Surface surface_two; //data related to second selected surface
5506  Plane measurement_plane; //the measurement plane
5507  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5508 
5509  //angle specific data
5510  Vector leader_line_one_direction; //the direction of the first leader line
5511  Vector leader_line_two_direction; //the direction of the second leader line
5512  Vector first_face_normal; //the normal of the first selected face
5513  Vector second_face_normal; //the normal of the second selected face
5514  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'
5515  CircularArcKey measurement_arc; //an arc representing the measured angle
5516  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5517  Vector mid_point_direction;
5518 
5519  //selection kits
5520  SelectionOptionsKit point_to_point_selection;
5521  SelectionOptionsKit edge_radius_selection;
5522  SelectionOptionsKit feature_to_feature_selection;
5523  SelectionOptionsKit angle_selection;
5524 
5525  //highlighting
5526  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5527  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5528  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5529  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5530  KeyPath highlighted_path; //highlighted_path
5531  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5532  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5533 
5534  //input handling
5535  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5536  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5537  bool InputUp(WindowKey & in_window);
5538  void ResetMeasurement();
5539 
5540  //inserting measurements
5541  void InsertPointToPointMeasurement(Point const & in_world_point);
5542  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5543  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5544  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5545  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5546  void InvertMeasuredAngle(WindowKey & in_window);
5547  void AdjustLineToCursor(Point const & cursor_position);
5548 
5549  //saving measurements
5550  void TagMeasurement();
5551  void TagPointToPointMeasurement();
5552  void TagEdgeMeasurement();
5553  void TagRadiusMeasurement();
5554  void TagGenericEdgeMeasurement();
5555  void TagFeatureToFeatureMeasurement();
5556  void TagAngleMeasurement();
5557 
5558  //restoring measurements
5559  void RestoreMeasurement(SegmentKey const & measurement_segment);
5560  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5561  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5562  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5563  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5564  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5565  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5566  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5567 
5568  //topology functions
5569  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5570  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5571  void PlaneToCenterLineDistance();
5572  void PlaneToPlaneDistance();
5573  void LineToLineDistance();
5574  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);
5575  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5576  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5577  bool IsPlane(Exchange::Component const & face_component);
5578  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5579  };
5580 
5581 private:
5583  Exchange();
5584 };
5585 
5586 }
5587 
5588 #endif
Definition: hps.h:6208
Definition: sprk_exchange.h:3872
Level
Definition: sprk_exchange.h:865
ConstructionEntities
Definition: sprk_exchange.h:1025
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:976
Definition: sprk.h:267
Definition: sprk_exchange.h:1142
Definition: sprk_exchange.h:5107
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5823
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2931
Definition: sprk.h:100
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5126
Definition: sprk_exchange.h:607
Version
Definition: sprk_exchange.h:1046
Definition: sprk_exchange.h:3204
Definition: sprk_exchange.h:875
Definition: sprk_exchange.h:708
SurfaceType
Definition: sprk_exchange.h:797
Definition: hps.h:1732
Format
Definition: sprk_exchange.h:963
Definition: sprk_exchange.h:4313
Definition: sprk.h:236
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6674
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6650
Definition: hps.h:47626
Format
Definition: sprk_exchange.h:1147
Definition: hps.h:7714
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6644
Type
Definition: sprk_exchange.h:856
Definition: hps.h:16084
Definition: sprk_exchange.h:461
Definition: sprk_exchange.h:546
Definition: sprk_exchange.h:302
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5184
Definition: sprk_exchange.h:1391
Definition: sprk_exchange.h:242
Definition: sprk_exchange.h:3738
Merging
Definition: sprk_exchange.h:2940
Field
Definition: sprk_exchange.h:953
Definition: hps.h:47524
Definition: hps.h:41116
Definition: sprk_exchange.h:3636
Definition: sprk_exchange.h:2953
Limit
Definition: sprk_exchange.h:880
Definition: hps.h:4509
TessellationLevel
Definition: sprk_exchange.h:927
Definition: sprk_exchange.h:851
Definition: sprk_exchange.h:4029
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:948
Definition: hps.h:4448
Definition: hps.h:7085
Definition: hps.h:46995
Definition: sprk_exchange.h:415
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:43108
Definition: hps.h:47411
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:844
Definition: sprk_exchange.h:4212
Definition: sprk_exchange.h:913
Definition: hps.h:15474
Event * Clone() const
Definition: sprk_exchange.h:5246
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6630
intptr_t GetChannel() const
Definition: hps.h:6325
Definition: sprk_exchange.h:1041
SessionColor
Definition: sprk_exchange.h:1000
Definition: sprk.h:1739
Definition: hps.h:47733
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:44237
Definition: hps.h:46502
CurveType
Definition: sprk_exchange.h:820
Definition: sprk_exchange.h:506
Definition: hps.h:6292
Definition: hps.h:13721
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6642
Definition: sprk_exchange.h:5341
Definition: sprk.h:481
BRepCompression
Definition: sprk_exchange.h:981
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:770
Definition: sprk.h:2065
ComponentType
Definition: sprk.h:1755
Accuracy
Definition: sprk_exchange.h:897
Definition: sprk_exchange.h:3489
Definition: sprk_exchange.h:4433
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5230
Definition: sprk.h:2447
FamilyTable
Definition: sprk_exchange.h:1013
Content
Definition: sprk_exchange.h:918
Definition: sprk_exchange.h:1616
Definition: sprk.h:2547
static MouseButtons ButtonLeft()
Definition: hps.h:47113
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5357
Definition: hps.h:7632
Definition: sprk_exchange.h:995
AccurateEdges
Definition: sprk_exchange.h:2922
Event * Clone() const
Definition: sprk_exchange.h:5200
Definition: hps.h:9328
Definition: sprk_exchange.h:661
Definition: hps.h:23944
Healing
Definition: sprk_exchange.h:2913
Definition: sprk.h:2634
Definition: hps.h:30377
ImportMode
Definition: sprk_exchange.h:785
Definition: sprk_exchange.h:1058
Definition: hps.h:511
Definition: sprk.h:1104
Definition: sprk_exchange.h:2908
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:4611
Definition: sprk_exchange.h:176
Definition: hps.h:40612
Version
Definition: sprk_exchange.h:936
Definition: sprk_exchange.h:4962
Definition: hps.h:41731
Definition: sprk_exchange.h:4757