API Search || Global Search
sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180  };
181 
182  class EXCHANGE_API ProductOccurrence : public Exchange::Component
183  {
184  public:
187 
191  ProductOccurrence(HPS::Component const & in_that);
192 
196  ProductOccurrence(Component const & in_that);
197 
200  ProductOccurrence(ProductOccurrence const & in_sheet);
201 
206 
210  ProductOccurrence & operator=(ProductOccurrence && in_that);
211 
212  virtual ~ProductOccurrence();
213 
214  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
215  HPS::Type ObjectType() const { return staticType; }
216 
220  bool Equals(ProductOccurrence const & in_kit) const;
221 
225  bool operator==(ProductOccurrence const & in_kit) const;
226 
230  bool operator!=(ProductOccurrence const & in_kit) const;
231 
237  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
238 
244  LoadStatus GetLoadStatus() const;
245  };
246 
248  class EXCHANGE_API Sheet : public Exchange::Component
249  {
250  public:
252  Sheet();
253 
257  Sheet(HPS::Component const & in_that);
258 
262  Sheet(Component const & in_that);
263 
266  Sheet(Sheet const & in_sheet);
267 
271  Sheet(Sheet && in_that);
272 
276  Sheet & operator=(Sheet && in_that);
277 
278  virtual ~Sheet();
279 
280  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
281  HPS::Type ObjectType() const { return staticType; }
282 
286  bool Equals(Sheet const & in_kit) const;
287 
288 #if !defined(_MSC_VER) || _MSC_VER >= 1900
289  Sheet & operator=(Sheet const & in_that) = default;
290 #endif
291 
295  bool operator==(Sheet const & in_kit) const;
296 
300  bool operator!=(Sheet const & in_kit) const;
301 
302  /* Activates this sheet */
303  HPS::View Activate();
304  };
305 
308  class EXCHANGE_API CADModel : public HPS::CADModel
309  {
310  public:
312  CADModel();
313 
317  CADModel(Component const & in_that);
318 
322  CADModel(HPS::CADModel const & in_that);
323 
326  CADModel(Exchange::CADModel const & in_that);
327 
330  CADModel(Exchange::CADModel && in_that);
331 
332  virtual ~CADModel();
333 
334  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
335  HPS::Type ObjectType() const { return staticType; }
336 
337 #if !defined(_MSC_VER) || _MSC_VER >= 1900
338  CADModel & operator=(Exchange::CADModel const & in_that) = default;
339 #endif
340 
344  CADModel & operator=(Exchange::CADModel && in_that);
345 
346 
349  A3DEntity * GetExchangeEntity() const;
350 
354  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
355 
361  bool GetEntityOwnership() const;
362 
363 
367  UTF8Array GetCurrentConfiguration() const;
368 
372  ConfigurationArray GetConfigurations() const;
373 
374  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
375  * \return The list of sheets for this CADModel */
376  SheetArray GetSheets() const;
377 
383  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
384 
389  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
390 
396  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
397 
403  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
404 
410  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
411 
416  void Tessellate(TessellationOptionsKit const & in_options);
417  };
418 
421  class EXCHANGE_API Capture : public HPS::Capture
422  {
423  public:
425  Capture();
426 
430  Capture(Component const & in_that);
431 
435  Capture(HPS::Capture const & in_that);
436 
439  Capture(Exchange::Capture const & in_that);
440 
443  Capture(Exchange::Capture && in_that);
444 
445  virtual ~Capture();
446 
447  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
448  HPS::Type ObjectType() const { return staticType; }
449 
450 #if !defined(_MSC_VER) || _MSC_VER >= 1900
451  Capture & operator=(Exchange::Capture const & in_that) = default;
452 #endif
453 
457  Capture & operator=(Exchange::Capture && in_that);
458 
459 
462  A3DEntity * GetExchangeEntity() const;
463  };
464 
467  class EXCHANGE_API Filter : public HPS::Filter
468  {
469  public:
471  Filter();
472 
476  Filter(Component const & in_that);
477 
481  Filter(HPS::Filter const & in_that);
482 
485  Filter(Exchange::Filter const & in_that);
486 
489  Filter(Exchange::Filter && in_that);
490 
491  virtual ~Filter();
492 
493  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
494  HPS::Type ObjectType() const { return staticType; }
495 
496 #if !defined(_MSC_VER) || _MSC_VER >= 1900
497  Filter & operator=(Exchange::Filter const & in_that) = default;
498 #endif
499 
503  Filter & operator=(Exchange::Filter && in_that);
504 
505 
508  A3DEntity * GetExchangeEntity() const;
509  };
510 
512  class EXCHANGE_API Factory : public Sprocket
513  {
514  public:
519  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
520 
526  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
527 
531  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
532 
539  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
540 
544  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
545 
550  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
551 
552  private:
554  Factory();
555  };
556 
558  class EXCHANGE_API ImportNotifier : public IONotifier
559  {
560  public:
562  ImportNotifier();
563 
566  ImportNotifier(ImportNotifier const & in_that);
567 
572  ImportNotifier(IONotifier const & in_that);
573 
577  ImportNotifier(ImportNotifier && in_that);
578 
582  ImportNotifier & operator=(ImportNotifier && in_that);
583 
584  virtual ~ImportNotifier();
585 
586  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
587  HPS::Type ObjectType() const { return staticType; };
588 
592  ImportNotifier & operator=(ImportNotifier const & in_that);
593 
596  void Assign(ImportNotifier const & in_that);
597 
600  Exchange::CADModel GetCADModel() const;
601 
607  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
608 
611  Time GetImportTime() const;
612 
615  Time GetParseTime() const;
616  };
617 
619  class EXCHANGE_API TranslationNotifier : public IONotifier
620  {
621  public:
624 
627  TranslationNotifier(TranslationNotifier const & in_that);
628 
633  TranslationNotifier(IONotifier const & in_that);
634 
639 
643  TranslationNotifier & operator=(TranslationNotifier && in_that);
644 
645  virtual ~TranslationNotifier();
646 
647  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
648  HPS::Type ObjectType() const { return staticType; };
649 
653  TranslationNotifier & operator=(TranslationNotifier const & in_that);
654 
657  void Assign(TranslationNotifier const & in_that);
658 
661  Exchange::ParasolidEntityArray GetParasolidParts() const;
662 
665  HPS::Time GetImportTime() const;
666 
669  HPS::Time GetTranslationTime() const;
670  };
671 
673  class EXCHANGE_API ExportNotifier : public IONotifier
674  {
675  public:
677  ExportNotifier();
678 
681  ExportNotifier(ExportNotifier const & in_that);
682 
687  ExportNotifier(IONotifier const & in_that);
688 
692  ExportNotifier(ExportNotifier && in_that);
693 
697  ExportNotifier & operator=(ExportNotifier && in_that);
698 
699  virtual ~ExportNotifier();
700 
701  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
702  HPS::Type ObjectType() const { return staticType; };
703 
707  ExportNotifier & operator=(ExportNotifier const & in_that);
708 
711  void Assign(ExportNotifier const & in_that);
712 
716  A3DAsmModelFile * GetModelFile() const;
717  };
718 
720  class EXCHANGE_API ReloadNotifier : public IONotifier
721  {
722  public:
724  ReloadNotifier();
725 
728  ReloadNotifier(ReloadNotifier const & in_that);
729 
734  ReloadNotifier(IONotifier const & in_that);
735 
739  ReloadNotifier(ReloadNotifier && in_that);
740 
744  ReloadNotifier & operator=(ReloadNotifier && in_that);
745 
746  virtual ~ReloadNotifier();
747 
748  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
749  HPS::Type ObjectType() const { return staticType; };
750 
754  ReloadNotifier & operator=(ReloadNotifier const & in_that);
755 
758  void Assign(ReloadNotifier const & in_that);
759  };
760 
761 
762  class ImportOptionsKit;
764 
765 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
766  class Export3MFOptionsKit;
767  class ExportACISOptionsKit;
768  class ExportJTOptionsKit;
769  class ExportPRCOptionsKit;
770  class ExportSTLOptionsKit;
771  class ExportU3DOptionsKit;
772  class ExportXMLOptionsKit;
773 #endif
774 
775 #if !defined(TARGET_OS_ANDROID)
776  class ExportSTEPOptionsKit;
777  class ExportIGESOptionsKit;
778 #endif
779 
782  enum class BRepMode
783  {
786  TessellationOnly,
789  BRepOnly,
792  BRepAndTessellation,
793  };
794 
797  enum class ImportMode
798  {
801  Complete,
804  Incremental,
805  };
806 
809  enum class SurfaceType
810  {
811  Blend01,
812  Blend02,
813  Blend03,
814  Blend04,
815  NURBS,
816  Cone,
817  Cylinder,
818  Offset,
819  Pipe,
820  Plane,
821  Ruled,
822  Sphere,
823  Revolution,
824  Extrusion,
825  FromCurve,
826  Torus,
827  Transform,
828  };
829 
832  enum class CurveType
833  {
834  Blend,
835  NURBS,
836  Circle,
837  Composite,
838  CurveOnSurface,
839  Ellipse,
840  Equation,
841  Helix,
842  Hyperbola,
843  Intersection,
844  Line,
845  Offset,
846  Parabola,
847  Polyline,
848  Transform,
849  };
850 
851  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
852  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
853 
857  {
858  PMIOnly,
859  ModelAndPMI
860  };
861 
863  class EXCHANGE_API Tessellation
864  {
865  public:
868  enum class Type
869  {
870  Standard,
871  Custom
872  };
873 
874 
877  enum class Level
878  {
879  ExtraLow,
880  Low,
881  Medium,
882  High,
883  ExtraHigh,
884  };
885 
887  class EXCHANGE_API Chord
888  {
889  public:
892  enum class Limit
893  {
896  Ratio,
899  Height
900  };
901 
902  private:
904  Chord();
905  };
906 
909  enum class Accuracy
910  {
913  Standard,
916  Accurate,
918  GridAccurate
919  };
920 
921  private:
923  Tessellation();
924  };
925 
927  class EXCHANGE_API JT
928  {
929  public:
932  enum class Content
933  {
934  Geometry,
935  Tessellation,
936  GeometryAndTessellation
937  };
938 
941  enum class TessellationLevel
942  {
943  Low,
944  Medium,
945  High,
946  };
947 
950  enum class Version
951  {
952  JT81,
953  JT95,
954  };
955 
956  private:
958  JT();
959  };
960 
962  class EXCHANGE_API STEP
963  {
964  public:
967  enum class Field
968  {
969  ProductName,
970  NextAssemblyUsageOccurrenceID,
971  NextAssemblyUsageOccurrenceName,
972  NextAssemblyUsageOccurrenceDescription
973  };
974 
977  enum class Format
978  {
979  AP203,
980  AP214,
981  AP242,
982  };
983 
984  private:
986  STEP();
987  };
988 
990  class EXCHANGE_API PRC
991  {
992  public:
995  enum class BRepCompression
996  {
997  None,
998  Low,
999  Medium,
1000  High
1001  };
1002 
1003  private:
1005  PRC();
1006  };
1007 
1009  class EXCHANGE_API ProE
1010  {
1011  public:
1014  enum class SessionColor
1015  {
1017  LastCreoVersion,
1019  ExchangeDefault,
1022  UserDefined
1023  };
1024 
1027  enum class FamilyTable
1028  {
1030  BRepOnly,
1032  BRepOrTessellation,
1034  BRepOrTessellationOrGeneric
1035  };
1036 
1040  {
1042  On,
1044  Off,
1046  AsDatum,
1047  };
1048 
1049  private:
1051  ProE();
1052  };
1053 
1055  class EXCHANGE_API U3D
1056  {
1057  public:
1060  enum class Version
1061  {
1062  ECMA1,
1063  ECMA3
1064  };
1065 
1066  private:
1068  U3D();
1069  };
1070 
1072  class EXCHANGE_API Configuration : public HPS::Sprocket
1073  {
1074  public:
1076  Configuration();
1077 
1080  Configuration(char const * in_name);
1081 
1086  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1087 
1091  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1092 
1095  Configuration(Configuration const & in_configuration);
1096 
1100  Configuration(Configuration && in_that);
1101 
1105  Configuration & operator=(Configuration && in_that);
1106 
1107  virtual ~Configuration();
1108 
1109  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1110  HPS::Type ObjectType() const { return staticType; }
1111 
1112 
1115  void Set(Configuration const & in_kit);
1116 
1119  void Show(Configuration & out_kit) const;
1120 
1124  Configuration & operator=(Configuration const & in_kit);
1125 
1128  bool Empty() const;
1129 
1133  bool Equals(Configuration const & in_kit) const;
1134 
1138  bool operator==(Configuration const & in_kit) const;
1139 
1143  bool operator!=(Configuration const & in_kit) const;
1144 
1145 
1148  HPS::UTF8 GetName() const;
1149 
1152  ConfigurationArray GetSubconfigurations() const;
1153  };
1154 
1156  class EXCHANGE_API File
1157  {
1158  public:
1161  enum class Format
1162  {
1163  Unsupported,
1164  ACIS,
1165  CADDS,
1166  CATIAV4,
1167  CATIAV5,
1168  CGR,
1169  COLLADA,
1170  CreoProE,
1171  DWG,
1172  DXF,
1173  IDEAS,
1174  IFC,
1175  IGES,
1176  Inventor,
1177  JT,
1178  KeyholeMarkupLanguage,
1179  LatticeXVL,
1180  OneSpaceDesigner,
1181  Parasolid,
1182  PDF,
1183  PRC,
1184  Rhino,
1185  NXUnigraphics,
1186  SolidEdge,
1187  SolidWorks,
1188  STEP,
1189  StereoLithography,
1190  ThreeDStudioMax,
1191  ThreeDXML,
1192  Universal3D,
1193  VDAFS,
1194  VRML,
1195  WavefrontObject,
1196  Revit,
1197  GLTF,
1198  DWF,
1199  FBX,
1200  };
1201 
1203  static Format GetFormat(char const * in_file_name);
1204 
1208  static ConfigurationArray GetConfigurations(char const * in_file_name);
1209 
1221  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);
1222 
1228  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1229 
1236  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1237 
1244  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1245 
1253  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1254 
1261  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1262 
1263 
1270  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1271 
1272 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1273 
1277  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1278 
1284  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1285 
1292  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1293 
1299  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1300 
1305  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1306 
1311  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1312 
1318  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1319 
1325  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1326 
1333  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1334 
1341  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1342 
1346  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1347 
1352  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1353 
1357  static ExportNotifier ExportPRC(KeyPath const & in_source);
1358 
1363  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1364 
1369  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1370 
1374  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1375 
1380  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1381 #endif
1382 
1383 #if TARGET_OS_ANDROID == 0
1384 
1388  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1389 
1394  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1395 
1400  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1401 #endif
1402 
1403  private:
1405  File();
1406  };
1407 
1409  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1410  {
1411  public:
1414 
1418 
1423 
1427  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1428 
1429  virtual ~NURBSConversionOptionsKit();
1430 
1431  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1432  HPS::Type ObjectType() const { return staticType; }
1433 
1436  void Set(NURBSConversionOptionsKit const & in_kit);
1437 
1440  void Show(NURBSConversionOptionsKit & out_kit) const;
1441 
1445  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1446 
1449  bool Empty() const;
1450 
1454  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1455 
1459  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1460 
1464  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1465 
1469  static NURBSConversionOptionsKit GetDefault();
1470 
1475  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1476 
1481  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1482 
1487  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1488 
1493  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1494 
1499  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1500 
1505  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1506 
1511  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1512 
1518  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1519 
1526  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1527 
1533  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1534 
1541  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1542 
1543 
1546  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1547 
1550  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1551 
1554  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1555 
1558  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1559 
1562  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1563 
1566  NURBSConversionOptionsKit & UnsetParameterization();
1567 
1570  NURBSConversionOptionsKit & UnsetTolerance();
1571 
1574  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1575 
1578  NURBSConversionOptionsKit & UnsetAllowedCurves();
1579 
1582  NURBSConversionOptionsKit & UnsetEverything();
1583 
1584 
1585 
1589  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1590 
1594  bool Show3DCurvesComputation(bool & out_state) const;
1595 
1600  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1601 
1605  bool ShowClosedFaceSplitting(bool & out_state) const;
1606 
1610  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1611 
1615  bool ShowParameterization(bool & out_state) const;
1616 
1620  bool ShowTolerance(double & out_tolerance) const;
1621 
1625  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1626 
1630  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1631  };
1632 
1634  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1635  {
1636  public:
1638  ImportOptionsKit();
1639 
1642  ImportOptionsKit(ImportOptionsKit const & in_kit);
1643 
1647  ImportOptionsKit(ImportOptionsKit && in_that);
1648 
1652  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1653 
1654  virtual ~ImportOptionsKit();
1655 
1656  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1657  HPS::Type ObjectType() const { return staticType; }
1658 
1662  static ImportOptionsKit GetDefault();
1663 
1666  void Set(ImportOptionsKit const & in_kit);
1667 
1670  void Show(ImportOptionsKit & out_kit) const;
1671 
1675  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1676 
1679  bool Empty() const;
1680 
1684  bool Equals(ImportOptionsKit const & in_kit) const;
1685 
1689  bool operator==(ImportOptionsKit const & in_kit) const;
1690 
1694  bool operator!=(ImportOptionsKit const & in_kit) const;
1695 
1696 
1702  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1703 
1709  ImportOptionsKit & SetSolids(bool in_state);
1710 
1716  ImportOptionsKit & SetSurfaces(bool in_state);
1717 
1723  ImportOptionsKit & SetWireframes(bool in_state);
1724 
1730  ImportOptionsKit & SetPMI(bool in_state);
1731 
1738  ImportOptionsKit & SetAttributes(bool in_state);
1739 
1745  ImportOptionsKit & SetHiddenObjects(bool in_state);
1746 
1752  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1753 
1759  ImportOptionsKit & SetActiveFilter(bool in_state);
1760 
1768  ImportOptionsKit & SetFeatureTrees(bool in_state);
1769 
1775  ImportOptionsKit & SetDrawings(bool in_state);
1776 
1782  ImportOptionsKit & SetDefaultUnits(Units in_units);
1783 
1788  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1789 
1795  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1796 
1803  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1804 
1810  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1811 
1817  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1818 
1826  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1827 
1834  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1835 
1843  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1844 
1850  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1851 
1857  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1858 
1865  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1866 
1878  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
1879 
1885  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1886 
1892  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1893 
1899  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1900 
1905  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1906 
1913  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1914 
1920  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1921 
1930  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1931 
1940  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1941 
1947  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1948 
1953  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1954 
1961  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
1962 
1967  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1968 
1974  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1975 
1980  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1981 
1987  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1988 
1995  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1996 
2003  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2004 
2012  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2013 
2020  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2021 
2027  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2028 
2034  ImportOptionsKit & SetProECodePageName(char const * in_name);
2035 
2041  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2042 
2048  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2049 
2055  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2056 
2063  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2064 
2071  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2072 
2079  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2080 
2087  ImportOptionsKit & SetProEHomeView(bool in_state);
2088 
2095  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2096 
2103  ImportOptionsKit & SetProEDatum(bool in_state);
2104 
2105 
2112  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2113 
2120  ImportOptionsKit & SetProESkeletons(bool in_state);
2121 
2128  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2129 
2135  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2136 
2142  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2143 
2149  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2150 
2156  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2157 
2163  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2164 
2170  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2171 
2178  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2179 
2185  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2186 
2192  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2193 
2200  ImportOptionsKit & SetIFCEdges(bool in_state);
2201 
2207  ImportOptionsKit & SetIFCMetadata(bool in_state);
2208 
2214  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2215 
2221  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2222 
2228  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2229 
2235  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2236 
2242  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2243 
2250  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2251 
2255  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2256 
2268  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2269 
2281  ImportOptionsKit & SetMode(ImportMode in_mode);
2282 
2292  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2293 
2301  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2302 
2309  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2310 
2314  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2315 
2320  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2321 
2324  ImportOptionsKit & UnsetBRepMode();
2325 
2328  ImportOptionsKit & UnsetSolids();
2329 
2332  ImportOptionsKit & UnsetSurfaces();
2333 
2336  ImportOptionsKit & UnsetWireframes();
2337 
2340  ImportOptionsKit & UnsetPMI();
2341 
2344  ImportOptionsKit & UnsetAttributes();
2345 
2348  ImportOptionsKit & UnsetHiddenObjects();
2349 
2352  ImportOptionsKit & UnsetConstructionAndReferences();
2353 
2356  ImportOptionsKit & UnsetActiveFilter();
2357 
2360  ImportOptionsKit & UnsetDrawings();
2361 
2364  ImportOptionsKit & UnsetFeatureTrees();
2365 
2368  ImportOptionsKit & UnsetSewingTolerance();
2369 
2372  ImportOptionsKit & UnsetDefaultUnits();
2373 
2376  ImportOptionsKit & UnsetMultiProcessCount();
2377 
2380  ImportOptionsKit & UnsetPMISubstitutionFont();
2381 
2384  ImportOptionsKit & UnsetPMIPrecision();
2385 
2388  ImportOptionsKit & UnsetPMIDefaultUnits();
2389 
2392  ImportOptionsKit & UnsetPMIDefaultColor();
2393 
2396  ImportOptionsKit & UnsetTessellationLevel();
2397 
2400  ImportOptionsKit & UnsetTessellationAccuracy();
2401 
2404  ImportOptionsKit & UnsetTessellationCleanup();
2405 
2408  ImportOptionsKit & UnsetPMIFlipping();
2409 
2412  ImportOptionsKit & UnsetRemovedViews();
2413 
2416  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2417 
2420  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2421 
2424  ImportOptionsKit & UnsetTextureDirectories();
2425 
2428  ImportOptionsKit & UnsetSearchDirectories();
2429 
2432  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2433 
2436  ImportOptionsKit & UnsetSearchRootDirectory();
2437 
2440  ImportOptionsKit & UnsetConfiguration();
2441 
2444  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2445 
2448  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2449 
2452  ImportOptionsKit & UnsetCatiaV5Cache();
2453 
2456  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2457 
2460  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2461 
2464  ImportOptionsKit & UnsetProECodePageName();
2465 
2468  ImportOptionsKit & UnsetProEDimensionTolerance();
2469 
2472  ImportOptionsKit & UnsetProESubpartPMI();
2473 
2476  ImportOptionsKit & UnsetProESessionColor();
2477 
2480  ImportOptionsKit & UnsetProEDatum();
2481 
2484  ImportOptionsKit & UnsetProEHomeView();
2485 
2488  ImportOptionsKit & UnsetProEExplodedViews();
2489 
2492  ImportOptionsKit & UnsetProEMissingBoolean();
2493 
2496  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2497 
2500  ImportOptionsKit & UnsetProEFamilyTreeSource();
2501 
2504  ImportOptionsKit & UnsetProEConstructionEntities();
2505 
2508  ImportOptionsKit & UnsetProESkeletons();
2509 
2512  ImportOptionsKit & UnsetSTEPNamePreference();
2513 
2516  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2517 
2520  ImportOptionsKit & UnsetSTEPCodePageName();
2521 
2524  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2525 
2528  ImportOptionsKit & UnsetSTEPOrientationHealing();
2529 
2532  ImportOptionsKit & UnsetSTEPValidationProperties();
2533 
2536  ImportOptionsKit & UnsetIFCCodePageName();
2537 
2540  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2541 
2544  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2545 
2548  ImportOptionsKit & UnsetIFCFaceOptimization();
2549 
2552  ImportOptionsKit & UnsetIFCEdges();
2553 
2556  ImportOptionsKit & UnsetIFCMetadata();
2557 
2560  ImportOptionsKit & UnsetPDF3DStreamIndex();
2561 
2564  ImportOptionsKit & UnsetJTTessellationLevel();
2565 
2568  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2569 
2572  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2573 
2576  ImportOptionsKit & UnsetPRCReadHelper();
2577 
2580  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2581 
2584  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2585 
2588  ImportOptionsKit & UnsetLocation();
2589 
2592  ImportOptionsKit & UnsetMode();
2593 
2596  ImportOptionsKit & UnsetIncrementalComponentPaths();
2597 
2600  ImportOptionsKit & UnsetNURBSConversion();
2601 
2604  ImportOptionsKit & UnsetGeometryDefaultColor();
2605 
2608  ImportOptionsKit & UnsetEverything();
2609 
2613  bool ShowBRepMode(BRepMode & out_mode) const;
2614 
2618  bool ShowSolids(bool & out_state) const;
2619 
2623  bool ShowSurfaces(bool & out_state) const;
2624 
2628  bool ShowWireframes(bool & out_state) const;
2629 
2633  bool ShowPMI(bool & out_state) const;
2634 
2638  bool ShowAttributes(bool & out_state) const;
2639 
2643  bool ShowHiddenObjects(bool & out_state) const;
2644 
2648  bool ShowConstructionAndReferences(bool & out_state) const;
2649 
2653  bool ShowActiveFilter(bool & out_state) const;
2654 
2658  bool ShowDrawings(bool & out_state) const;
2659 
2663  bool ShowFeatureTrees(bool & out_state) const;
2664 
2668  bool ShowSewingTolerance(double & out_tolerance) const;
2669 
2673  bool ShowDefaultUnits(Units & out_units) const;
2674 
2678  bool ShowMultiProcessCount(unsigned int & out_count) const;
2679 
2684  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2685 
2689  bool ShowPMIPrecision(size_t & out_precision) const;
2690 
2694  bool ShowPMIDefaultUnits(Units & out_units) const;
2695 
2700  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2701 
2709  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2710 
2717  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2718 
2722  bool ShowTessellationCleanup(bool & out_cleanup) const;
2723 
2727  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2728 
2732  bool ShowRemovedViews(bool & out_read_removed_views) const;
2733 
2737  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2738 
2742  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2743 
2747  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2748 
2754  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2755 
2759  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2760 
2765  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2766 
2770  bool ShowConfiguration(UTF8Array & out_configuration) const;
2771 
2775  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2776 
2780  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2781 
2786  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2787 
2792  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2793 
2797  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2798 
2802  bool ShowProECodePageName(UTF8 & out_name) const;
2803 
2807  bool ShowProEDimensionTolerance(bool & out_state) const;
2808 
2812  bool ShowProESubpartPMI(bool & out_state) const;
2813 
2817  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2818 
2822  bool ShowProEDatum(bool & out_state) const;
2823 
2827  bool ShowProEHomeView(bool & out_state) const;
2828 
2832  bool ShowProEExplodedViews(bool & out_state) const;
2833 
2837  bool ShowProEMissingBoolean(bool & out_state) const;
2838 
2842  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2843 
2847  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2848 
2852  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2853 
2857  bool ShowProESkeletons(bool & out_state) const;
2858 
2862  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2863 
2867  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2868 
2872  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2873 
2877  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2878 
2882  bool ShowSTEPOrientationHealing(bool & out_state) const;
2883 
2887  bool ShowSTEPValidationProperties(bool & out_state) const;
2888 
2892  bool ShowIFCCodePageName(UTF8 & out_name) const;
2893 
2897  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2898 
2902  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2903 
2907  bool ShowIFCFaceOptimization(bool & out_state) const;
2908 
2912  bool ShowIFCEdges(bool & out_state) const;
2913 
2917  bool ShowIFCMetadata(bool & out_state) const;
2918 
2922  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2923 
2927  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2928 
2932  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
2933 
2937  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2938 
2942  bool ShowPRCReadHelper(bool & out_use_helper) const;
2943 
2947  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
2948 
2952  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2953 
2958  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2959 
2963  bool ShowMode(ImportMode & out_mode) const;
2964 
2968  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2969 
2973  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
2974 
2978  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
2979  };
2980 
2982  class EXCHANGE_API Translation
2983  {
2984  public:
2987  enum class Healing
2988  {
2989  Off,
2990  On,
2991  OnlyIfNotParasolid,
2992  };
2993 
2996  enum class AccurateEdges
2997  {
2998  Off,
2999  On,
3000  OnlyIfNotParasolid,
3001  };
3002 
3005  enum class Simplification
3006  {
3007  Off,
3008  On,
3009  OnlyIfNotParasolid,
3010  };
3011 
3014  enum class Merging
3015  {
3016  Off,
3017  On,
3018  OnlyIfNotParasolid,
3019  };
3020 
3021  private:
3023  Translation();
3024  };
3025 
3027  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3028  {
3029  public:
3032 
3036 
3041 
3045  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3046 
3047  virtual ~TranslationOptionsKit();
3048 
3049  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3050  HPS::Type ObjectType() const { return staticType; }
3051 
3055  static TranslationOptionsKit GetDefault();
3056 
3059  void Set(TranslationOptionsKit const & in_kit);
3060 
3063  void Show(TranslationOptionsKit & out_kit) const;
3064 
3068  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3069 
3072  bool Empty() const;
3073 
3077  bool Equals(TranslationOptionsKit const & in_kit) const;
3078 
3082  bool operator==(TranslationOptionsKit const & in_kit) const;
3083 
3087  bool operator!=(TranslationOptionsKit const & in_kit) const;
3088 
3094  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3095 
3101  TranslationOptionsKit & SetTessellation(bool in_state);
3102 
3108  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3109 
3113  TranslationOptionsKit & SetApplication(char const * in_name);
3114 
3118  TranslationOptionsKit & SetVersion(char const * in_version);
3119 
3125  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3126 
3130  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3131 
3135  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3136 
3140  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3141 
3145  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3146 
3151  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3152 
3156  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3157 
3160  TranslationOptionsKit & UnsetSolidsAsFaces();
3161 
3164  TranslationOptionsKit & UnsetTessellation();
3165 
3168  TranslationOptionsKit & UnsetHiddenObjects();
3169 
3172  TranslationOptionsKit & UnsetApplication();
3173 
3176  TranslationOptionsKit & UnsetVersion();
3177 
3180  TranslationOptionsKit & UnsetHealing();
3181 
3184  TranslationOptionsKit & UnsetAccurateEdges();
3185 
3188  TranslationOptionsKit & UnsetSimplification();
3189 
3192  TranslationOptionsKit & UnsetEntityMerging();
3193 
3196  TranslationOptionsKit & UnsetSewing();
3197 
3200  TranslationOptionsKit & UnsetDisjointFaces();
3201 
3204  TranslationOptionsKit& UnsetExplodeMultiBodies();
3205 
3208  TranslationOptionsKit & UnsetEverything();
3209 
3210 
3214  bool ShowSolidsAsFaces(bool & out_state) const;
3215 
3219  bool ShowTessellation(bool & out_state) const;
3220 
3224  bool ShowHiddenObjects(bool & out_state) const;
3225 
3229  bool ShowApplication(UTF8 & out_name) const;
3230 
3234  bool ShowVersion(UTF8 & out_version) const;
3235 
3239  bool ShowExplodeMultiBodies(bool& out_state) const;
3240 
3244  bool ShowHealing(Translation::Healing & out_healing) const;
3245 
3249  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3250 
3254  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3255 
3259  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3260 
3265  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3266 
3270  bool ShowDisjointFaces(bool & out_state) const;
3271 
3276  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3277 
3280  TranslationOptionsKit & UnsetMultiProcessCount();
3281 
3285  bool ShowMultiProcessCount(unsigned int & out_count) const;
3286  };
3287 
3288 
3289 
3294  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3295  {
3296  public:
3299 
3303 
3308 
3312  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3313 
3314  virtual ~ModelFileImportOptionsKit();
3315 
3316  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3317  HPS::Type ObjectType() const { return staticType; }
3318 
3322  static ModelFileImportOptionsKit GetDefault();
3323 
3326  void Set(ModelFileImportOptionsKit const & in_kit);
3327 
3330  void Show(ModelFileImportOptionsKit & out_kit) const;
3331 
3335  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3336 
3339  bool Empty() const;
3340 
3344  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3345 
3349  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3350 
3354  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3355 
3356 
3357  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3358  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3359  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3360  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3361  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3362  * \return A reference to this ImportOptionsKit.
3363  */
3364  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3365 
3371  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3372 
3379  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3380 
3392  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double accurate_grid_maximum_stitch_length = 0.0);
3393 
3394  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3395  * \warning Setting this option to true will cause future exports to output without tessellation data.
3396  * \param in_cleanup Whether to clean up tessellation data from representation items.
3397  * \return A reference to this ImportOptionsKit.
3398  */
3399  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3400 
3406  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3407 
3413  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3414 
3421  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3422 
3426  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3427 
3440  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3441 
3447  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3448 
3452  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3453 
3458  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3459 
3460 
3463  ModelFileImportOptionsKit & UnsetTessellationLevel();
3464 
3467  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3468 
3471  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3472 
3475  ModelFileImportOptionsKit & UnsetPMIFlipping();
3476 
3479  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3480 
3483  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3484 
3487  ModelFileImportOptionsKit & UnsetIFCEdges();
3488 
3491  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3492 
3495  ModelFileImportOptionsKit & UnsetLocation();
3496 
3499  ModelFileImportOptionsKit & UnsetSewingTolerance();
3500 
3503  ModelFileImportOptionsKit & UnsetNURBSConversion();
3504 
3507  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3508 
3511  ModelFileImportOptionsKit & UnsetEverything();
3512 
3513 
3521  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3522 
3529  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3530 
3534  bool ShowTessellationCleanup(bool & out_cleanup) const;
3535 
3539  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3540 
3544  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3545 
3549  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3550 
3554  bool ShowIFCEdges(bool & out_state) const;
3555 
3559  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3560 
3565  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3566 
3570  bool ShowSewingTolerance(double & out_tolerance) const;
3571 
3575  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3576 
3580  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3581  };
3582 
3583 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3584 
3585  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3586  {
3587  public:
3590 
3593  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3594 
3598 
3599  virtual ~Export3MFOptionsKit();
3600 
3601  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3602  HPS::Type ObjectType() const { return staticType; }
3603 
3607  static Export3MFOptionsKit GetDefault();
3608 
3611  void Set(Export3MFOptionsKit const & in_kit);
3612 
3615  void Show(Export3MFOptionsKit& out_kit) const;
3616 
3620  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3621 
3625  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3626 
3629  bool Empty() const;
3630 
3634  bool Equals(Export3MFOptionsKit const & in_kit) const;
3635 
3639  bool operator==(Export3MFOptionsKit const & in_kit) const;
3640 
3644  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3645 
3650  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3651 
3657  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3658 
3661  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3662 
3666  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3667 
3672  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3673 
3676  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3677 
3682  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3683 
3687  Export3MFOptionsKit & SetDescription(char const * in_description);
3688 
3691  Export3MFOptionsKit & UnsetDescription();
3692 
3696  bool ShowDescription(HPS::UTF8 & out_state) const;
3697 
3701  Export3MFOptionsKit & SetCopyright(char const * in_state);
3702 
3705  Export3MFOptionsKit & UnsetCopyright();
3706 
3710  bool ShowCopyright(HPS::UTF8 & out_state) const;
3711 
3715  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3716 
3719  Export3MFOptionsKit & UnsetLicenseTerms();
3720 
3724  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3725 
3728  Export3MFOptionsKit & UnsetEverything();
3729  };
3730 
3732  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3733  {
3734  public:
3737 
3741 
3745 
3746  virtual ~ExportACISOptionsKit();
3747 
3748  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
3749  HPS::Type ObjectType() const { return staticType; }
3750 
3754  static ExportACISOptionsKit GetDefault();
3755 
3758  void Set(ExportACISOptionsKit const & in_kit);
3759 
3762  void Show(ExportACISOptionsKit & out_kit) const;
3763 
3767  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3768 
3772  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3773 
3776  bool Empty() const;
3777 
3781  bool Equals(ExportACISOptionsKit const & in_kit) const;
3782 
3786  bool operator==(ExportACISOptionsKit const & in_kit) const;
3787 
3791  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3792 
3793 
3799  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3800 
3806  ExportACISOptionsKit & SetBinary(bool in_state);
3807 
3808 
3811  ExportACISOptionsKit & UnsetMillimeterUnits();
3812 
3815  ExportACISOptionsKit & UnsetBinary();
3816 
3819  ExportACISOptionsKit & UnsetEverything();
3820 
3821 
3825  bool ShowMillimeterUnits(bool & out_state) const;
3826 
3830  bool ShowBinary(bool & out_state) const;
3831  };
3832 
3834  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3835  {
3836  public:
3839 
3842  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3843 
3847 
3848  virtual ~ExportJTOptionsKit();
3849 
3850  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
3851  HPS::Type ObjectType() const { return staticType; }
3852 
3856  static ExportJTOptionsKit GetDefault();
3857 
3860  void Set(ExportJTOptionsKit const & in_kit);
3861 
3864  void Show(ExportJTOptionsKit & out_kit) const;
3865 
3869  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3870 
3874  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3875 
3878  bool Empty() const;
3879 
3883  bool Equals(ExportJTOptionsKit const & in_kit) const;
3884 
3888  bool operator==(ExportJTOptionsKit const & in_kit) const;
3889 
3893  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3894 
3895 
3901  ExportJTOptionsKit & SetContent(JT::Content in_content);
3902 
3908  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3909 
3915  ExportJTOptionsKit & SetPMI(bool in_state);
3916 
3922  ExportJTOptionsKit & SetVersion(JT::Version in_version);
3923 
3924 
3927  ExportJTOptionsKit & UnsetContent();
3928 
3931  ExportJTOptionsKit & UnsetHiddenObjects();
3932 
3935  ExportJTOptionsKit & UnsetPMI();
3936 
3939  ExportJTOptionsKit & UnsetVersion();
3940 
3943  ExportJTOptionsKit & UnsetEverything();
3944 
3945 
3949  bool ShowContent(JT::Content & out_content) const;
3950 
3954  bool ShowHiddenObjects(bool & out_state) const;
3955 
3959  bool ShowPMI(bool & out_state) const;
3960 
3964  bool ShowVersion(JT::Version & out_version) const;
3965  };
3966 
3968  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
3969  {
3970  public:
3973 
3976  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3977 
3981 
3982  virtual ~ExportPRCOptionsKit();
3983 
3984  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
3985  HPS::Type ObjectType() const { return staticType; }
3986 
3990  static ExportPRCOptionsKit GetDefault();
3991 
3994  void Set(ExportPRCOptionsKit const & in_kit);
3995 
3998  void Show(ExportPRCOptionsKit & out_kit) const;
3999 
4003  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4004 
4008  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4009 
4012  bool Empty() const;
4013 
4017  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4018 
4022  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4023 
4027  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4028 
4029 
4035  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4036 
4043  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4044 
4050  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4051 
4057  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4058 
4063  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4064 
4070  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4071 
4072 
4075  ExportPRCOptionsKit & UnsetTessellationCompression();
4076 
4079  ExportPRCOptionsKit & UnsetBRepCompression();
4080 
4083  ExportPRCOptionsKit & UnsetBRepRemoval();
4084 
4087  ExportPRCOptionsKit & UnsetAttributeRemoval();
4088 
4091  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4092 
4095  ExportPRCOptionsKit & UnsetEverything();
4096 
4097 
4101  bool ShowTessellationCompression(bool & out_state) const;
4102 
4106  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4107 
4111  bool ShowBRepRemoval(bool & out_state) const;
4112 
4116  bool ShowAttributeRemoval(bool & out_state) const;
4117 
4121  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4122  };
4123 
4125  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4126  {
4127  public:
4130 
4133  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4134 
4138 
4139  virtual ~ExportSTLOptionsKit();
4140 
4141  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4142  HPS::Type ObjectType() const { return staticType; }
4143 
4147  static ExportSTLOptionsKit GetDefault();
4148 
4151  void Set(ExportSTLOptionsKit const & in_kit);
4152 
4155  void Show(ExportSTLOptionsKit & out_kit) const;
4156 
4160  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4161 
4165  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4166 
4169  bool Empty() const;
4170 
4174  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4175 
4179  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4180 
4184  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4185 
4186 
4192  ExportSTLOptionsKit & SetBinary(bool in_state);
4193 
4199  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4200 
4207  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4208 
4214  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4215 
4221  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4222 
4229  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4230 
4240  ExportSTLOptionsKit & SetUnits(Units in_units);
4241 
4242 
4245  ExportSTLOptionsKit & UnsetBinary();
4246 
4249  ExportSTLOptionsKit & UnsetTessellationLevel();
4250 
4253  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4254 
4257  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4258 
4261  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4262 
4265  ExportSTLOptionsKit & UnsetUnits();
4266 
4269  ExportSTLOptionsKit & UnsetEverything();
4270 
4271 
4275  bool ShowBinary(bool & out_state) const;
4276 
4284  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4285 
4289  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4290 
4294  bool ShowCurrentTessellationRetention(bool & out_state) const;
4295 
4299  bool ShowMaximumEdgeLength(double & out_length) const;
4300 
4304  bool ShowUnits(Units & out_units) const;
4305  };
4306 
4308  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4309  {
4310  public:
4313 
4316  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4317 
4321 
4322  virtual ~ExportU3DOptionsKit();
4323 
4324  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4325  HPS::Type ObjectType() const { return staticType; }
4326 
4330  static ExportU3DOptionsKit GetDefault();
4331 
4334  void Set(ExportU3DOptionsKit const & in_kit);
4335 
4338  void Show(ExportU3DOptionsKit & out_kit) const;
4339 
4343  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4344 
4348  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4349 
4352  bool Empty() const;
4353 
4357  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4358 
4362  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4363 
4367  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4368 
4369 
4375  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4376 
4381  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4382 
4383 
4386  ExportU3DOptionsKit & UnsetVersion();
4387 
4390  ExportU3DOptionsKit & UnsetCompression();
4391 
4394  ExportU3DOptionsKit & UnsetEverything();
4395 
4396 
4400  bool ShowVersion(U3D::Version & out_version) const;
4401 
4405  bool ShowCompression(unsigned char & out_level) const;
4406  };
4407 
4409  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4410  {
4411  public:
4414 
4417  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4418 
4422 
4423  virtual ~ExportXMLOptionsKit();
4424 
4425  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4426  HPS::Type ObjectType() const { return staticType; }
4427 
4431  static ExportXMLOptionsKit GetDefault();
4432 
4435  void Set(ExportXMLOptionsKit const & in_kit);
4436 
4439  void Show(ExportXMLOptionsKit & out_kit) const;
4440 
4444  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4445 
4449  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4450 
4453  bool Empty() const;
4454 
4458  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4459 
4463  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4464 
4468  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4469 
4470 
4476  ExportXMLOptionsKit & SetMetadata(bool in_state);
4477 
4483  ExportXMLOptionsKit & SetTransformations(bool in_state);
4484 
4490  ExportXMLOptionsKit & SetMaterials(bool in_state);
4491 
4492 
4495  ExportXMLOptionsKit & UnsetMetadata();
4496 
4499  ExportXMLOptionsKit & UnsetTransformations();
4500 
4503  ExportXMLOptionsKit & UnsetMaterials();
4504 
4507  ExportXMLOptionsKit & UnsetEverything();
4508 
4509 
4513  bool ShowMetadata(bool & out_state) const;
4514 
4518  bool ShowTransformations(bool & out_state) const;
4519 
4523  bool ShowMaterials(bool & out_state) const;
4524  };
4525 #endif
4526 
4527 #if !defined(TARGET_OS_ANDROID)
4528 
4529  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4530  {
4531  public:
4534 
4538 
4542 
4543  virtual ~ExportIGESOptionsKit();
4544 
4545  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4546  HPS::Type ObjectType() const { return staticType; }
4547 
4551  static ExportIGESOptionsKit GetDefault();
4552 
4555  void Set(ExportIGESOptionsKit const & in_kit);
4556 
4559  void Show(ExportIGESOptionsKit & out_kit) const;
4560 
4564  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4565 
4569  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4570 
4573  bool Empty() const;
4574 
4578  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4579 
4583  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4584 
4588  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4589 
4590 
4596  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4597 
4603  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4604 
4610  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4611 
4617  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4618 
4624  ExportIGESOptionsKit & SetTessellation(bool in_state);
4625 
4629  ExportIGESOptionsKit & SetApplication(char const * in_name);
4630 
4634  ExportIGESOptionsKit & SetVersion(char const * in_version);
4635 
4636 
4639  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4640 
4643  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
4644 
4647  ExportIGESOptionsKit & UnsetSolidsAsFaces();
4648 
4651  ExportIGESOptionsKit & UnsetHiddenObjects();
4652 
4655  ExportIGESOptionsKit & UnsetTessellation();
4656 
4659  ExportIGESOptionsKit & UnsetApplication();
4660 
4663  ExportIGESOptionsKit & UnsetVersion();
4664 
4667  ExportIGESOptionsKit & UnsetEverything();
4668 
4669 
4673  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4674 
4678  bool ShowFacetedAsWireframe(bool & out_state) const;
4679 
4683  bool ShowSolidsAsFaces(bool & out_state) const;
4684 
4688  bool ShowHiddenObjects(bool & out_state) const;
4689 
4693  bool ShowTessellation(bool & out_state) const;
4694 
4698  bool ShowApplication(UTF8 & out_name) const;
4699 
4703  bool ShowVersion(UTF8 & out_version) const;
4704  };
4705 
4707  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
4708  {
4709  public:
4712 
4716 
4720 
4721  virtual ~ExportParasolidOptionsKit();
4722 
4723  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
4724  HPS::Type ObjectType() const { return staticType; }
4725 
4729  static ExportParasolidOptionsKit GetDefault();
4730 
4733  void Set(ExportParasolidOptionsKit const & in_kit);
4734 
4737  void Show(ExportParasolidOptionsKit & out_kit) const;
4738 
4742  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4743 
4747  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4748 
4751  bool Empty() const;
4752 
4756  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4757 
4761  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4762 
4766  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4767 
4768 
4774  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4775 
4781  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4782 
4788  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4789 
4793  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4794 
4798  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4799 
4805  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
4806 
4809  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4810 
4813  ExportParasolidOptionsKit & UnsetTessellation();
4814 
4817  ExportParasolidOptionsKit & UnsetHiddenObjects();
4818 
4821  ExportParasolidOptionsKit & UnsetApplication();
4822 
4825  ExportParasolidOptionsKit & UnsetVersion();
4826 
4829  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
4830 
4833  ExportParasolidOptionsKit & UnsetEverything();
4834 
4835 
4839  bool ShowSolidsAsFaces(bool & out_state) const;
4840 
4844  bool ShowTessellation(bool & out_state) const;
4845 
4849  bool ShowHiddenObjects(bool & out_state) const;
4850 
4854  bool ShowApplication(UTF8 & out_name) const;
4855 
4859  bool ShowVersion(UTF8 & out_version) const;
4860 
4864  bool ShowExplodeMultiBodies(bool& out_state) const;
4865  };
4866 
4868  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4869  {
4870  public:
4873 
4877 
4881 
4882  virtual ~ExportSTEPOptionsKit();
4883 
4884  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
4885  HPS::Type ObjectType() const { return staticType; }
4886 
4890  static ExportSTEPOptionsKit GetDefault();
4891 
4894  void Set(ExportSTEPOptionsKit const & in_kit);
4895 
4898  void Show(ExportSTEPOptionsKit & out_kit) const;
4899 
4903  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4904 
4908  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4909 
4912  bool Empty() const;
4913 
4917  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
4918 
4922  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
4923 
4927  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
4928 
4929 
4935  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
4936 
4942  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4943 
4949  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
4950 
4956  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
4957 
4961  ExportSTEPOptionsKit & SetApplication(char const * in_name);
4962 
4966  ExportSTEPOptionsKit & SetVersion(char const * in_version);
4967 
4971  ExportSTEPOptionsKit & SetPMI(bool in_state);
4972 
4976  ExportSTEPOptionsKit & SetCurves(bool in_state);
4977 
4981  ExportSTEPOptionsKit & SetAttributes(bool in_state);
4982 
4986  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
4987 
4991  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
4992 
4995  ExportSTEPOptionsKit & UnsetFormat();
4996 
4999  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5000 
5003  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5004 
5007  ExportSTEPOptionsKit & UnsetNameShortening();
5008 
5011  ExportSTEPOptionsKit & UnsetApplication();
5012 
5015  ExportSTEPOptionsKit & UnsetVersion();
5016 
5019  ExportSTEPOptionsKit & UnsetPMI();
5020 
5023  ExportSTEPOptionsKit & UnsetCurves();
5024 
5027  ExportSTEPOptionsKit & UnsetAttributes();
5028 
5031  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5032 
5035  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5036 
5039  ExportSTEPOptionsKit & UnsetEverything();
5040 
5041 
5045  bool ShowFormat(STEP::Format & out_format) const;
5046 
5050  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5051 
5055  bool ShowFacetedAsWireframe(bool & out_state) const;
5056 
5060  bool ShowNameShortening(bool & out_state) const;
5061 
5065  bool ShowApplication(UTF8 & out_name) const;
5066 
5070  bool ShowVersion(UTF8 & out_version) const;
5071 
5075  bool ShowPMI(bool & out_state) const;
5076 
5080  bool ShowCurves(bool & out_state) const;
5081 
5085  bool ShowAttributes(bool & out_state) const;
5086 
5090  bool ShowPMIWithSemantic(bool & out_state) const;
5091 
5095  bool ShowPMIAsTessellated(bool & out_state) const;
5096  };
5097 #endif
5098 
5100  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5101  {
5102  public:
5105 
5109 
5113 
5114  virtual ~TessellationOptionsKit();
5115 
5116  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5117  HPS::Type ObjectType() const { return staticType; }
5118 
5122  static TessellationOptionsKit GetDefault();
5123 
5126  void Set(TessellationOptionsKit const & in_kit);
5127 
5130  void Show(TessellationOptionsKit & out_kit) const;
5131 
5135  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5136 
5140  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5141 
5144  bool Empty() const;
5145 
5149  bool Equals(TessellationOptionsKit const & in_kit) const;
5150 
5154  bool operator==(TessellationOptionsKit const & in_kit) const;
5155 
5159  bool operator!=(TessellationOptionsKit const & in_kit) const;
5160 
5161 
5165  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5166 
5173  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5174 
5184  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
5185 
5189  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5190 
5194  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5195 
5196 
5199  TessellationOptionsKit & UnsetLevel();
5200 
5203  TessellationOptionsKit & UnsetAccuracy();
5204 
5207  TessellationOptionsKit & UnsetUVPointPreservation();
5208 
5211  TessellationOptionsKit & UnsetMaximumEdgeLength();
5212 
5215  TessellationOptionsKit & UnsetEverything();
5216 
5217 
5225  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5226 
5233  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5234 
5238  bool ShowUVPointPreservation(bool & out_state) const;
5239 
5243  bool ShowMaximumEdgeLength(double & out_length) const;
5244  };
5245 
5251  class EXCHANGE_API CommonMeasurementOperator : public Operator
5252  {
5253  public:
5254  enum class Tags
5255  {
5256  Name = 0,
5257  MeasurementType,
5258  Radius,
5259  Inverted,
5260  VectorX,
5261  VectorY,
5262  VectorZ,
5263  };
5264 
5266 
5267  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5268 
5270  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5271 
5272  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5273  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5274 
5275  Exchange::CADModel GetCADModel() const;
5276  void SetCADModel(Exchange::CADModel const & in_cad_model);
5277 
5279  size_t GetPrecision() const;
5280 
5283  void SetPrecision(size_t in_precision);
5284 
5286  MaterialMappingKit GetMaterial() const;
5287 
5290  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5291 
5293  TextAttributeKit GetTextAttributes() const;
5294 
5297  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5298 
5300  SegmentKey GetMeasurementSegment() const;
5301 
5303  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5304 
5305  /* Deletes all measurements */
5306  void DeleteMeasurements();
5307 
5308  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5309  {
5310  public:
5313  {
5314  channel = GetClassID();
5315  consumable = false;
5316  }
5317 
5318  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5319  {
5320  channel = GetClassID();
5321  consumable = false;
5322  measurement_key = in_measurement_key;
5323  view = in_view;
5324  }
5325 
5328  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5329  {
5330  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5331  {
5332  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5333  measurement_key = that.measurement_key;
5334  view = that.view;
5335  }
5336  else
5337  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5338  }
5339 
5341 
5344  Event * Clone() const
5345  {
5346  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5347  return new_event;
5348  }
5349 
5350  Key measurement_key;
5351  View view;
5352  };
5353 
5354  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5355  {
5356  public:
5359  {
5360  channel = GetClassID();
5361  consumable = false;
5362  }
5363 
5364  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5365  {
5366  channel = GetClassID();
5367  consumable = false;
5368  measurement_name = in_measurement_name;
5369  view = in_view;
5370  }
5371 
5374  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5375  {
5376  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5377  {
5378  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5379  measurement_name = that.measurement_name;
5380  view = that.view;
5381  }
5382  else
5383  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5384  }
5385 
5387 
5390  Event * Clone() const
5391  {
5392  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5393  return new_event;
5394  }
5395 
5396  UTF8 measurement_name;
5397  View view;
5398  };
5399 
5400  protected:
5401  Exchange::CADModel cad_model;
5402  size_t measurement_precision;
5403  UTF8 units;
5404  MaterialMappingKit materials;
5405  TextAttributeKit text_attributes;
5406  SegmentKey measurement_segment;
5407  GlyphDefinition left_arrow;
5408  GlyphDefinition right_arrow;
5409  SelectionOptionsKit selection_options;
5410  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5411  Vector camera_direction;
5412  PortfolioKey portfolio;
5413  SegmentKey style_segment;
5414  HighlightOptionsKit highlight_options;
5415 
5416  static size_t length_measurement_index;
5417  static size_t radius_measurement_index;
5418  static size_t distance_measurement_index;
5419  static size_t angle_measurement_index;
5420 
5421  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5422  void GetUnits();
5423  void SetGlyphColor();
5424  void GetCameraDirection();
5425  void SetupConstructionSegment();
5426  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5427  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5428  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5429  float GetModelScale(Exchange::Component const & component);
5430  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5431  };
5432 
5486  {
5487  public:
5488  enum class MeasurementType
5489  {
5490  PointToPoint,
5491  EdgeAndRadius,
5492  FeatureToFeature,
5493  FaceAngle,
5494  };
5495 
5497 
5498  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5499 
5501  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5502 
5503  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5504  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5505 
5510  virtual bool OnMouseDown(MouseState const & in_state) override;
5511 
5515  virtual bool OnMouseUp(MouseState const & in_state) override;
5516 
5522  virtual bool OnMouseMove(MouseState const & in_state) override;
5523 
5528  virtual bool OnTouchDown(TouchState const & in_state) override;
5529 
5533  virtual bool OnTouchUp(TouchState const & in_state) override;
5534 
5540  virtual bool OnTouchMove(TouchState const & in_state) override;
5541 
5545  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5546 
5549  void SetMeasurementType(MeasurementType in_measurement_type);
5550 
5553  MeasurementType GetMeasurementType();
5554 
5557  void SetMouseOverHighlighting(bool in_highlighting);
5558 
5562  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5563 
5566  bool GetMouseOverHighlighting();
5567 
5570  HighlightOptionsKit GetHighlightOptions();
5571 
5574  bool IsMeasurementActive();
5575 
5577  void DeleteLastMeasurement();
5578 
5579  private:
5580  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5581  {
5582  Circle,
5583  Line,
5584  Generic,
5585  };
5586 
5587  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5588  {
5589  public:
5590  Surface();
5591 
5592  enum class SurfaceType
5593  {
5594  Plane,
5595  ConeOrCylinder,
5596  Unsupported,
5597  };
5598 
5599  SurfaceType surface_type; //the type of surface being measured
5600  Point center; //the center point of the surface
5601  Vector normal; //the center line of surfaces of type Cylinder or Cone
5602  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5603  ComponentPath path; //the ComponentPath to this surface
5604  };
5605 
5606  //bookkeeping
5607  MeasurementType measurement_type; //the type of measurement to be inserted
5608  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5609  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5610  TouchID current_touch_id; //the ID of the touch being processed
5611  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5612  bool operator_active; //whether a measurement is in progress
5613  bool end_measurement; //whether we should end the current measurement
5614  CanvasArray canvases; //canvases related to the view where this operator is attached
5615 
5616  //measurement anchors
5617  size_t anchors; //valid for point-to-point and face-angle measurements
5618  bool anchors_in_place; //true if all the anchors have been placed
5619  Point first_click_position; //position of the first anchor
5620  Point second_click_position; //position of the second anchor
5621 
5622  //geometry for linear measurements
5623  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5624  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5625  LineKey distance_line; //a line representing the distance measured
5626  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5627  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5628  Point distance_point_one; //intersection of leader_line_one and distance_line
5629  Point distance_point_two; //intersection of leader_line_two and distance_line
5630  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5631  TextKey text; //text representing the measurement and units
5632  UTF8 text_string; //the contents of the text
5633  Vector measurement_direction; //the direction of the measurement
5634  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5635  Vector explicit_direction; //used if use_explicit_direction is true
5636 
5637  //geometry for radius measurement
5638  MarkerKey center_marker; //marker representing the center of the circle
5639  Point circle_center; //circle center
5640  float radius; //circle radius
5641 
5642  //edge specific data
5643  LineKey edge_line; //the edge being measured
5644  double edge_length; //length of the measured edge
5645  EdgeType edge_type; //the type of edge being measured
5646 
5647  //feature-to-feature specific data
5648  Surface surface_one; //data related to first selected surface
5649  Surface surface_two; //data related to second selected surface
5650  Plane measurement_plane; //the measurement plane
5651  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5652 
5653  //angle specific data
5654  Vector leader_line_one_direction; //the direction of the first leader line
5655  Vector leader_line_two_direction; //the direction of the second leader line
5656  Vector first_face_normal; //the normal of the first selected face
5657  Vector second_face_normal; //the normal of the second selected face
5658  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'
5659  CircularArcKey measurement_arc; //an arc representing the measured angle
5660  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5661  Vector mid_point_direction;
5662 
5663  //selection kits
5664  SelectionOptionsKit point_to_point_selection;
5665  SelectionOptionsKit edge_radius_selection;
5666  SelectionOptionsKit feature_to_feature_selection;
5667  SelectionOptionsKit angle_selection;
5668 
5669  //highlighting
5670  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5671  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5672  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5673  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5674  KeyPath highlighted_path; //highlighted_path
5675  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5676  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5677 
5678  //input handling
5679  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5680  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5681  bool InputUp(WindowKey & in_window);
5682  void ResetMeasurement();
5683 
5684  //inserting measurements
5685  void InsertPointToPointMeasurement(Point const & in_world_point);
5686  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5687  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5688  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5689  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5690  void InvertMeasuredAngle(WindowKey & in_window);
5691  void AdjustLineToCursor(Point const & cursor_position);
5692 
5693  //saving measurements
5694  void TagMeasurement();
5695  void TagPointToPointMeasurement();
5696  void TagEdgeMeasurement();
5697  void TagRadiusMeasurement();
5698  void TagGenericEdgeMeasurement();
5699  void TagFeatureToFeatureMeasurement();
5700  void TagAngleMeasurement();
5701 
5702  //restoring measurements
5703  void RestoreMeasurement(SegmentKey const & measurement_segment);
5704  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5705  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5706  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5707  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5708  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5709  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5710  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5711 
5712  //topology functions
5713  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5714  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5715  void PlaneToCenterLineDistance();
5716  void PlaneToPlaneDistance();
5717  void LineToLineDistance();
5718  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);
5719  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5720  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5721  bool IsPlane(Exchange::Component const & face_component);
5722  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5723  };
5724 
5725 private:
5727  Exchange();
5728 };
5729 
5730 }
5731 
5732 #endif
Definition: hps.h:6241
Definition: sprk_exchange.h:3968
Level
Definition: sprk_exchange.h:877
ConstructionEntities
Definition: sprk_exchange.h:1039
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:990
Definition: sprk.h:272
Definition: sprk_exchange.h:1156
Definition: sprk_exchange.h:5251
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5852
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:3005
Definition: sprk.h:105
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5270
Definition: sprk_exchange.h:619
Version
Definition: sprk_exchange.h:1060
Definition: sprk_exchange.h:3294
Definition: sprk_exchange.h:887
Definition: sprk_exchange.h:720
SurfaceType
Definition: sprk_exchange.h:809
Definition: hps.h:1734
Format
Definition: sprk_exchange.h:977
Definition: sprk_exchange.h:4409
Definition: sprk.h:241
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6707
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6683
Definition: hps.h:48118
Format
Definition: sprk_exchange.h:1161
Definition: hps.h:7747
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6677
Type
Definition: sprk_exchange.h:868
Definition: hps.h:16354
Definition: sprk_exchange.h:467
Definition: sprk_exchange.h:558
Definition: sprk_exchange.h:308
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5328
Definition: sprk_exchange.h:1409
Definition: sprk_exchange.h:248
Definition: sprk_exchange.h:3834
Merging
Definition: sprk_exchange.h:3014
Field
Definition: sprk_exchange.h:967
Definition: hps.h:48016
Definition: hps.h:41562
Definition: sprk_exchange.h:3732
Definition: sprk_exchange.h:3027
Limit
Definition: sprk_exchange.h:892
Definition: hps.h:4531
TessellationLevel
Definition: sprk_exchange.h:941
Definition: sprk_exchange.h:863
Definition: sprk_exchange.h:4125
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:962
Definition: hps.h:4470
Definition: hps.h:7118
Definition: hps.h:47487
Definition: sprk_exchange.h:421
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:43554
Definition: hps.h:47903
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:856
Definition: sprk_exchange.h:4308
Definition: sprk_exchange.h:927
Definition: hps.h:15741
Event * Clone() const
Definition: sprk_exchange.h:5390
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6663
intptr_t GetChannel() const
Definition: hps.h:6358
Definition: sprk_exchange.h:1055
SessionColor
Definition: sprk_exchange.h:1014
Definition: sprk.h:1746
Definition: hps.h:48225
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:44753
Definition: hps.h:46994
CurveType
Definition: sprk_exchange.h:832
Definition: sprk_exchange.h:512
Definition: hps.h:6325
Definition: hps.h:13991
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6675
Definition: sprk_exchange.h:5485
Definition: sprk.h:486
BRepCompression
Definition: sprk_exchange.h:995
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:782
Definition: sprk.h:2084
ComponentType
Definition: sprk.h:1762
Accuracy
Definition: sprk_exchange.h:909
Definition: sprk_exchange.h:3585
Definition: sprk_exchange.h:4529
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5374
Definition: sprk.h:2583
FamilyTable
Definition: sprk_exchange.h:1027
Content
Definition: sprk_exchange.h:932
Definition: sprk_exchange.h:1634
Definition: sprk.h:2683
static MouseButtons ButtonLeft()
Definition: hps.h:47605
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5501
Definition: hps.h:7665
Definition: sprk_exchange.h:1009
AccurateEdges
Definition: sprk_exchange.h:2996
Event * Clone() const
Definition: sprk_exchange.h:5344
Definition: hps.h:9370
Definition: sprk_exchange.h:673
Definition: hps.h:24342
Healing
Definition: sprk_exchange.h:2987
Definition: sprk.h:2770
Definition: hps.h:30775
ImportMode
Definition: sprk_exchange.h:797
Definition: sprk_exchange.h:1072
Definition: hps.h:511
Definition: sprk.h:1109
Definition: sprk_exchange.h:2982
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:4707
Definition: sprk_exchange.h:182
Definition: hps.h:41058
Version
Definition: sprk_exchange.h:950
Definition: sprk_exchange.h:5100
Definition: hps.h:42177
Definition: sprk_exchange.h:4868