sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
437 
442  void Tessellate(TessellationOptionsKit const & in_options);
443 
450  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
451  };
452 
455  class EXCHANGE_API Capture : public HPS::Capture
456  {
457  public:
459  Capture();
460 
464  Capture(Component const & in_that);
465 
469  Capture(HPS::Capture const & in_that);
470 
473  Capture(Exchange::Capture const & in_that);
474 
477  Capture(Exchange::Capture && in_that);
478 
479  virtual ~Capture();
480 
481  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
482  HPS::Type ObjectType() const { return staticType; }
483 
484 #if !defined(_MSC_VER) || _MSC_VER >= 1900
485  Capture & operator=(Exchange::Capture const & in_that) = default;
486 #endif
487 
491  Capture & operator=(Exchange::Capture && in_that);
492 
493 
496  A3DEntity * GetExchangeEntity() const;
497 
498  /* Activates this capture */
499  HPS::View Activate(HPS::ComponentPath const & in_capture_path = HPS::ComponentPath());
500  };
501 
504  class EXCHANGE_API Filter : public HPS::Filter
505  {
506  public:
508  Filter();
509 
513  Filter(Component const & in_that);
514 
518  Filter(HPS::Filter const & in_that);
519 
522  Filter(Exchange::Filter const & in_that);
523 
526  Filter(Exchange::Filter && in_that);
527 
528  virtual ~Filter();
529 
530  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
531  HPS::Type ObjectType() const { return staticType; }
532 
533 #if !defined(_MSC_VER) || _MSC_VER >= 1900
534  Filter & operator=(Exchange::Filter const & in_that) = default;
535 #endif
536 
540  Filter & operator=(Exchange::Filter && in_that);
541 
542 
545  A3DEntity * GetExchangeEntity() const;
546  };
547 
549  class EXCHANGE_API Factory : public Sprocket
550  {
551  public:
556  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
557 
563  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
564 
568  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
569 
576  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
577 
581  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
582 
587  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
588 
589  private:
591  Factory();
592  };
593 
595  class EXCHANGE_API ImportNotifier : public IONotifier
596  {
597  public:
599  ImportNotifier();
600 
603  ImportNotifier(ImportNotifier const & in_that);
604 
609  ImportNotifier(IONotifier const & in_that);
610 
614  ImportNotifier(ImportNotifier && in_that);
615 
619  ImportNotifier & operator=(ImportNotifier && in_that);
620 
621  virtual ~ImportNotifier();
622 
623  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
624  HPS::Type ObjectType() const { return staticType; };
625 
629  ImportNotifier & operator=(ImportNotifier const & in_that);
630 
633  void Assign(ImportNotifier const & in_that);
634 
637  Exchange::CADModel GetCADModel() const;
638 
644  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
645 
648  Time GetImportTime() const;
649 
652  Time GetParseTime() const;
653  };
654 
656  class EXCHANGE_API TranslationNotifier : public IONotifier
657  {
658  public:
661 
664  TranslationNotifier(TranslationNotifier const & in_that);
665 
670  TranslationNotifier(IONotifier const & in_that);
671 
676 
680  TranslationNotifier & operator=(TranslationNotifier && in_that);
681 
682  virtual ~TranslationNotifier();
683 
684  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
685  HPS::Type ObjectType() const { return staticType; };
686 
690  TranslationNotifier & operator=(TranslationNotifier const & in_that);
691 
694  void Assign(TranslationNotifier const & in_that);
695 
698  Exchange::ParasolidEntityArray GetParasolidParts() const;
699 
702  HPS::Time GetImportTime() const;
703 
706  HPS::Time GetTranslationTime() const;
707  };
708 
710  class EXCHANGE_API ExportNotifier : public IONotifier
711  {
712  public:
714  ExportNotifier();
715 
718  ExportNotifier(ExportNotifier const & in_that);
719 
724  ExportNotifier(IONotifier const & in_that);
725 
729  ExportNotifier(ExportNotifier && in_that);
730 
734  ExportNotifier & operator=(ExportNotifier && in_that);
735 
736  virtual ~ExportNotifier();
737 
738  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
739  HPS::Type ObjectType() const { return staticType; };
740 
744  ExportNotifier & operator=(ExportNotifier const & in_that);
745 
748  void Assign(ExportNotifier const & in_that);
749 
753  A3DAsmModelFile * GetModelFile() const;
754  };
755 
757  class EXCHANGE_API ReloadNotifier : public IONotifier
758  {
759  public:
761  ReloadNotifier();
762 
765  ReloadNotifier(ReloadNotifier const & in_that);
766 
771  ReloadNotifier(IONotifier const & in_that);
772 
776  ReloadNotifier(ReloadNotifier && in_that);
777 
781  ReloadNotifier & operator=(ReloadNotifier && in_that);
782 
783  virtual ~ReloadNotifier();
784 
785  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
786  HPS::Type ObjectType() const { return staticType; };
787 
791  ReloadNotifier & operator=(ReloadNotifier const & in_that);
792 
795  void Assign(ReloadNotifier const & in_that);
796  };
797 
798 
799  class ImportOptionsKit;
800  class ModelFileImportOptionsKit;
801 
802 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
803  class Export3MFOptionsKit;
804  class ExportFBXOptionsKit;
805  class ExportACISOptionsKit;
806  class ExportJTOptionsKit;
807  class ExportPRCOptionsKit;
808  class ExportSTLOptionsKit;
809  class ExportOBJOptionsKit;
810  class ExportU3DOptionsKit;
811  class ExportXMLOptionsKit;
812 #endif
813 
814 #if !defined(TARGET_OS_ANDROID)
815  class ExportSTEPOptionsKit;
816  class ExportIGESOptionsKit;
817 #endif
818 
821  enum class BRepMode
822  {
825  TessellationOnly,
828  BRepOnly,
831  BRepAndTessellation,
832  };
833 
836  enum class ImportMode
837  {
840  Complete,
843  Incremental,
844  };
845 
848  enum class SurfaceType
849  {
850  Blend01,
851  Blend02,
852  Blend03,
853  Blend04,
854  NURBS,
855  Cone,
856  Cylinder,
857  Offset,
858  Pipe,
859  Plane,
860  Ruled,
861  Sphere,
862  Revolution,
863  Extrusion,
864  FromCurve,
865  Torus,
866  Transform,
867  };
868 
871  enum class CurveType
872  {
873  Blend,
874  NURBS,
875  Circle,
876  Composite,
877  CurveOnSurface,
878  Ellipse,
879  Equation,
880  Helix,
881  Hyperbola,
882  Intersection,
883  Line,
884  Offset,
885  Parabola,
886  Polyline,
887  Transform,
888  };
889 
890  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
891  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
892 
896  {
897  PMIOnly,
898  ModelAndPMI
899  };
900 
902  class EXCHANGE_API Tessellation
903  {
904  public:
907  enum class Type
908  {
909  Standard,
910  Custom
911  };
912 
913 
916  enum class Level
917  {
918  ExtraLow,
919  Low,
920  Medium,
921  High,
922  ExtraHigh,
923  };
924 
926  class EXCHANGE_API Chord
927  {
928  public:
931  enum class Limit
932  {
935  Ratio,
938  Height
939  };
940 
941  private:
943  Chord();
944  };
945 
948  enum class Accuracy
949  {
952  Standard,
955  Accurate,
957  GridAccurate
958  };
959 
960  private:
962  Tessellation();
963  };
964 
966  class EXCHANGE_API JT
967  {
968  public:
971  enum class Content
972  {
973  Geometry,
974  Tessellation,
975  GeometryAndTessellation
976  };
977 
980  enum class TessellationLevel
981  {
982  Low,
983  Medium,
984  High,
985  };
986 
989  enum class Version
990  {
991  JT81,
992  JT95,
993  JT100,
994  };
995 
996  private:
998  JT();
999  };
1000 
1002  class EXCHANGE_API STEP
1003  {
1004  public:
1007  enum class Field
1008  {
1009  ProductName,
1010  NextAssemblyUsageOccurrenceID,
1011  NextAssemblyUsageOccurrenceName,
1012  NextAssemblyUsageOccurrenceDescription
1013  };
1014 
1017  enum class Format
1018  {
1019  AP203,
1020  AP214,
1021  AP242,
1022  };
1023 
1024  private:
1026  STEP();
1027  };
1028 
1030  class EXCHANGE_API PRC
1031  {
1032  public:
1035  enum class BRepCompression
1036  {
1037  None,
1038  Low,
1039  Medium,
1040  High
1041  };
1042 
1043  private:
1045  PRC();
1046  };
1047 
1049  class EXCHANGE_API ProE
1050  {
1051  public:
1054  enum class SessionColor
1055  {
1057  LastCreoVersion,
1059  ExchangeDefault,
1062  UserDefined
1063  };
1064 
1067  enum class FamilyTable
1068  {
1070  BRepOnly,
1072  BRepOrTessellation,
1074  BRepOrTessellationOrGeneric
1075  };
1076 
1080  {
1082  On,
1084  Off,
1086  AsDatum,
1087  };
1088 
1089  private:
1091  ProE();
1092  };
1093 
1095  class EXCHANGE_API U3D
1096  {
1097  public:
1100  enum class Version
1101  {
1102  ECMA1,
1103  ECMA3
1104  };
1105 
1106  private:
1108  U3D();
1109  };
1110 
1112  class EXCHANGE_API Configuration : public HPS::Sprocket
1113  {
1114  public:
1116  Configuration();
1117 
1120  Configuration(char const * in_name);
1121 
1126  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1127 
1131  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1132 
1135  Configuration(Configuration const & in_configuration);
1136 
1140  Configuration(Configuration && in_that);
1141 
1145  Configuration & operator=(Configuration && in_that);
1146 
1147  virtual ~Configuration();
1148 
1149  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1150  HPS::Type ObjectType() const { return staticType; }
1151 
1152 
1155  void Set(Configuration const & in_kit);
1156 
1159  void Show(Configuration & out_kit) const;
1160 
1164  Configuration & operator=(Configuration const & in_kit);
1165 
1168  bool Empty() const;
1169 
1173  bool Equals(Configuration const & in_kit) const;
1174 
1178  bool operator==(Configuration const & in_kit) const;
1179 
1183  bool operator!=(Configuration const & in_kit) const;
1184 
1185 
1188  HPS::UTF8 GetName() const;
1189 
1192  ConfigurationArray GetSubconfigurations() const;
1193  };
1194 
1196  class EXCHANGE_API File
1197  {
1198  public:
1201  enum class Format
1202  {
1203  Unsupported,
1204  ACIS,
1205  CADDS,
1206  CATIAV4,
1207  CATIAV5,
1208  CGR,
1209  COLLADA,
1210  CreoProE,
1211  DWG,
1212  DXF,
1213  IDEAS,
1214  IFC,
1215  IGES,
1216  Inventor,
1217  JT,
1218  KeyholeMarkupLanguage,
1219  LatticeXVL,
1220  OneSpaceDesigner,
1221  Parasolid,
1222  PDF,
1223  PRC,
1224  Rhino,
1225  NXUnigraphics,
1226  SolidEdge,
1227  SolidWorks,
1228  STEP,
1229  StereoLithography,
1230  ThreeDStudioMax,
1231  ThreeDXML,
1232  Universal3D,
1233  VDAFS,
1234  VRML,
1235  WavefrontObject,
1236  Revit,
1237  GLTF,
1238  DWF,
1239  FBX,
1240  STEPXML,
1241  };
1242 
1244  static Format GetFormat(char const * in_file_name);
1245 
1249  static ConfigurationArray GetConfigurations(char const * in_file_name);
1250 
1262  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);
1263 
1269  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1270 
1277  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1278 
1285  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1286 
1294  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1295 
1302  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1303 
1304 
1311  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1312 
1313 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1314 
1318  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1319 
1325  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1326 
1333  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1334 
1340  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1341 
1346  static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);
1347 
1352  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1353 
1358  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1359 
1365  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1366 
1372  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1373 
1380  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1381 
1388  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1389 
1393  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1394 
1399  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1400 
1404  static ExportNotifier ExportPRC(KeyPath const & in_source);
1405 
1410  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1411 
1416  static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);
1417 
1422  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1423 
1427  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1428 
1433  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1434 #endif
1435 
1436 #if TARGET_OS_ANDROID == 0
1437 
1441  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1442 
1447  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1448 
1453  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1454 #endif
1455 
1456  private:
1458  File();
1459  };
1460 
1462  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1463  {
1464  public:
1467 
1471 
1476 
1480  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1481 
1482  virtual ~NURBSConversionOptionsKit();
1483 
1484  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1485  HPS::Type ObjectType() const { return staticType; }
1486 
1489  void Set(NURBSConversionOptionsKit const & in_kit);
1490 
1493  void Show(NURBSConversionOptionsKit & out_kit) const;
1494 
1498  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1499 
1502  bool Empty() const;
1503 
1507  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1508 
1512  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1513 
1517  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1518 
1522  static NURBSConversionOptionsKit GetDefault();
1523 
1528  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1529 
1534  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1535 
1540  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1541 
1546  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1547 
1552  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1553 
1558  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1559 
1564  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1565 
1571  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1572 
1579  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1580 
1586  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1587 
1594  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1595 
1596 
1599  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1600 
1603  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1604 
1607  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1608 
1611  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1612 
1615  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1616 
1619  NURBSConversionOptionsKit & UnsetParameterization();
1620 
1623  NURBSConversionOptionsKit & UnsetTolerance();
1624 
1627  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1628 
1631  NURBSConversionOptionsKit & UnsetAllowedCurves();
1632 
1635  NURBSConversionOptionsKit & UnsetEverything();
1636 
1637 
1638 
1642  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1643 
1647  bool Show3DCurvesComputation(bool & out_state) const;
1648 
1653  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1654 
1658  bool ShowClosedFaceSplitting(bool & out_state) const;
1659 
1663  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1664 
1668  bool ShowParameterization(bool & out_state) const;
1669 
1673  bool ShowTolerance(double & out_tolerance) const;
1674 
1678  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1679 
1683  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1684  };
1685 
1687  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1688  {
1689  public:
1691  ImportOptionsKit();
1692 
1695  ImportOptionsKit(ImportOptionsKit const & in_kit);
1696 
1700  ImportOptionsKit(ImportOptionsKit && in_that);
1701 
1705  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1706 
1707  virtual ~ImportOptionsKit();
1708 
1709  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1710  HPS::Type ObjectType() const { return staticType; }
1711 
1715  static ImportOptionsKit GetDefault();
1716 
1719  void Set(ImportOptionsKit const & in_kit);
1720 
1723  void Show(ImportOptionsKit & out_kit) const;
1724 
1728  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1729 
1732  bool Empty() const;
1733 
1737  bool Equals(ImportOptionsKit const & in_kit) const;
1738 
1742  bool operator==(ImportOptionsKit const & in_kit) const;
1743 
1747  bool operator!=(ImportOptionsKit const & in_kit) const;
1748 
1749 
1755  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1756 
1762  ImportOptionsKit & SetSolids(bool in_state);
1763 
1769  ImportOptionsKit & SetSurfaces(bool in_state);
1770 
1776  ImportOptionsKit & SetWireframes(bool in_state);
1777 
1783  ImportOptionsKit & SetPMI(bool in_state);
1784 
1791  ImportOptionsKit & SetAttributes(bool in_state);
1792 
1798  ImportOptionsKit & SetHiddenObjects(bool in_state);
1799 
1805  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1806 
1812  ImportOptionsKit & SetActiveFilter(bool in_state);
1813 
1821  ImportOptionsKit & SetFeatureTrees(bool in_state);
1822 
1828  ImportOptionsKit & SetDrawings(bool in_state);
1829 
1835  ImportOptionsKit & SetDefaultUnits(Units in_units);
1836 
1841  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1842 
1848  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1849 
1856  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1857 
1864  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1865 
1871  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1872 
1878  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1879 
1887  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1888 
1895  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1896 
1904  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1905 
1913  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1914 
1920  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1921 
1927  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1928 
1935  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1936 
1948  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);
1949 
1955  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1956 
1962  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1963 
1969  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1970 
1975  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1976 
1983  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1984 
1990  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1991 
2000  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2001 
2010  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2011 
2017  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2018 
2023  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2024 
2031  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2032 
2037  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2038 
2044  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2045 
2050  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2051 
2057  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2058 
2065  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2066 
2073  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2074 
2082  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2083 
2090  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2091 
2097  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2098 
2104  ImportOptionsKit & SetProECodePageName(char const * in_name);
2105 
2111  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2112 
2118  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2119 
2125  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2126 
2133  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2134 
2141  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2142 
2149  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2150 
2157  ImportOptionsKit & SetProEHomeView(bool in_state);
2158 
2165  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2166 
2173  ImportOptionsKit & SetProEDatum(bool in_state);
2174 
2175 
2182  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2183 
2190  ImportOptionsKit & SetProESkeletons(bool in_state);
2191 
2198  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2199 
2205  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2206 
2212  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2213 
2219  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2220 
2226  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2227 
2233  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2234 
2240  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2241 
2248  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2249 
2255  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2256 
2262  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2263 
2270  ImportOptionsKit & SetIFCEdges(bool in_state);
2271 
2277  ImportOptionsKit & SetIFCMetadata(bool in_state);
2278 
2284  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2285 
2291  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2292 
2298  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2299 
2305  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2306 
2312  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2313 
2320  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2321 
2325  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2326 
2338  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2339 
2351  ImportOptionsKit & SetMode(ImportMode in_mode);
2352 
2362  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2363 
2371  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2372 
2379  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2380 
2384  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2385 
2390  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2391 
2394  ImportOptionsKit & UnsetBRepMode();
2395 
2398  ImportOptionsKit & UnsetSolids();
2399 
2402  ImportOptionsKit & UnsetSurfaces();
2403 
2406  ImportOptionsKit & UnsetWireframes();
2407 
2410  ImportOptionsKit & UnsetPMI();
2411 
2414  ImportOptionsKit & UnsetAttributes();
2415 
2418  ImportOptionsKit & UnsetHiddenObjects();
2419 
2422  ImportOptionsKit & UnsetConstructionAndReferences();
2423 
2426  ImportOptionsKit & UnsetActiveFilter();
2427 
2430  ImportOptionsKit & UnsetDrawings();
2431 
2434  ImportOptionsKit & UnsetFeatureTrees();
2435 
2438  ImportOptionsKit & UnsetSewingTolerance();
2439 
2442  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2443 
2446  ImportOptionsKit & UnsetDefaultUnits();
2447 
2450  ImportOptionsKit & UnsetMultiProcessCount();
2451 
2454  ImportOptionsKit & UnsetPMISubstitutionFont();
2455 
2458  ImportOptionsKit & UnsetPMIPrecision();
2459 
2462  ImportOptionsKit & UnsetPMIDefaultUnits();
2463 
2466  ImportOptionsKit & UnsetPMIDefaultColor();
2467 
2470  ImportOptionsKit & UnsetTessellationLevel();
2471 
2474  ImportOptionsKit & UnsetTessellationAccuracy();
2475 
2478  ImportOptionsKit & UnsetTessellationCleanup();
2479 
2482  ImportOptionsKit & UnsetPMIFlipping();
2483 
2486  ImportOptionsKit & UnsetRemovedViews();
2487 
2490  ImportOptionsKit & UnsetExternalProductOccurrence();
2491 
2494  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2495 
2498  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2499 
2502  ImportOptionsKit & UnsetTextureDirectories();
2503 
2506  ImportOptionsKit & UnsetSearchDirectories();
2507 
2510  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2511 
2514  ImportOptionsKit & UnsetSearchRootDirectory();
2515 
2518  ImportOptionsKit & UnsetConfiguration();
2519 
2522  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2523 
2526  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2527 
2530  ImportOptionsKit & UnsetCatiaV5Cache();
2531 
2534  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2535 
2538  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2539 
2542  ImportOptionsKit & UnsetProECodePageName();
2543 
2546  ImportOptionsKit & UnsetProEDimensionTolerance();
2547 
2550  ImportOptionsKit & UnsetProESubpartPMI();
2551 
2554  ImportOptionsKit & UnsetProESessionColor();
2555 
2558  ImportOptionsKit & UnsetProEDatum();
2559 
2562  ImportOptionsKit & UnsetProEHomeView();
2563 
2566  ImportOptionsKit & UnsetProEExplodedViews();
2567 
2570  ImportOptionsKit & UnsetProEMissingBoolean();
2571 
2574  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2575 
2578  ImportOptionsKit & UnsetProEFamilyTreeSource();
2579 
2582  ImportOptionsKit & UnsetProEConstructionEntities();
2583 
2586  ImportOptionsKit & UnsetProESkeletons();
2587 
2590  ImportOptionsKit & UnsetSTEPNamePreference();
2591 
2594  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2595 
2598  ImportOptionsKit & UnsetSTEPCodePageName();
2599 
2602  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2603 
2606  ImportOptionsKit & UnsetSTEPOrientationHealing();
2607 
2610  ImportOptionsKit & UnsetSTEPValidationProperties();
2611 
2614  ImportOptionsKit & UnsetIFCCodePageName();
2615 
2618  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2619 
2622  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2623 
2626  ImportOptionsKit & UnsetIFCFaceOptimization();
2627 
2630  ImportOptionsKit & UnsetIFCEdges();
2631 
2634  ImportOptionsKit & UnsetIFCMetadata();
2635 
2638  ImportOptionsKit & UnsetPDF3DStreamIndex();
2639 
2642  ImportOptionsKit & UnsetJTTessellationLevel();
2643 
2646  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2647 
2650  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2651 
2654  ImportOptionsKit & UnsetPRCReadHelper();
2655 
2658  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2659 
2662  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2663 
2666  ImportOptionsKit & UnsetLocation();
2667 
2670  ImportOptionsKit & UnsetMode();
2671 
2674  ImportOptionsKit & UnsetIncrementalComponentPaths();
2675 
2678  ImportOptionsKit & UnsetNURBSConversion();
2679 
2682  ImportOptionsKit & UnsetGeometryDefaultColor();
2683 
2686  ImportOptionsKit & UnsetEverything();
2687 
2691  bool ShowBRepMode(BRepMode & out_mode) const;
2692 
2696  bool ShowSolids(bool & out_state) const;
2697 
2701  bool ShowSurfaces(bool & out_state) const;
2702 
2706  bool ShowWireframes(bool & out_state) const;
2707 
2711  bool ShowPMI(bool & out_state) const;
2712 
2716  bool ShowAttributes(bool & out_state) const;
2717 
2721  bool ShowHiddenObjects(bool & out_state) const;
2722 
2726  bool ShowConstructionAndReferences(bool & out_state) const;
2727 
2731  bool ShowActiveFilter(bool & out_state) const;
2732 
2736  bool ShowDrawings(bool & out_state) const;
2737 
2741  bool ShowFeatureTrees(bool & out_state) const;
2742 
2746  bool ShowSewingTolerance(double & out_tolerance) const;
2747 
2751  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2752 
2756  bool ShowDefaultUnits(Units & out_units) const;
2757 
2761  bool ShowMultiProcessCount(unsigned int & out_count) const;
2762 
2767  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2768 
2772  bool ShowPMIPrecision(size_t & out_precision) const;
2773 
2777  bool ShowPMIDefaultUnits(Units & out_units) const;
2778 
2783  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2784 
2792  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2793 
2800  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2801 
2805  bool ShowTessellationCleanup(bool & out_cleanup) const;
2806 
2810  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2811 
2815  bool ShowRemovedViews(bool & out_read_removed_views) const;
2816 
2820  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2821 
2825  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2826 
2830  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2831 
2835  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2836 
2842  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2843 
2847  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2848 
2853  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2854 
2858  bool ShowConfiguration(UTF8Array & out_configuration) const;
2859 
2863  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2864 
2868  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2869 
2874  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2875 
2880  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2881 
2885  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2886 
2890  bool ShowProECodePageName(UTF8 & out_name) const;
2891 
2895  bool ShowProEDimensionTolerance(bool & out_state) const;
2896 
2900  bool ShowProESubpartPMI(bool & out_state) const;
2901 
2905  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2906 
2910  bool ShowProEDatum(bool & out_state) const;
2911 
2915  bool ShowProEHomeView(bool & out_state) const;
2916 
2920  bool ShowProEExplodedViews(bool & out_state) const;
2921 
2925  bool ShowProEMissingBoolean(bool & out_state) const;
2926 
2930  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2931 
2935  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2936 
2940  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2941 
2945  bool ShowProESkeletons(bool & out_state) const;
2946 
2950  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2951 
2955  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2956 
2960  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2961 
2965  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2966 
2970  bool ShowSTEPOrientationHealing(bool & out_state) const;
2971 
2975  bool ShowSTEPValidationProperties(bool & out_state) const;
2976 
2980  bool ShowIFCCodePageName(UTF8 & out_name) const;
2981 
2985  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2986 
2990  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2991 
2995  bool ShowIFCFaceOptimization(bool & out_state) const;
2996 
3000  bool ShowIFCEdges(bool & out_state) const;
3001 
3005  bool ShowIFCMetadata(bool & out_state) const;
3006 
3010  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3011 
3015  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3016 
3020  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3021 
3025  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3026 
3030  bool ShowPRCReadHelper(bool & out_use_helper) const;
3031 
3035  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3036 
3040  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3041 
3046  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3047 
3051  bool ShowMode(ImportMode & out_mode) const;
3052 
3056  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3057 
3061  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3062 
3066  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3067  };
3068 
3070  class EXCHANGE_API Translation
3071  {
3072  public:
3075  enum class Healing
3076  {
3077  Off,
3078  On,
3079  OnlyIfNotParasolid,
3080  };
3081 
3084  enum class AccurateEdges
3085  {
3086  Off,
3087  On,
3088  OnlyIfNotParasolid,
3089  };
3090 
3093  enum class Simplification
3094  {
3095  Off,
3096  On,
3097  OnlyIfNotParasolid,
3098  };
3099 
3102  enum class Merging
3103  {
3104  Off,
3105  On,
3106  OnlyIfNotParasolid,
3107  };
3108 
3109  private:
3111  Translation();
3112  };
3113 
3115  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3116  {
3117  public:
3120 
3124 
3129 
3133  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3134 
3135  virtual ~TranslationOptionsKit();
3136 
3137  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3138  HPS::Type ObjectType() const { return staticType; }
3139 
3143  static TranslationOptionsKit GetDefault();
3144 
3147  void Set(TranslationOptionsKit const & in_kit);
3148 
3151  void Show(TranslationOptionsKit & out_kit) const;
3152 
3156  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3157 
3160  bool Empty() const;
3161 
3165  bool Equals(TranslationOptionsKit const & in_kit) const;
3166 
3170  bool operator==(TranslationOptionsKit const & in_kit) const;
3171 
3175  bool operator!=(TranslationOptionsKit const & in_kit) const;
3176 
3182  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3183 
3189  TranslationOptionsKit & SetTessellation(bool in_state);
3190 
3196  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3197 
3201  TranslationOptionsKit & SetApplication(char const * in_name);
3202 
3206  TranslationOptionsKit & SetVersion(char const * in_version);
3207 
3213  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3214 
3218  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3219 
3223  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3224 
3228  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3229 
3233  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3234 
3239  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3240 
3244  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3245 
3248  TranslationOptionsKit & UnsetSolidsAsFaces();
3249 
3252  TranslationOptionsKit & UnsetTessellation();
3253 
3256  TranslationOptionsKit & UnsetHiddenObjects();
3257 
3260  TranslationOptionsKit & UnsetApplication();
3261 
3264  TranslationOptionsKit & UnsetVersion();
3265 
3268  TranslationOptionsKit & UnsetHealing();
3269 
3272  TranslationOptionsKit & UnsetAccurateEdges();
3273 
3276  TranslationOptionsKit & UnsetSimplification();
3277 
3280  TranslationOptionsKit & UnsetEntityMerging();
3281 
3284  TranslationOptionsKit & UnsetSewing();
3285 
3288  TranslationOptionsKit & UnsetDisjointFaces();
3289 
3292  TranslationOptionsKit& UnsetExplodeMultiBodies();
3293 
3296  TranslationOptionsKit & UnsetEverything();
3297 
3298 
3302  bool ShowSolidsAsFaces(bool & out_state) const;
3303 
3307  bool ShowTessellation(bool & out_state) const;
3308 
3312  bool ShowHiddenObjects(bool & out_state) const;
3313 
3317  bool ShowApplication(UTF8 & out_name) const;
3318 
3322  bool ShowVersion(UTF8 & out_version) const;
3323 
3327  bool ShowExplodeMultiBodies(bool& out_state) const;
3328 
3332  bool ShowHealing(Translation::Healing & out_healing) const;
3333 
3337  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3338 
3342  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3343 
3347  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3348 
3353  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3354 
3358  bool ShowDisjointFaces(bool & out_state) const;
3359 
3364  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3365 
3368  TranslationOptionsKit & UnsetMultiProcessCount();
3369 
3373  bool ShowMultiProcessCount(unsigned int & out_count) const;
3374  };
3375 
3376 
3377 
3382  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3383  {
3384  public:
3387 
3391 
3396 
3400  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3401 
3402  virtual ~ModelFileImportOptionsKit();
3403 
3404  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3405  HPS::Type ObjectType() const { return staticType; }
3406 
3410  static ModelFileImportOptionsKit GetDefault();
3411 
3414  void Set(ModelFileImportOptionsKit const & in_kit);
3415 
3418  void Show(ModelFileImportOptionsKit & out_kit) const;
3419 
3423  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3424 
3427  bool Empty() const;
3428 
3432  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3433 
3437  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3438 
3442  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3443 
3444 
3445  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3446  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3447  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3448  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3449  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3450  * \return A reference to this ModelFileImportOptionsKit.
3451  */
3452  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3453 
3459  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3460 
3467  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3468 
3480  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);
3481 
3482  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3483  * \warning Setting this option to true will cause future exports to output without tessellation data.
3484  * \param in_cleanup Whether to clean up tessellation data from representation items.
3485  * \return A reference to this ImportOptionsKit.
3486  */
3487  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3488 
3494  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3495 
3501  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3502 
3509  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3510 
3514  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3515 
3528  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3529 
3535  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3536 
3543  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3544 
3548  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3549 
3554  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3555 
3561  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
3562 
3565  ModelFileImportOptionsKit & UnsetTessellationLevel();
3566 
3569  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3570 
3573  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3574 
3577  ModelFileImportOptionsKit & UnsetPMIFlipping();
3578 
3581  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3582 
3585  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3586 
3589  ModelFileImportOptionsKit & UnsetIFCEdges();
3590 
3593  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3594 
3597  ModelFileImportOptionsKit & UnsetLocation();
3598 
3601  ModelFileImportOptionsKit & UnsetSewingTolerance();
3602 
3605  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3606 
3609  ModelFileImportOptionsKit & UnsetNURBSConversion();
3610 
3613  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3614 
3617  ModelFileImportOptionsKit & UnsetHiddenObjects();
3618 
3621  ModelFileImportOptionsKit & UnsetEverything();
3622 
3623 
3631  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3632 
3639  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3640 
3644  bool ShowTessellationCleanup(bool & out_cleanup) const;
3645 
3649  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3650 
3654  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3655 
3659  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3660 
3664  bool ShowIFCEdges(bool & out_state) const;
3665 
3669  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3670 
3675  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3676 
3680  bool ShowSewingTolerance(double & out_tolerance) const;
3681 
3682 
3686  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3687 
3691  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3692 
3696  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3697 
3701  bool ShowHiddenObjects(bool & out_state) const;
3702  };
3703 
3704 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3705 
3706  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3707  {
3708  public:
3711 
3714  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3715 
3719 
3720  virtual ~Export3MFOptionsKit();
3721 
3722  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3723  HPS::Type ObjectType() const { return staticType; }
3724 
3728  static Export3MFOptionsKit GetDefault();
3729 
3732  void Set(Export3MFOptionsKit const & in_kit);
3733 
3736  void Show(Export3MFOptionsKit& out_kit) const;
3737 
3741  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3742 
3746  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3747 
3750  bool Empty() const;
3751 
3755  bool Equals(Export3MFOptionsKit const & in_kit) const;
3756 
3760  bool operator==(Export3MFOptionsKit const & in_kit) const;
3761 
3765  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3766 
3771  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3772 
3778  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3779 
3782  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3783 
3787  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3788 
3793  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3794 
3797  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3798 
3803  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3804 
3808  Export3MFOptionsKit & SetDescription(char const * in_description);
3809 
3812  Export3MFOptionsKit & UnsetDescription();
3813 
3817  bool ShowDescription(HPS::UTF8 & out_state) const;
3818 
3822  Export3MFOptionsKit & SetCopyright(char const * in_state);
3823 
3826  Export3MFOptionsKit & UnsetCopyright();
3827 
3831  bool ShowCopyright(HPS::UTF8 & out_state) const;
3832 
3836  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3837 
3840  Export3MFOptionsKit & UnsetLicenseTerms();
3841 
3845  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3846 
3849  Export3MFOptionsKit & UnsetEverything();
3850  };
3851 
3853  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
3854  {
3855  public:
3858 
3861  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
3862 
3866 
3867  virtual ~ExportFBXOptionsKit();
3868 
3869  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
3870  HPS::Type ObjectType() const { return staticType; }
3871 
3875  static ExportFBXOptionsKit GetDefault();
3876 
3879  void Set(ExportFBXOptionsKit const & in_kit);
3880 
3883  void Show(ExportFBXOptionsKit & out_kit) const;
3884 
3888  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
3889 
3893  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
3894 
3897  bool Empty() const;
3898 
3902  bool Equals(ExportFBXOptionsKit const & in_kit) const;
3903 
3907  bool operator==(ExportFBXOptionsKit const & in_kit) const;
3908 
3912  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
3913 
3914 
3922  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
3923 
3924 
3930  ExportFBXOptionsKit & SetAscii(bool in_state);
3931 
3932 
3935  ExportFBXOptionsKit & UnsetTextureFolder();
3936 
3939  ExportFBXOptionsKit & UnsetAscii();
3940 
3943  ExportFBXOptionsKit & UnsetEverything();
3944 
3945 
3949  bool ShowTextureFolder(UTF8 & out_path) const;
3950 
3954  bool ShowAscii(bool & out_state) const;
3955  };
3956 
3958  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3959  {
3960  public:
3963 
3967 
3971 
3972  virtual ~ExportACISOptionsKit();
3973 
3974  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
3975  HPS::Type ObjectType() const { return staticType; }
3976 
3980  static ExportACISOptionsKit GetDefault();
3981 
3984  void Set(ExportACISOptionsKit const & in_kit);
3985 
3988  void Show(ExportACISOptionsKit & out_kit) const;
3989 
3993  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3994 
3998  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3999 
4002  bool Empty() const;
4003 
4007  bool Equals(ExportACISOptionsKit const & in_kit) const;
4008 
4012  bool operator==(ExportACISOptionsKit const & in_kit) const;
4013 
4017  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4018 
4019 
4025  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4026 
4032  ExportACISOptionsKit & SetBinary(bool in_state);
4033 
4034 
4037  ExportACISOptionsKit & UnsetMillimeterUnits();
4038 
4041  ExportACISOptionsKit & UnsetBinary();
4042 
4045  ExportACISOptionsKit & UnsetEverything();
4046 
4047 
4051  bool ShowMillimeterUnits(bool & out_state) const;
4052 
4056  bool ShowBinary(bool & out_state) const;
4057  };
4058 
4060  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4061  {
4062  public:
4065 
4068  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4069 
4073 
4074  virtual ~ExportJTOptionsKit();
4075 
4076  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4077  HPS::Type ObjectType() const { return staticType; }
4078 
4082  static ExportJTOptionsKit GetDefault();
4083 
4086  void Set(ExportJTOptionsKit const & in_kit);
4087 
4090  void Show(ExportJTOptionsKit & out_kit) const;
4091 
4095  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4096 
4100  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4101 
4104  bool Empty() const;
4105 
4109  bool Equals(ExportJTOptionsKit const & in_kit) const;
4110 
4114  bool operator==(ExportJTOptionsKit const & in_kit) const;
4115 
4119  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4120 
4121 
4127  ExportJTOptionsKit & SetContent(JT::Content in_content);
4128 
4134  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4135 
4141  ExportJTOptionsKit & SetPMI(bool in_state);
4142 
4148  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4149 
4150 
4153  ExportJTOptionsKit & UnsetContent();
4154 
4157  ExportJTOptionsKit & UnsetHiddenObjects();
4158 
4161  ExportJTOptionsKit & UnsetPMI();
4162 
4165  ExportJTOptionsKit & UnsetVersion();
4166 
4169  ExportJTOptionsKit & UnsetEverything();
4170 
4171 
4175  bool ShowContent(JT::Content & out_content) const;
4176 
4180  bool ShowHiddenObjects(bool & out_state) const;
4181 
4185  bool ShowPMI(bool & out_state) const;
4186 
4190  bool ShowVersion(JT::Version & out_version) const;
4191  };
4192 
4194  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4195  {
4196  public:
4199 
4202  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4203 
4207 
4208  virtual ~ExportPRCOptionsKit();
4209 
4210  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4211  HPS::Type ObjectType() const { return staticType; }
4212 
4216  static ExportPRCOptionsKit GetDefault();
4217 
4220  void Set(ExportPRCOptionsKit const & in_kit);
4221 
4224  void Show(ExportPRCOptionsKit & out_kit) const;
4225 
4229  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4230 
4234  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4235 
4238  bool Empty() const;
4239 
4243  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4244 
4248  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4249 
4253  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4254 
4255 
4261  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4262 
4269  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4270 
4276  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4277 
4283  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4284 
4289  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4290 
4296  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4297 
4298 
4301  ExportPRCOptionsKit & UnsetTessellationCompression();
4302 
4305  ExportPRCOptionsKit & UnsetBRepCompression();
4306 
4309  ExportPRCOptionsKit & UnsetBRepRemoval();
4310 
4313  ExportPRCOptionsKit & UnsetAttributeRemoval();
4314 
4317  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4318 
4321  ExportPRCOptionsKit & UnsetEverything();
4322 
4323 
4327  bool ShowTessellationCompression(bool & out_state) const;
4328 
4332  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4333 
4337  bool ShowBRepRemoval(bool & out_state) const;
4338 
4342  bool ShowAttributeRemoval(bool & out_state) const;
4343 
4347  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4348  };
4349 
4351  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4352  {
4353  public:
4356 
4359  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4360 
4364 
4365  virtual ~ExportSTLOptionsKit();
4366 
4367  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4368  HPS::Type ObjectType() const { return staticType; }
4369 
4373  static ExportSTLOptionsKit GetDefault();
4374 
4377  void Set(ExportSTLOptionsKit const & in_kit);
4378 
4381  void Show(ExportSTLOptionsKit & out_kit) const;
4382 
4386  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4387 
4391  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4392 
4395  bool Empty() const;
4396 
4400  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4401 
4405  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4406 
4410  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4411 
4412 
4418  ExportSTLOptionsKit & SetBinary(bool in_state);
4419 
4425  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4426 
4433  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4434 
4440  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4441 
4447  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4448 
4455  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4456 
4466  ExportSTLOptionsKit & SetUnits(Units in_units);
4467 
4468 
4471  ExportSTLOptionsKit & UnsetBinary();
4472 
4475  ExportSTLOptionsKit & UnsetTessellationLevel();
4476 
4479  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4480 
4483  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4484 
4487  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4488 
4491  ExportSTLOptionsKit & UnsetUnits();
4492 
4495  ExportSTLOptionsKit & UnsetEverything();
4496 
4497 
4501  bool ShowBinary(bool & out_state) const;
4502 
4510  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4511 
4515  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4516 
4520  bool ShowCurrentTessellationRetention(bool & out_state) const;
4521 
4525  bool ShowMaximumEdgeLength(double & out_length) const;
4526 
4530  bool ShowUnits(Units & out_units) const;
4531  };
4532 
4534  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4535  {
4536  public:
4539 
4542  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
4543 
4547 
4548  virtual ~ExportOBJOptionsKit();
4549 
4550  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
4551  HPS::Type ObjectType() const { return staticType; }
4552 
4556  static ExportOBJOptionsKit GetDefault();
4557 
4560  void Set(ExportOBJOptionsKit const & in_kit);
4561 
4564  void Show(ExportOBJOptionsKit & out_kit) const;
4565 
4569  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
4570 
4574  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
4575 
4578  bool Empty() const;
4579 
4583  bool Equals(ExportOBJOptionsKit const & in_kit) const;
4584 
4588  bool operator==(ExportOBJOptionsKit const & in_kit) const;
4589 
4593  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
4594 
4599  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
4600 
4604  bool ShowTextureFolder(UTF8 & out_path) const;
4605 
4608  ExportOBJOptionsKit & UnsetTextureFolder();
4609 
4612  ExportOBJOptionsKit & UnsetEverything();
4613  };
4614 
4616  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4617  {
4618  public:
4621 
4624  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4625 
4629 
4630  virtual ~ExportU3DOptionsKit();
4631 
4632  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4633  HPS::Type ObjectType() const { return staticType; }
4634 
4638  static ExportU3DOptionsKit GetDefault();
4639 
4642  void Set(ExportU3DOptionsKit const & in_kit);
4643 
4646  void Show(ExportU3DOptionsKit & out_kit) const;
4647 
4651  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4652 
4656  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4657 
4660  bool Empty() const;
4661 
4665  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4666 
4670  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4671 
4675  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4676 
4677 
4683  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4684 
4689  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4690 
4691 
4694  ExportU3DOptionsKit & UnsetVersion();
4695 
4698  ExportU3DOptionsKit & UnsetCompression();
4699 
4702  ExportU3DOptionsKit & UnsetEverything();
4703 
4704 
4708  bool ShowVersion(U3D::Version & out_version) const;
4709 
4713  bool ShowCompression(unsigned char & out_level) const;
4714  };
4715 
4717  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4718  {
4719  public:
4722 
4725  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4726 
4730 
4731  virtual ~ExportXMLOptionsKit();
4732 
4733  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4734  HPS::Type ObjectType() const { return staticType; }
4735 
4739  static ExportXMLOptionsKit GetDefault();
4740 
4743  void Set(ExportXMLOptionsKit const & in_kit);
4744 
4747  void Show(ExportXMLOptionsKit & out_kit) const;
4748 
4752  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4753 
4757  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4758 
4761  bool Empty() const;
4762 
4766  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4767 
4771  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4772 
4776  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4777 
4778 
4784  ExportXMLOptionsKit & SetMetadata(bool in_state);
4785 
4791  ExportXMLOptionsKit & SetTransformations(bool in_state);
4792 
4798  ExportXMLOptionsKit & SetMaterials(bool in_state);
4799 
4800 
4803  ExportXMLOptionsKit & UnsetMetadata();
4804 
4807  ExportXMLOptionsKit & UnsetTransformations();
4808 
4811  ExportXMLOptionsKit & UnsetMaterials();
4812 
4815  ExportXMLOptionsKit & UnsetEverything();
4816 
4817 
4821  bool ShowMetadata(bool & out_state) const;
4822 
4826  bool ShowTransformations(bool & out_state) const;
4827 
4831  bool ShowMaterials(bool & out_state) const;
4832  };
4833 #endif
4834 
4835 #if !defined(TARGET_OS_ANDROID)
4836 
4837  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4838  {
4839  public:
4842 
4846 
4850 
4851  virtual ~ExportIGESOptionsKit();
4852 
4853  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4854  HPS::Type ObjectType() const { return staticType; }
4855 
4859  static ExportIGESOptionsKit GetDefault();
4860 
4863  void Set(ExportIGESOptionsKit const & in_kit);
4864 
4867  void Show(ExportIGESOptionsKit & out_kit) const;
4868 
4872  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4873 
4877  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4878 
4881  bool Empty() const;
4882 
4886  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4887 
4891  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4892 
4896  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4897 
4898 
4904  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4905 
4911  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4912 
4918  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4919 
4925  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4926 
4932  ExportIGESOptionsKit & SetTessellation(bool in_state);
4933 
4937  ExportIGESOptionsKit & SetApplication(char const * in_name);
4938 
4942  ExportIGESOptionsKit & SetVersion(char const * in_version);
4943 
4944 
4947  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4948 
4951  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
4952 
4955  ExportIGESOptionsKit & UnsetSolidsAsFaces();
4956 
4959  ExportIGESOptionsKit & UnsetHiddenObjects();
4960 
4963  ExportIGESOptionsKit & UnsetTessellation();
4964 
4967  ExportIGESOptionsKit & UnsetApplication();
4968 
4971  ExportIGESOptionsKit & UnsetVersion();
4972 
4975  ExportIGESOptionsKit & UnsetEverything();
4976 
4977 
4981  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4982 
4986  bool ShowFacetedAsWireframe(bool & out_state) const;
4987 
4991  bool ShowSolidsAsFaces(bool & out_state) const;
4992 
4996  bool ShowHiddenObjects(bool & out_state) const;
4997 
5001  bool ShowTessellation(bool & out_state) const;
5002 
5006  bool ShowApplication(UTF8 & out_name) const;
5007 
5011  bool ShowVersion(UTF8 & out_version) const;
5012  };
5013 
5015  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5016  {
5017  public:
5020 
5024 
5028 
5029  virtual ~ExportParasolidOptionsKit();
5030 
5031  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5032  HPS::Type ObjectType() const { return staticType; }
5033 
5037  static ExportParasolidOptionsKit GetDefault();
5038 
5041  void Set(ExportParasolidOptionsKit const & in_kit);
5042 
5045  void Show(ExportParasolidOptionsKit & out_kit) const;
5046 
5050  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5051 
5055  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5056 
5059  bool Empty() const;
5060 
5064  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5065 
5069  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5070 
5074  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5075 
5076 
5082  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5083 
5089  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5090 
5096  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5097 
5101  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5102 
5106  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5107 
5113  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5114 
5117  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5118 
5121  ExportParasolidOptionsKit & UnsetTessellation();
5122 
5125  ExportParasolidOptionsKit & UnsetHiddenObjects();
5126 
5129  ExportParasolidOptionsKit & UnsetApplication();
5130 
5133  ExportParasolidOptionsKit & UnsetVersion();
5134 
5137  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5138 
5141  ExportParasolidOptionsKit & UnsetEverything();
5142 
5143 
5147  bool ShowSolidsAsFaces(bool & out_state) const;
5148 
5152  bool ShowTessellation(bool & out_state) const;
5153 
5157  bool ShowHiddenObjects(bool & out_state) const;
5158 
5162  bool ShowApplication(UTF8 & out_name) const;
5163 
5167  bool ShowVersion(UTF8 & out_version) const;
5168 
5172  bool ShowExplodeMultiBodies(bool& out_state) const;
5173  };
5174 
5176  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5177  {
5178  public:
5181 
5185 
5189 
5190  virtual ~ExportSTEPOptionsKit();
5191 
5192  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5193  HPS::Type ObjectType() const { return staticType; }
5194 
5198  static ExportSTEPOptionsKit GetDefault();
5199 
5202  void Set(ExportSTEPOptionsKit const & in_kit);
5203 
5206  void Show(ExportSTEPOptionsKit & out_kit) const;
5207 
5211  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5212 
5216  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5217 
5220  bool Empty() const;
5221 
5225  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5226 
5230  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5231 
5235  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5236 
5237 
5243  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5244 
5250  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5251 
5257  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5258 
5264  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5265 
5269  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5270 
5274  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5275 
5279  ExportSTEPOptionsKit & SetPMI(bool in_state);
5280 
5284  ExportSTEPOptionsKit & SetCurves(bool in_state);
5285 
5289  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5290 
5294  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5295 
5299  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5300 
5303  ExportSTEPOptionsKit & UnsetFormat();
5304 
5307  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5308 
5311  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5312 
5315  ExportSTEPOptionsKit & UnsetNameShortening();
5316 
5319  ExportSTEPOptionsKit & UnsetApplication();
5320 
5323  ExportSTEPOptionsKit & UnsetVersion();
5324 
5327  ExportSTEPOptionsKit & UnsetPMI();
5328 
5331  ExportSTEPOptionsKit & UnsetCurves();
5332 
5335  ExportSTEPOptionsKit & UnsetAttributes();
5336 
5339  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5340 
5343  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5344 
5347  ExportSTEPOptionsKit & UnsetEverything();
5348 
5349 
5353  bool ShowFormat(STEP::Format & out_format) const;
5354 
5358  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5359 
5363  bool ShowFacetedAsWireframe(bool & out_state) const;
5364 
5368  bool ShowNameShortening(bool & out_state) const;
5369 
5373  bool ShowApplication(UTF8 & out_name) const;
5374 
5378  bool ShowVersion(UTF8 & out_version) const;
5379 
5383  bool ShowPMI(bool & out_state) const;
5384 
5388  bool ShowCurves(bool & out_state) const;
5389 
5393  bool ShowAttributes(bool & out_state) const;
5394 
5398  bool ShowPMIWithSemantic(bool & out_state) const;
5399 
5403  bool ShowPMIAsTessellated(bool & out_state) const;
5404  };
5405 #endif
5406 
5408  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5409  {
5410  public:
5413 
5417 
5421 
5422  virtual ~TessellationOptionsKit();
5423 
5424  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5425  HPS::Type ObjectType() const { return staticType; }
5426 
5430  static TessellationOptionsKit GetDefault();
5431 
5434  void Set(TessellationOptionsKit const & in_kit);
5435 
5438  void Show(TessellationOptionsKit & out_kit) const;
5439 
5443  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5444 
5448  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5449 
5452  bool Empty() const;
5453 
5457  bool Equals(TessellationOptionsKit const & in_kit) const;
5458 
5462  bool operator==(TessellationOptionsKit const & in_kit) const;
5463 
5467  bool operator!=(TessellationOptionsKit const & in_kit) const;
5468 
5469 
5473  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5474 
5481  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5482 
5492  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);
5493 
5497  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5498 
5502  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5503 
5504 
5507  TessellationOptionsKit & UnsetLevel();
5508 
5511  TessellationOptionsKit & UnsetAccuracy();
5512 
5515  TessellationOptionsKit & UnsetUVPointPreservation();
5516 
5519  TessellationOptionsKit & UnsetMaximumEdgeLength();
5520 
5523  TessellationOptionsKit & UnsetEverything();
5524 
5525 
5533  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5534 
5541  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5542 
5546  bool ShowUVPointPreservation(bool & out_state) const;
5547 
5551  bool ShowMaximumEdgeLength(double & out_length) const;
5552  };
5553 
5559  class EXCHANGE_API CommonMeasurementOperator : public Operator
5560  {
5561  public:
5562  enum class Tags
5563  {
5564  Name = 0,
5565  MeasurementType,
5566  Radius,
5567  Inverted,
5568  VectorX,
5569  VectorY,
5570  VectorZ,
5571  };
5572 
5574 
5575  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5576 
5578  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5579 
5580  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5581  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5582 
5583  Exchange::CADModel GetCADModel() const;
5584  void SetCADModel(Exchange::CADModel const & in_cad_model);
5585 
5587  size_t GetPrecision() const;
5588 
5591  void SetPrecision(size_t in_precision);
5592 
5594  MaterialMappingKit GetMaterial() const;
5595 
5598  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5599 
5601  TextAttributeKit GetTextAttributes() const;
5602 
5605  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5606 
5608  SegmentKey GetMeasurementSegment() const;
5609 
5611  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5612 
5613  /* Deletes all measurements */
5614  void DeleteMeasurements();
5615 
5616  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5617  {
5618  public:
5621  {
5622  channel = GetClassID();
5623  consumable = false;
5624  }
5625 
5626  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5627  {
5628  channel = GetClassID();
5629  consumable = false;
5630  measurement_key = in_measurement_key;
5631  view = in_view;
5632  }
5633 
5636  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5637  {
5638  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5639  {
5640  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5641  measurement_key = that.measurement_key;
5642  view = that.view;
5643  }
5644  else
5645  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5646  }
5647 
5649 
5652  Event * Clone() const
5653  {
5654  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5655  return new_event;
5656  }
5657 
5658  Key measurement_key;
5659  View view;
5660  };
5661 
5662  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5663  {
5664  public:
5667  {
5668  channel = GetClassID();
5669  consumable = false;
5670  }
5671 
5672  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5673  {
5674  channel = GetClassID();
5675  consumable = false;
5676  measurement_name = in_measurement_name;
5677  view = in_view;
5678  }
5679 
5682  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5683  {
5684  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5685  {
5686  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5687  measurement_name = that.measurement_name;
5688  view = that.view;
5689  }
5690  else
5691  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5692  }
5693 
5695 
5698  Event * Clone() const
5699  {
5700  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5701  return new_event;
5702  }
5703 
5704  UTF8 measurement_name;
5705  View view;
5706  };
5707 
5708  protected:
5709  Exchange::CADModel cad_model;
5710  size_t measurement_precision;
5711  UTF8 units;
5712  MaterialMappingKit materials;
5713  TextAttributeKit text_attributes;
5714  SegmentKey measurement_segment;
5715  GlyphDefinition left_arrow;
5716  GlyphDefinition right_arrow;
5717  SelectionOptionsKit selection_options;
5718  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5719  Vector camera_direction;
5720  PortfolioKey portfolio;
5721  SegmentKey style_segment;
5722  HighlightOptionsKit highlight_options;
5723 
5724  static size_t length_measurement_index;
5725  static size_t radius_measurement_index;
5726  static size_t distance_measurement_index;
5727  static size_t angle_measurement_index;
5728 
5729  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5730  void GetUnits();
5731  void SetGlyphColor();
5732  void GetCameraDirection();
5733  void SetupConstructionSegment();
5734  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5735  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5736  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5737  float GetModelScale(Exchange::Component const & component);
5738  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5739  };
5740 
5794  {
5795  public:
5796  enum class MeasurementType
5797  {
5798  PointToPoint,
5799  EdgeAndRadius,
5800  FeatureToFeature,
5801  FaceAngle,
5802  };
5803 
5805 
5806  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5807 
5809  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5810 
5811  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5812  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5813 
5818  virtual bool OnMouseDown(MouseState const & in_state) override;
5819 
5823  virtual bool OnMouseUp(MouseState const & in_state) override;
5824 
5830  virtual bool OnMouseMove(MouseState const & in_state) override;
5831 
5836  virtual bool OnTouchDown(TouchState const & in_state) override;
5837 
5841  virtual bool OnTouchUp(TouchState const & in_state) override;
5842 
5848  virtual bool OnTouchMove(TouchState const & in_state) override;
5849 
5853  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5854 
5857  void SetMeasurementType(MeasurementType in_measurement_type);
5858 
5861  MeasurementType GetMeasurementType();
5862 
5865  void SetMouseOverHighlighting(bool in_highlighting);
5866 
5870  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5871 
5874  bool GetMouseOverHighlighting();
5875 
5878  HighlightOptionsKit GetHighlightOptions();
5879 
5882  bool IsMeasurementActive();
5883 
5885  void DeleteLastMeasurement();
5886 
5887  private:
5888  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5889  {
5890  Circle,
5891  Line,
5892  Generic,
5893  };
5894 
5895  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5896  {
5897  public:
5898  Surface();
5899 
5900  enum class SurfaceType
5901  {
5902  Plane,
5903  ConeOrCylinder,
5904  Unsupported,
5905  };
5906 
5907  SurfaceType surface_type; //the type of surface being measured
5908  Point center; //the center point of the surface
5909  Vector normal; //the center line of surfaces of type Cylinder or Cone
5910  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5911  ComponentPath path; //the ComponentPath to this surface
5912  };
5913 
5914  //bookkeeping
5915  MeasurementType measurement_type; //the type of measurement to be inserted
5916  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5917  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5918  TouchID current_touch_id; //the ID of the touch being processed
5919  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5920  bool operator_active; //whether a measurement is in progress
5921  bool end_measurement; //whether we should end the current measurement
5922  CanvasArray canvases; //canvases related to the view where this operator is attached
5923 
5924  //measurement anchors
5925  size_t anchors; //valid for point-to-point and face-angle measurements
5926  bool anchors_in_place; //true if all the anchors have been placed
5927  Point first_click_position; //position of the first anchor
5928  Point second_click_position; //position of the second anchor
5929 
5930  //geometry for linear measurements
5931  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5932  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5933  LineKey distance_line; //a line representing the distance measured
5934  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5935  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5936  Point distance_point_one; //intersection of leader_line_one and distance_line
5937  Point distance_point_two; //intersection of leader_line_two and distance_line
5938  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5939  TextKey text; //text representing the measurement and units
5940  UTF8 text_string; //the contents of the text
5941  Vector measurement_direction; //the direction of the measurement
5942  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5943  Vector explicit_direction; //used if use_explicit_direction is true
5944 
5945  //geometry for radius measurement
5946  MarkerKey center_marker; //marker representing the center of the circle
5947  Point circle_center; //circle center
5948  float radius; //circle radius
5949 
5950  //edge specific data
5951  LineKey edge_line; //the edge being measured
5952  double edge_length; //length of the measured edge
5953  EdgeType edge_type; //the type of edge being measured
5954 
5955  //feature-to-feature specific data
5956  Surface surface_one; //data related to first selected surface
5957  Surface surface_two; //data related to second selected surface
5958  Plane measurement_plane; //the measurement plane
5959  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5960 
5961  //angle specific data
5962  Vector leader_line_one_direction; //the direction of the first leader line
5963  Vector leader_line_two_direction; //the direction of the second leader line
5964  Vector first_face_normal; //the normal of the first selected face
5965  Vector second_face_normal; //the normal of the second selected face
5966  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'
5967  CircularArcKey measurement_arc; //an arc representing the measured angle
5968  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5969  Vector mid_point_direction;
5970 
5971  //selection kits
5972  SelectionOptionsKit point_to_point_selection;
5973  SelectionOptionsKit edge_radius_selection;
5974  SelectionOptionsKit feature_to_feature_selection;
5975  SelectionOptionsKit angle_selection;
5976 
5977  //highlighting
5978  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5979  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5980  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5981  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5982  KeyPath highlighted_path; //highlighted_path
5983  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5984  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5985 
5986  //input handling
5987  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5988  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5989  bool InputUp(WindowKey & in_window);
5990  void ResetMeasurement();
5991 
5992  //inserting measurements
5993  void InsertPointToPointMeasurement(Point const & in_world_point);
5994  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5995  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5996  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5997  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5998  void InvertMeasuredAngle(WindowKey & in_window);
5999  void AdjustLineToCursor(Point const & cursor_position);
6000 
6001  //saving measurements
6002  void TagMeasurement();
6003  void TagPointToPointMeasurement();
6004  void TagEdgeMeasurement();
6005  void TagRadiusMeasurement();
6006  void TagGenericEdgeMeasurement();
6007  void TagFeatureToFeatureMeasurement();
6008  void TagAngleMeasurement();
6009 
6010  //restoring measurements
6011  void RestoreMeasurement(SegmentKey const & measurement_segment);
6012  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6013  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6014  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6015  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6016  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6017  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6018 
6019  //topology functions
6020  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6021  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6022  void PlaneToCenterLineDistance();
6023  void PlaneToPlaneDistance();
6024  void LineToLineDistance();
6025  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);
6026  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6027  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6028  bool IsPlane(Exchange::Component const & face_component);
6029  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6030  };
6031 
6032 private:
6034  Exchange();
6035 };
6036 
6037 }
6038 
6039 #endif
Definition: hps.h:6285
Definition: hps.h:85
Definition: sprk_exchange.h:4194
Level
Definition: sprk_exchange.h:916
ConstructionEntities
Definition: sprk_exchange.h:1079
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1030
Definition: sprk.h:273
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5193
Definition: sprk_exchange.h:1196
Definition: sprk_exchange.h:5559
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4551
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4854
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5889
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:67
Simplification
Definition: sprk_exchange.h:3093
Definition: sprk.h:106
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5578
Definition: sprk_exchange.h:656
Version
Definition: sprk_exchange.h:1100
Definition: sprk_exchange.h:3382
Definition: sprk_exchange.h:926
intptr_t GetChannel() const
Definition: hps.h:6402
Definition: sprk_exchange.h:757
SurfaceType
Definition: sprk_exchange.h:848
Definition: hps.h:1742
Format
Definition: sprk_exchange.h:1017
Definition: sprk_exchange.h:4717
Definition: sprk.h:242
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5425
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6751
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6727
Definition: hps.h:48831
Format
Definition: sprk_exchange.h:1201
Definition: hps.h:7793
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6721
Type
Definition: sprk_exchange.h:907
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3723
Definition: hps.h:16460
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1150
Definition: sprk_exchange.h:504
Definition: sprk_exchange.h:595
Definition: sprk_exchange.h:334
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1485
HPS::Type ObjectType() const
Definition: sprk_exchange.h:531
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4734
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4633
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3870
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
HPS::Type ObjectType() const
Definition: sprk_exchange.h:786
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5636
Definition: sprk_exchange.h:1462
Definition: sprk_exchange.h:274
HPS::Type ObjectType() const
Definition: sprk_exchange.h:624
Definition: sprk_exchange.h:4060
Merging
Definition: sprk_exchange.h:3102
Field
Definition: sprk_exchange.h:1007
Definition: sprk_exchange.h:4534
Definition: hps.h:48729
Definition: hps.h:42106
Definition: sprk_exchange.h:3958
Definition: sprk_exchange.h:3115
Event * Clone() const
Definition: sprk_exchange.h:5698
Limit
Definition: sprk_exchange.h:931
Definition: hps.h:4549
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3405
TessellationLevel
Definition: sprk_exchange.h:980
Definition: sprk_exchange.h:902
Definition: sprk_exchange.h:4351
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:1002
Definition: sprk_exchange.h:3853
Definition: hps.h:4488
Definition: hps.h:7164
Definition: hps.h:48200
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3975
Definition: sprk_exchange.h:455
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:44119
Definition: hps.h:48616
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:895
Definition: sprk_exchange.h:4616
Definition: sprk_exchange.h:966
Definition: hps.h:15847
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6707
Definition: sprk_exchange.h:1095
SessionColor
Definition: sprk_exchange.h:1054
Definition: sprk.h:1778
Definition: hps.h:48938
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:45318
Definition: hps.h:47707
CurveType
Definition: sprk_exchange.h:871
Definition: sprk_exchange.h:549
Definition: hps.h:6369
Definition: hps.h:14095
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6719
Definition: sprk_exchange.h:5793
Definition: sprk.h:484
BRepCompression
Definition: sprk_exchange.h:1035
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5032
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:821
Definition: sprk.h:2148
ComponentType
Definition: sprk.h:1784
Accuracy
Definition: sprk_exchange.h:948
Definition: sprk_exchange.h:3706
Definition: sprk_exchange.h:4837
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5682
Definition: sprk.h:2854
FamilyTable
Definition: sprk_exchange.h:1067
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4368
Content
Definition: sprk_exchange.h:971
Definition: sprk_exchange.h:1687
Definition: sprk.h:2954
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4077
static MouseButtons ButtonLeft()
Definition: hps.h:48318
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5809
Event * Clone() const
Definition: sprk_exchange.h:5652
Definition: hps.h:7711
HPS::Type ObjectType() const
Definition: sprk_exchange.h:685
Definition: sprk_exchange.h:1049
AccurateEdges
Definition: sprk_exchange.h:3084
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
Definition: hps.h:9424
HPS::Type ObjectType() const
Definition: sprk_exchange.h:739
Definition: sprk_exchange.h:710
Definition: hps.h:24682
Healing
Definition: sprk_exchange.h:3075
Definition: sprk.h:3041
Definition: hps.h:31115
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
ImportMode
Definition: sprk_exchange.h:836
Definition: sprk_exchange.h:1112
Definition: hps.h:515
Definition: sprk.h:1107
Definition: sprk_exchange.h:3070
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:5015
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1710
Definition: sprk_exchange.h:203
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3138
Definition: hps.h:41602
Version
Definition: sprk_exchange.h:989
Definition: sprk_exchange.h:5408
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4211
Definition: hps.h:42737
Definition: sprk_exchange.h:5176