API Search || Global Search
sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
437 
442  void Tessellate(TessellationOptionsKit const & in_options);
443 
450  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
451  };
452 
455  class EXCHANGE_API Capture : public HPS::Capture
456  {
457  public:
459  Capture();
460 
464  Capture(Component const & in_that);
465 
469  Capture(HPS::Capture const & in_that);
470 
473  Capture(Exchange::Capture const & in_that);
474 
477  Capture(Exchange::Capture && in_that);
478 
479  virtual ~Capture();
480 
481  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
482  HPS::Type ObjectType() const { return staticType; }
483 
484 #if !defined(_MSC_VER) || _MSC_VER >= 1900
485  Capture & operator=(Exchange::Capture const & in_that) = default;
486 #endif
487 
491  Capture & operator=(Exchange::Capture && in_that);
492 
493 
496  A3DEntity * GetExchangeEntity() const;
497  };
498 
501  class EXCHANGE_API Filter : public HPS::Filter
502  {
503  public:
505  Filter();
506 
510  Filter(Component const & in_that);
511 
515  Filter(HPS::Filter const & in_that);
516 
519  Filter(Exchange::Filter const & in_that);
520 
523  Filter(Exchange::Filter && in_that);
524 
525  virtual ~Filter();
526 
527  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
528  HPS::Type ObjectType() const { return staticType; }
529 
530 #if !defined(_MSC_VER) || _MSC_VER >= 1900
531  Filter & operator=(Exchange::Filter const & in_that) = default;
532 #endif
533 
537  Filter & operator=(Exchange::Filter && in_that);
538 
539 
542  A3DEntity * GetExchangeEntity() const;
543  };
544 
546  class EXCHANGE_API Factory : public Sprocket
547  {
548  public:
553  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
554 
560  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
561 
565  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
566 
573  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
574 
578  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
579 
584  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
585 
586  private:
588  Factory();
589  };
590 
592  class EXCHANGE_API ImportNotifier : public IONotifier
593  {
594  public:
596  ImportNotifier();
597 
600  ImportNotifier(ImportNotifier const & in_that);
601 
606  ImportNotifier(IONotifier const & in_that);
607 
611  ImportNotifier(ImportNotifier && in_that);
612 
616  ImportNotifier & operator=(ImportNotifier && in_that);
617 
618  virtual ~ImportNotifier();
619 
620  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
621  HPS::Type ObjectType() const { return staticType; };
622 
626  ImportNotifier & operator=(ImportNotifier const & in_that);
627 
630  void Assign(ImportNotifier const & in_that);
631 
634  Exchange::CADModel GetCADModel() const;
635 
641  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
642 
645  Time GetImportTime() const;
646 
649  Time GetParseTime() const;
650  };
651 
653  class EXCHANGE_API TranslationNotifier : public IONotifier
654  {
655  public:
658 
661  TranslationNotifier(TranslationNotifier const & in_that);
662 
667  TranslationNotifier(IONotifier const & in_that);
668 
673 
677  TranslationNotifier & operator=(TranslationNotifier && in_that);
678 
679  virtual ~TranslationNotifier();
680 
681  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
682  HPS::Type ObjectType() const { return staticType; };
683 
687  TranslationNotifier & operator=(TranslationNotifier const & in_that);
688 
691  void Assign(TranslationNotifier const & in_that);
692 
695  Exchange::ParasolidEntityArray GetParasolidParts() const;
696 
699  HPS::Time GetImportTime() const;
700 
703  HPS::Time GetTranslationTime() const;
704  };
705 
707  class EXCHANGE_API ExportNotifier : public IONotifier
708  {
709  public:
711  ExportNotifier();
712 
715  ExportNotifier(ExportNotifier const & in_that);
716 
721  ExportNotifier(IONotifier const & in_that);
722 
726  ExportNotifier(ExportNotifier && in_that);
727 
731  ExportNotifier & operator=(ExportNotifier && in_that);
732 
733  virtual ~ExportNotifier();
734 
735  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
736  HPS::Type ObjectType() const { return staticType; };
737 
741  ExportNotifier & operator=(ExportNotifier const & in_that);
742 
745  void Assign(ExportNotifier const & in_that);
746 
750  A3DAsmModelFile * GetModelFile() const;
751  };
752 
754  class EXCHANGE_API ReloadNotifier : public IONotifier
755  {
756  public:
758  ReloadNotifier();
759 
762  ReloadNotifier(ReloadNotifier const & in_that);
763 
768  ReloadNotifier(IONotifier const & in_that);
769 
773  ReloadNotifier(ReloadNotifier && in_that);
774 
778  ReloadNotifier & operator=(ReloadNotifier && in_that);
779 
780  virtual ~ReloadNotifier();
781 
782  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
783  HPS::Type ObjectType() const { return staticType; };
784 
788  ReloadNotifier & operator=(ReloadNotifier const & in_that);
789 
792  void Assign(ReloadNotifier const & in_that);
793  };
794 
795 
796  class ImportOptionsKit;
798 
799 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
800  class Export3MFOptionsKit;
801  class ExportACISOptionsKit;
802  class ExportJTOptionsKit;
803  class ExportPRCOptionsKit;
804  class ExportSTLOptionsKit;
805  class ExportU3DOptionsKit;
806  class ExportXMLOptionsKit;
807 #endif
808 
809 #if !defined(TARGET_OS_ANDROID)
810  class ExportSTEPOptionsKit;
811  class ExportIGESOptionsKit;
812 #endif
813 
816  enum class BRepMode
817  {
820  TessellationOnly,
823  BRepOnly,
826  BRepAndTessellation,
827  };
828 
831  enum class ImportMode
832  {
835  Complete,
838  Incremental,
839  };
840 
843  enum class SurfaceType
844  {
845  Blend01,
846  Blend02,
847  Blend03,
848  Blend04,
849  NURBS,
850  Cone,
851  Cylinder,
852  Offset,
853  Pipe,
854  Plane,
855  Ruled,
856  Sphere,
857  Revolution,
858  Extrusion,
859  FromCurve,
860  Torus,
861  Transform,
862  };
863 
866  enum class CurveType
867  {
868  Blend,
869  NURBS,
870  Circle,
871  Composite,
872  CurveOnSurface,
873  Ellipse,
874  Equation,
875  Helix,
876  Hyperbola,
877  Intersection,
878  Line,
879  Offset,
880  Parabola,
881  Polyline,
882  Transform,
883  };
884 
885  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
886  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
887 
891  {
892  PMIOnly,
893  ModelAndPMI
894  };
895 
897  class EXCHANGE_API Tessellation
898  {
899  public:
902  enum class Type
903  {
904  Standard,
905  Custom
906  };
907 
908 
911  enum class Level
912  {
913  ExtraLow,
914  Low,
915  Medium,
916  High,
917  ExtraHigh,
918  };
919 
921  class EXCHANGE_API Chord
922  {
923  public:
926  enum class Limit
927  {
930  Ratio,
933  Height
934  };
935 
936  private:
938  Chord();
939  };
940 
943  enum class Accuracy
944  {
947  Standard,
950  Accurate,
952  GridAccurate
953  };
954 
955  private:
957  Tessellation();
958  };
959 
961  class EXCHANGE_API JT
962  {
963  public:
966  enum class Content
967  {
968  Geometry,
969  Tessellation,
970  GeometryAndTessellation
971  };
972 
975  enum class TessellationLevel
976  {
977  Low,
978  Medium,
979  High,
980  };
981 
984  enum class Version
985  {
986  JT81,
987  JT95,
988  };
989 
990  private:
992  JT();
993  };
994 
996  class EXCHANGE_API STEP
997  {
998  public:
1001  enum class Field
1002  {
1003  ProductName,
1004  NextAssemblyUsageOccurrenceID,
1005  NextAssemblyUsageOccurrenceName,
1006  NextAssemblyUsageOccurrenceDescription
1007  };
1008 
1011  enum class Format
1012  {
1013  AP203,
1014  AP214,
1015  AP242,
1016  };
1017 
1018  private:
1020  STEP();
1021  };
1022 
1024  class EXCHANGE_API PRC
1025  {
1026  public:
1029  enum class BRepCompression
1030  {
1031  None,
1032  Low,
1033  Medium,
1034  High
1035  };
1036 
1037  private:
1039  PRC();
1040  };
1041 
1043  class EXCHANGE_API ProE
1044  {
1045  public:
1048  enum class SessionColor
1049  {
1051  LastCreoVersion,
1053  ExchangeDefault,
1056  UserDefined
1057  };
1058 
1061  enum class FamilyTable
1062  {
1064  BRepOnly,
1066  BRepOrTessellation,
1068  BRepOrTessellationOrGeneric
1069  };
1070 
1074  {
1076  On,
1078  Off,
1080  AsDatum,
1081  };
1082 
1083  private:
1085  ProE();
1086  };
1087 
1089  class EXCHANGE_API U3D
1090  {
1091  public:
1094  enum class Version
1095  {
1096  ECMA1,
1097  ECMA3
1098  };
1099 
1100  private:
1102  U3D();
1103  };
1104 
1106  class EXCHANGE_API Configuration : public HPS::Sprocket
1107  {
1108  public:
1110  Configuration();
1111 
1114  Configuration(char const * in_name);
1115 
1120  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1121 
1125  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1126 
1129  Configuration(Configuration const & in_configuration);
1130 
1134  Configuration(Configuration && in_that);
1135 
1139  Configuration & operator=(Configuration && in_that);
1140 
1141  virtual ~Configuration();
1142 
1143  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1144  HPS::Type ObjectType() const { return staticType; }
1145 
1146 
1149  void Set(Configuration const & in_kit);
1150 
1153  void Show(Configuration & out_kit) const;
1154 
1158  Configuration & operator=(Configuration const & in_kit);
1159 
1162  bool Empty() const;
1163 
1167  bool Equals(Configuration const & in_kit) const;
1168 
1172  bool operator==(Configuration const & in_kit) const;
1173 
1177  bool operator!=(Configuration const & in_kit) const;
1178 
1179 
1182  HPS::UTF8 GetName() const;
1183 
1186  ConfigurationArray GetSubconfigurations() const;
1187  };
1188 
1190  class EXCHANGE_API File
1191  {
1192  public:
1195  enum class Format
1196  {
1197  Unsupported,
1198  ACIS,
1199  CADDS,
1200  CATIAV4,
1201  CATIAV5,
1202  CGR,
1203  COLLADA,
1204  CreoProE,
1205  DWG,
1206  DXF,
1207  IDEAS,
1208  IFC,
1209  IGES,
1210  Inventor,
1211  JT,
1212  KeyholeMarkupLanguage,
1213  LatticeXVL,
1214  OneSpaceDesigner,
1215  Parasolid,
1216  PDF,
1217  PRC,
1218  Rhino,
1219  NXUnigraphics,
1220  SolidEdge,
1221  SolidWorks,
1222  STEP,
1223  StereoLithography,
1224  ThreeDStudioMax,
1225  ThreeDXML,
1226  Universal3D,
1227  VDAFS,
1228  VRML,
1229  WavefrontObject,
1230  Revit,
1231  GLTF,
1232  DWF,
1233  FBX,
1234  };
1235 
1237  static Format GetFormat(char const * in_file_name);
1238 
1242  static ConfigurationArray GetConfigurations(char const * in_file_name);
1243 
1255  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);
1256 
1262  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1263 
1270  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1271 
1278  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1279 
1287  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1288 
1295  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1296 
1297 
1304  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1305 
1306 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1307 
1311  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1312 
1318  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1319 
1326  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1327 
1333  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1334 
1339  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1340 
1345  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1346 
1352  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1353 
1359  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1360 
1367  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1368 
1375  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1376 
1380  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1381 
1386  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1387 
1391  static ExportNotifier ExportPRC(KeyPath const & in_source);
1392 
1397  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1398 
1403  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1404 
1408  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1409 
1414  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1415 #endif
1416 
1417 #if TARGET_OS_ANDROID == 0
1418 
1422  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1423 
1428  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1429 
1434  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1435 #endif
1436 
1437  private:
1439  File();
1440  };
1441 
1443  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1444  {
1445  public:
1448 
1452 
1457 
1461  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1462 
1463  virtual ~NURBSConversionOptionsKit();
1464 
1465  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1466  HPS::Type ObjectType() const { return staticType; }
1467 
1470  void Set(NURBSConversionOptionsKit const & in_kit);
1471 
1474  void Show(NURBSConversionOptionsKit & out_kit) const;
1475 
1479  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1480 
1483  bool Empty() const;
1484 
1488  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1489 
1493  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1494 
1498  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1499 
1503  static NURBSConversionOptionsKit GetDefault();
1504 
1509  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1510 
1515  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1516 
1521  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1522 
1527  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1528 
1533  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1534 
1539  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1540 
1545  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1546 
1552  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1553 
1560  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1561 
1567  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1568 
1575  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1576 
1577 
1580  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1581 
1584  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1585 
1588  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1589 
1592  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1593 
1596  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1597 
1600  NURBSConversionOptionsKit & UnsetParameterization();
1601 
1604  NURBSConversionOptionsKit & UnsetTolerance();
1605 
1608  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1609 
1612  NURBSConversionOptionsKit & UnsetAllowedCurves();
1613 
1616  NURBSConversionOptionsKit & UnsetEverything();
1617 
1618 
1619 
1623  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1624 
1628  bool Show3DCurvesComputation(bool & out_state) const;
1629 
1634  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1635 
1639  bool ShowClosedFaceSplitting(bool & out_state) const;
1640 
1644  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1645 
1649  bool ShowParameterization(bool & out_state) const;
1650 
1654  bool ShowTolerance(double & out_tolerance) const;
1655 
1659  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1660 
1664  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1665  };
1666 
1668  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1669  {
1670  public:
1672  ImportOptionsKit();
1673 
1676  ImportOptionsKit(ImportOptionsKit const & in_kit);
1677 
1681  ImportOptionsKit(ImportOptionsKit && in_that);
1682 
1686  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1687 
1688  virtual ~ImportOptionsKit();
1689 
1690  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1691  HPS::Type ObjectType() const { return staticType; }
1692 
1696  static ImportOptionsKit GetDefault();
1697 
1700  void Set(ImportOptionsKit const & in_kit);
1701 
1704  void Show(ImportOptionsKit & out_kit) const;
1705 
1709  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1710 
1713  bool Empty() const;
1714 
1718  bool Equals(ImportOptionsKit const & in_kit) const;
1719 
1723  bool operator==(ImportOptionsKit const & in_kit) const;
1724 
1728  bool operator!=(ImportOptionsKit const & in_kit) const;
1729 
1730 
1736  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1737 
1743  ImportOptionsKit & SetSolids(bool in_state);
1744 
1750  ImportOptionsKit & SetSurfaces(bool in_state);
1751 
1757  ImportOptionsKit & SetWireframes(bool in_state);
1758 
1764  ImportOptionsKit & SetPMI(bool in_state);
1765 
1772  ImportOptionsKit & SetAttributes(bool in_state);
1773 
1779  ImportOptionsKit & SetHiddenObjects(bool in_state);
1780 
1786  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1787 
1793  ImportOptionsKit & SetActiveFilter(bool in_state);
1794 
1802  ImportOptionsKit & SetFeatureTrees(bool in_state);
1803 
1809  ImportOptionsKit & SetDrawings(bool in_state);
1810 
1816  ImportOptionsKit & SetDefaultUnits(Units in_units);
1817 
1822  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1823 
1829  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1830 
1837  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1838 
1845  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1846 
1852  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1853 
1859  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1860 
1868  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1869 
1876  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1877 
1885  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1886 
1894  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1895 
1901  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1902 
1908  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1909 
1916  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1917 
1929  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);
1930 
1936  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1937 
1943  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1944 
1950  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1951 
1956  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1957 
1964  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1965 
1971  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1972 
1981  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1982 
1991  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1992 
1998  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1999 
2004  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2005 
2012  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2013 
2018  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2019 
2025  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2026 
2031  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2032 
2038  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2039 
2046  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2047 
2054  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2055 
2063  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2064 
2071  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2072 
2078  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2079 
2085  ImportOptionsKit & SetProECodePageName(char const * in_name);
2086 
2092  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2093 
2099  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2100 
2106  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2107 
2114  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2115 
2122  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2123 
2130  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2131 
2138  ImportOptionsKit & SetProEHomeView(bool in_state);
2139 
2146  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2147 
2154  ImportOptionsKit & SetProEDatum(bool in_state);
2155 
2156 
2163  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2164 
2171  ImportOptionsKit & SetProESkeletons(bool in_state);
2172 
2179  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2180 
2186  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2187 
2193  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2194 
2200  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2201 
2207  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2208 
2214  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2215 
2221  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2222 
2229  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2230 
2236  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2237 
2243  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2244 
2251  ImportOptionsKit & SetIFCEdges(bool in_state);
2252 
2258  ImportOptionsKit & SetIFCMetadata(bool in_state);
2259 
2265  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2266 
2272  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2273 
2279  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2280 
2286  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2287 
2293  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2294 
2301  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2302 
2306  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2307 
2319  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2320 
2332  ImportOptionsKit & SetMode(ImportMode in_mode);
2333 
2343  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2344 
2352  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2353 
2360  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2361 
2365  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2366 
2371  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2372 
2375  ImportOptionsKit & UnsetBRepMode();
2376 
2379  ImportOptionsKit & UnsetSolids();
2380 
2383  ImportOptionsKit & UnsetSurfaces();
2384 
2387  ImportOptionsKit & UnsetWireframes();
2388 
2391  ImportOptionsKit & UnsetPMI();
2392 
2395  ImportOptionsKit & UnsetAttributes();
2396 
2399  ImportOptionsKit & UnsetHiddenObjects();
2400 
2403  ImportOptionsKit & UnsetConstructionAndReferences();
2404 
2407  ImportOptionsKit & UnsetActiveFilter();
2408 
2411  ImportOptionsKit & UnsetDrawings();
2412 
2415  ImportOptionsKit & UnsetFeatureTrees();
2416 
2419  ImportOptionsKit & UnsetSewingTolerance();
2420 
2423  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2424 
2427  ImportOptionsKit & UnsetDefaultUnits();
2428 
2431  ImportOptionsKit & UnsetMultiProcessCount();
2432 
2435  ImportOptionsKit & UnsetPMISubstitutionFont();
2436 
2439  ImportOptionsKit & UnsetPMIPrecision();
2440 
2443  ImportOptionsKit & UnsetPMIDefaultUnits();
2444 
2447  ImportOptionsKit & UnsetPMIDefaultColor();
2448 
2451  ImportOptionsKit & UnsetTessellationLevel();
2452 
2455  ImportOptionsKit & UnsetTessellationAccuracy();
2456 
2459  ImportOptionsKit & UnsetTessellationCleanup();
2460 
2463  ImportOptionsKit & UnsetPMIFlipping();
2464 
2467  ImportOptionsKit & UnsetRemovedViews();
2468 
2471  ImportOptionsKit & UnsetExternalProductOccurrence();
2472 
2475  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2476 
2479  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2480 
2483  ImportOptionsKit & UnsetTextureDirectories();
2484 
2487  ImportOptionsKit & UnsetSearchDirectories();
2488 
2491  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2492 
2495  ImportOptionsKit & UnsetSearchRootDirectory();
2496 
2499  ImportOptionsKit & UnsetConfiguration();
2500 
2503  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2504 
2507  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2508 
2511  ImportOptionsKit & UnsetCatiaV5Cache();
2512 
2515  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2516 
2519  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2520 
2523  ImportOptionsKit & UnsetProECodePageName();
2524 
2527  ImportOptionsKit & UnsetProEDimensionTolerance();
2528 
2531  ImportOptionsKit & UnsetProESubpartPMI();
2532 
2535  ImportOptionsKit & UnsetProESessionColor();
2536 
2539  ImportOptionsKit & UnsetProEDatum();
2540 
2543  ImportOptionsKit & UnsetProEHomeView();
2544 
2547  ImportOptionsKit & UnsetProEExplodedViews();
2548 
2551  ImportOptionsKit & UnsetProEMissingBoolean();
2552 
2555  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2556 
2559  ImportOptionsKit & UnsetProEFamilyTreeSource();
2560 
2563  ImportOptionsKit & UnsetProEConstructionEntities();
2564 
2567  ImportOptionsKit & UnsetProESkeletons();
2568 
2571  ImportOptionsKit & UnsetSTEPNamePreference();
2572 
2575  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2576 
2579  ImportOptionsKit & UnsetSTEPCodePageName();
2580 
2583  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2584 
2587  ImportOptionsKit & UnsetSTEPOrientationHealing();
2588 
2591  ImportOptionsKit & UnsetSTEPValidationProperties();
2592 
2595  ImportOptionsKit & UnsetIFCCodePageName();
2596 
2599  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2600 
2603  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2604 
2607  ImportOptionsKit & UnsetIFCFaceOptimization();
2608 
2611  ImportOptionsKit & UnsetIFCEdges();
2612 
2615  ImportOptionsKit & UnsetIFCMetadata();
2616 
2619  ImportOptionsKit & UnsetPDF3DStreamIndex();
2620 
2623  ImportOptionsKit & UnsetJTTessellationLevel();
2624 
2627  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2628 
2631  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2632 
2635  ImportOptionsKit & UnsetPRCReadHelper();
2636 
2639  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2640 
2643  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2644 
2647  ImportOptionsKit & UnsetLocation();
2648 
2651  ImportOptionsKit & UnsetMode();
2652 
2655  ImportOptionsKit & UnsetIncrementalComponentPaths();
2656 
2659  ImportOptionsKit & UnsetNURBSConversion();
2660 
2663  ImportOptionsKit & UnsetGeometryDefaultColor();
2664 
2667  ImportOptionsKit & UnsetEverything();
2668 
2672  bool ShowBRepMode(BRepMode & out_mode) const;
2673 
2677  bool ShowSolids(bool & out_state) const;
2678 
2682  bool ShowSurfaces(bool & out_state) const;
2683 
2687  bool ShowWireframes(bool & out_state) const;
2688 
2692  bool ShowPMI(bool & out_state) const;
2693 
2697  bool ShowAttributes(bool & out_state) const;
2698 
2702  bool ShowHiddenObjects(bool & out_state) const;
2703 
2707  bool ShowConstructionAndReferences(bool & out_state) const;
2708 
2712  bool ShowActiveFilter(bool & out_state) const;
2713 
2717  bool ShowDrawings(bool & out_state) const;
2718 
2722  bool ShowFeatureTrees(bool & out_state) const;
2723 
2727  bool ShowSewingTolerance(double & out_tolerance) const;
2728 
2732  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2733 
2737  bool ShowDefaultUnits(Units & out_units) const;
2738 
2742  bool ShowMultiProcessCount(unsigned int & out_count) const;
2743 
2748  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2749 
2753  bool ShowPMIPrecision(size_t & out_precision) const;
2754 
2758  bool ShowPMIDefaultUnits(Units & out_units) const;
2759 
2764  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2765 
2773  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2774 
2781  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2782 
2786  bool ShowTessellationCleanup(bool & out_cleanup) const;
2787 
2791  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2792 
2796  bool ShowRemovedViews(bool & out_read_removed_views) const;
2797 
2801  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2802 
2806  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2807 
2811  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2812 
2816  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2817 
2823  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2824 
2828  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2829 
2834  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2835 
2839  bool ShowConfiguration(UTF8Array & out_configuration) const;
2840 
2844  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2845 
2849  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2850 
2855  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2856 
2861  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2862 
2866  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2867 
2871  bool ShowProECodePageName(UTF8 & out_name) const;
2872 
2876  bool ShowProEDimensionTolerance(bool & out_state) const;
2877 
2881  bool ShowProESubpartPMI(bool & out_state) const;
2882 
2886  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2887 
2891  bool ShowProEDatum(bool & out_state) const;
2892 
2896  bool ShowProEHomeView(bool & out_state) const;
2897 
2901  bool ShowProEExplodedViews(bool & out_state) const;
2902 
2906  bool ShowProEMissingBoolean(bool & out_state) const;
2907 
2911  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2912 
2916  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2917 
2921  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2922 
2926  bool ShowProESkeletons(bool & out_state) const;
2927 
2931  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2932 
2936  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2937 
2941  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2942 
2946  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2947 
2951  bool ShowSTEPOrientationHealing(bool & out_state) const;
2952 
2956  bool ShowSTEPValidationProperties(bool & out_state) const;
2957 
2961  bool ShowIFCCodePageName(UTF8 & out_name) const;
2962 
2966  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2967 
2971  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2972 
2976  bool ShowIFCFaceOptimization(bool & out_state) const;
2977 
2981  bool ShowIFCEdges(bool & out_state) const;
2982 
2986  bool ShowIFCMetadata(bool & out_state) const;
2987 
2991  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2992 
2996  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2997 
3001  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3002 
3006  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3007 
3011  bool ShowPRCReadHelper(bool & out_use_helper) const;
3012 
3016  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3017 
3021  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3022 
3027  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3028 
3032  bool ShowMode(ImportMode & out_mode) const;
3033 
3037  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3038 
3042  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3043 
3047  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3048  };
3049 
3051  class EXCHANGE_API Translation
3052  {
3053  public:
3056  enum class Healing
3057  {
3058  Off,
3059  On,
3060  OnlyIfNotParasolid,
3061  };
3062 
3065  enum class AccurateEdges
3066  {
3067  Off,
3068  On,
3069  OnlyIfNotParasolid,
3070  };
3071 
3074  enum class Simplification
3075  {
3076  Off,
3077  On,
3078  OnlyIfNotParasolid,
3079  };
3080 
3083  enum class Merging
3084  {
3085  Off,
3086  On,
3087  OnlyIfNotParasolid,
3088  };
3089 
3090  private:
3092  Translation();
3093  };
3094 
3096  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3097  {
3098  public:
3101 
3105 
3110 
3114  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3115 
3116  virtual ~TranslationOptionsKit();
3117 
3118  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3119  HPS::Type ObjectType() const { return staticType; }
3120 
3124  static TranslationOptionsKit GetDefault();
3125 
3128  void Set(TranslationOptionsKit const & in_kit);
3129 
3132  void Show(TranslationOptionsKit & out_kit) const;
3133 
3137  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3138 
3141  bool Empty() const;
3142 
3146  bool Equals(TranslationOptionsKit const & in_kit) const;
3147 
3151  bool operator==(TranslationOptionsKit const & in_kit) const;
3152 
3156  bool operator!=(TranslationOptionsKit const & in_kit) const;
3157 
3163  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3164 
3170  TranslationOptionsKit & SetTessellation(bool in_state);
3171 
3177  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3178 
3182  TranslationOptionsKit & SetApplication(char const * in_name);
3183 
3187  TranslationOptionsKit & SetVersion(char const * in_version);
3188 
3194  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3195 
3199  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3200 
3204  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3205 
3209  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3210 
3214  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3215 
3220  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3221 
3225  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3226 
3229  TranslationOptionsKit & UnsetSolidsAsFaces();
3230 
3233  TranslationOptionsKit & UnsetTessellation();
3234 
3237  TranslationOptionsKit & UnsetHiddenObjects();
3238 
3241  TranslationOptionsKit & UnsetApplication();
3242 
3245  TranslationOptionsKit & UnsetVersion();
3246 
3249  TranslationOptionsKit & UnsetHealing();
3250 
3253  TranslationOptionsKit & UnsetAccurateEdges();
3254 
3257  TranslationOptionsKit & UnsetSimplification();
3258 
3261  TranslationOptionsKit & UnsetEntityMerging();
3262 
3265  TranslationOptionsKit & UnsetSewing();
3266 
3269  TranslationOptionsKit & UnsetDisjointFaces();
3270 
3273  TranslationOptionsKit& UnsetExplodeMultiBodies();
3274 
3277  TranslationOptionsKit & UnsetEverything();
3278 
3279 
3283  bool ShowSolidsAsFaces(bool & out_state) const;
3284 
3288  bool ShowTessellation(bool & out_state) const;
3289 
3293  bool ShowHiddenObjects(bool & out_state) const;
3294 
3298  bool ShowApplication(UTF8 & out_name) const;
3299 
3303  bool ShowVersion(UTF8 & out_version) const;
3304 
3308  bool ShowExplodeMultiBodies(bool& out_state) const;
3309 
3313  bool ShowHealing(Translation::Healing & out_healing) const;
3314 
3318  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3319 
3323  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3324 
3328  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3329 
3334  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3335 
3339  bool ShowDisjointFaces(bool & out_state) const;
3340 
3345  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3346 
3349  TranslationOptionsKit & UnsetMultiProcessCount();
3350 
3354  bool ShowMultiProcessCount(unsigned int & out_count) const;
3355  };
3356 
3357 
3358 
3363  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3364  {
3365  public:
3368 
3372 
3377 
3381  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3382 
3383  virtual ~ModelFileImportOptionsKit();
3384 
3385  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3386  HPS::Type ObjectType() const { return staticType; }
3387 
3391  static ModelFileImportOptionsKit GetDefault();
3392 
3395  void Set(ModelFileImportOptionsKit const & in_kit);
3396 
3399  void Show(ModelFileImportOptionsKit & out_kit) const;
3400 
3404  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3405 
3408  bool Empty() const;
3409 
3413  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3414 
3418  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3419 
3423  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3424 
3425 
3426  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3427  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3428  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3429  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3430  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3431  * \return A reference to this ImportOptionsKit.
3432  */
3433  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3434 
3440  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3441 
3448  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3449 
3461  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);
3462 
3463  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3464  * \warning Setting this option to true will cause future exports to output without tessellation data.
3465  * \param in_cleanup Whether to clean up tessellation data from representation items.
3466  * \return A reference to this ImportOptionsKit.
3467  */
3468  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3469 
3475  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3476 
3482  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3483 
3490  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3491 
3495  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3496 
3509  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3510 
3516  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3517 
3524  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3525 
3529  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3530 
3535  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3536 
3537 
3540  ModelFileImportOptionsKit & UnsetTessellationLevel();
3541 
3544  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3545 
3548  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3549 
3552  ModelFileImportOptionsKit & UnsetPMIFlipping();
3553 
3556  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3557 
3560  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3561 
3564  ModelFileImportOptionsKit & UnsetIFCEdges();
3565 
3568  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3569 
3572  ModelFileImportOptionsKit & UnsetLocation();
3573 
3576  ModelFileImportOptionsKit & UnsetSewingTolerance();
3577 
3580  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3581 
3584  ModelFileImportOptionsKit & UnsetNURBSConversion();
3585 
3588  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3589 
3592  ModelFileImportOptionsKit & UnsetEverything();
3593 
3594 
3602  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3603 
3610  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3611 
3615  bool ShowTessellationCleanup(bool & out_cleanup) const;
3616 
3620  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3621 
3625  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3626 
3630  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3631 
3635  bool ShowIFCEdges(bool & out_state) const;
3636 
3640  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3641 
3646  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3647 
3651  bool ShowSewingTolerance(double & out_tolerance) const;
3652 
3653 
3657  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3658 
3662  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3663 
3667  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3668  };
3669 
3670 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3671 
3672  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3673  {
3674  public:
3677 
3680  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3681 
3685 
3686  virtual ~Export3MFOptionsKit();
3687 
3688  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3689  HPS::Type ObjectType() const { return staticType; }
3690 
3694  static Export3MFOptionsKit GetDefault();
3695 
3698  void Set(Export3MFOptionsKit const & in_kit);
3699 
3702  void Show(Export3MFOptionsKit& out_kit) const;
3703 
3707  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3708 
3712  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3713 
3716  bool Empty() const;
3717 
3721  bool Equals(Export3MFOptionsKit const & in_kit) const;
3722 
3726  bool operator==(Export3MFOptionsKit const & in_kit) const;
3727 
3731  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3732 
3737  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3738 
3744  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3745 
3748  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3749 
3753  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3754 
3759  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3760 
3763  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3764 
3769  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3770 
3774  Export3MFOptionsKit & SetDescription(char const * in_description);
3775 
3778  Export3MFOptionsKit & UnsetDescription();
3779 
3783  bool ShowDescription(HPS::UTF8 & out_state) const;
3784 
3788  Export3MFOptionsKit & SetCopyright(char const * in_state);
3789 
3792  Export3MFOptionsKit & UnsetCopyright();
3793 
3797  bool ShowCopyright(HPS::UTF8 & out_state) const;
3798 
3802  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3803 
3806  Export3MFOptionsKit & UnsetLicenseTerms();
3807 
3811  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3812 
3815  Export3MFOptionsKit & UnsetEverything();
3816  };
3817 
3819  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
3820  {
3821  public:
3824 
3828 
3832 
3833  virtual ~ExportACISOptionsKit();
3834 
3835  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
3836  HPS::Type ObjectType() const { return staticType; }
3837 
3841  static ExportACISOptionsKit GetDefault();
3842 
3845  void Set(ExportACISOptionsKit const & in_kit);
3846 
3849  void Show(ExportACISOptionsKit & out_kit) const;
3850 
3854  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
3855 
3859  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
3860 
3863  bool Empty() const;
3864 
3868  bool Equals(ExportACISOptionsKit const & in_kit) const;
3869 
3873  bool operator==(ExportACISOptionsKit const & in_kit) const;
3874 
3878  bool operator!=(ExportACISOptionsKit const & in_kit) const;
3879 
3880 
3886  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
3887 
3893  ExportACISOptionsKit & SetBinary(bool in_state);
3894 
3895 
3898  ExportACISOptionsKit & UnsetMillimeterUnits();
3899 
3902  ExportACISOptionsKit & UnsetBinary();
3903 
3906  ExportACISOptionsKit & UnsetEverything();
3907 
3908 
3912  bool ShowMillimeterUnits(bool & out_state) const;
3913 
3917  bool ShowBinary(bool & out_state) const;
3918  };
3919 
3921  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
3922  {
3923  public:
3926 
3929  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3930 
3934 
3935  virtual ~ExportJTOptionsKit();
3936 
3937  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
3938  HPS::Type ObjectType() const { return staticType; }
3939 
3943  static ExportJTOptionsKit GetDefault();
3944 
3947  void Set(ExportJTOptionsKit const & in_kit);
3948 
3951  void Show(ExportJTOptionsKit & out_kit) const;
3952 
3956  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3957 
3961  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3962 
3965  bool Empty() const;
3966 
3970  bool Equals(ExportJTOptionsKit const & in_kit) const;
3971 
3975  bool operator==(ExportJTOptionsKit const & in_kit) const;
3976 
3980  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3981 
3982 
3988  ExportJTOptionsKit & SetContent(JT::Content in_content);
3989 
3995  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3996 
4002  ExportJTOptionsKit & SetPMI(bool in_state);
4003 
4009  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4010 
4011 
4014  ExportJTOptionsKit & UnsetContent();
4015 
4018  ExportJTOptionsKit & UnsetHiddenObjects();
4019 
4022  ExportJTOptionsKit & UnsetPMI();
4023 
4026  ExportJTOptionsKit & UnsetVersion();
4027 
4030  ExportJTOptionsKit & UnsetEverything();
4031 
4032 
4036  bool ShowContent(JT::Content & out_content) const;
4037 
4041  bool ShowHiddenObjects(bool & out_state) const;
4042 
4046  bool ShowPMI(bool & out_state) const;
4047 
4051  bool ShowVersion(JT::Version & out_version) const;
4052  };
4053 
4055  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4056  {
4057  public:
4060 
4063  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4064 
4068 
4069  virtual ~ExportPRCOptionsKit();
4070 
4071  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4072  HPS::Type ObjectType() const { return staticType; }
4073 
4077  static ExportPRCOptionsKit GetDefault();
4078 
4081  void Set(ExportPRCOptionsKit const & in_kit);
4082 
4085  void Show(ExportPRCOptionsKit & out_kit) const;
4086 
4090  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4091 
4095  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4096 
4099  bool Empty() const;
4100 
4104  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4105 
4109  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4110 
4114  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4115 
4116 
4122  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4123 
4130  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4131 
4137  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4138 
4144  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4145 
4150  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4151 
4157  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4158 
4159 
4162  ExportPRCOptionsKit & UnsetTessellationCompression();
4163 
4166  ExportPRCOptionsKit & UnsetBRepCompression();
4167 
4170  ExportPRCOptionsKit & UnsetBRepRemoval();
4171 
4174  ExportPRCOptionsKit & UnsetAttributeRemoval();
4175 
4178  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4179 
4182  ExportPRCOptionsKit & UnsetEverything();
4183 
4184 
4188  bool ShowTessellationCompression(bool & out_state) const;
4189 
4193  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4194 
4198  bool ShowBRepRemoval(bool & out_state) const;
4199 
4203  bool ShowAttributeRemoval(bool & out_state) const;
4204 
4208  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4209  };
4210 
4212  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4213  {
4214  public:
4217 
4220  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4221 
4225 
4226  virtual ~ExportSTLOptionsKit();
4227 
4228  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4229  HPS::Type ObjectType() const { return staticType; }
4230 
4234  static ExportSTLOptionsKit GetDefault();
4235 
4238  void Set(ExportSTLOptionsKit const & in_kit);
4239 
4242  void Show(ExportSTLOptionsKit & out_kit) const;
4243 
4247  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4248 
4252  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4253 
4256  bool Empty() const;
4257 
4261  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4262 
4266  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4267 
4271  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4272 
4273 
4279  ExportSTLOptionsKit & SetBinary(bool in_state);
4280 
4286  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4287 
4294  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4295 
4301  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4302 
4308  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4309 
4316  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4317 
4327  ExportSTLOptionsKit & SetUnits(Units in_units);
4328 
4329 
4332  ExportSTLOptionsKit & UnsetBinary();
4333 
4336  ExportSTLOptionsKit & UnsetTessellationLevel();
4337 
4340  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4341 
4344  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4345 
4348  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4349 
4352  ExportSTLOptionsKit & UnsetUnits();
4353 
4356  ExportSTLOptionsKit & UnsetEverything();
4357 
4358 
4362  bool ShowBinary(bool & out_state) const;
4363 
4371  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4372 
4376  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4377 
4381  bool ShowCurrentTessellationRetention(bool & out_state) const;
4382 
4386  bool ShowMaximumEdgeLength(double & out_length) const;
4387 
4391  bool ShowUnits(Units & out_units) const;
4392  };
4393 
4395  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4396  {
4397  public:
4400 
4403  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4404 
4408 
4409  virtual ~ExportU3DOptionsKit();
4410 
4411  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4412  HPS::Type ObjectType() const { return staticType; }
4413 
4417  static ExportU3DOptionsKit GetDefault();
4418 
4421  void Set(ExportU3DOptionsKit const & in_kit);
4422 
4425  void Show(ExportU3DOptionsKit & out_kit) const;
4426 
4430  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4431 
4435  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4436 
4439  bool Empty() const;
4440 
4444  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4445 
4449  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4450 
4454  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4455 
4456 
4462  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4463 
4468  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4469 
4470 
4473  ExportU3DOptionsKit & UnsetVersion();
4474 
4477  ExportU3DOptionsKit & UnsetCompression();
4478 
4481  ExportU3DOptionsKit & UnsetEverything();
4482 
4483 
4487  bool ShowVersion(U3D::Version & out_version) const;
4488 
4492  bool ShowCompression(unsigned char & out_level) const;
4493  };
4494 
4496  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4497  {
4498  public:
4501 
4504  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4505 
4509 
4510  virtual ~ExportXMLOptionsKit();
4511 
4512  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4513  HPS::Type ObjectType() const { return staticType; }
4514 
4518  static ExportXMLOptionsKit GetDefault();
4519 
4522  void Set(ExportXMLOptionsKit const & in_kit);
4523 
4526  void Show(ExportXMLOptionsKit & out_kit) const;
4527 
4531  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4532 
4536  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4537 
4540  bool Empty() const;
4541 
4545  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4546 
4550  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4551 
4555  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4556 
4557 
4563  ExportXMLOptionsKit & SetMetadata(bool in_state);
4564 
4570  ExportXMLOptionsKit & SetTransformations(bool in_state);
4571 
4577  ExportXMLOptionsKit & SetMaterials(bool in_state);
4578 
4579 
4582  ExportXMLOptionsKit & UnsetMetadata();
4583 
4586  ExportXMLOptionsKit & UnsetTransformations();
4587 
4590  ExportXMLOptionsKit & UnsetMaterials();
4591 
4594  ExportXMLOptionsKit & UnsetEverything();
4595 
4596 
4600  bool ShowMetadata(bool & out_state) const;
4601 
4605  bool ShowTransformations(bool & out_state) const;
4606 
4610  bool ShowMaterials(bool & out_state) const;
4611  };
4612 #endif
4613 
4614 #if !defined(TARGET_OS_ANDROID)
4615 
4616  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4617  {
4618  public:
4621 
4625 
4629 
4630  virtual ~ExportIGESOptionsKit();
4631 
4632  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4633  HPS::Type ObjectType() const { return staticType; }
4634 
4638  static ExportIGESOptionsKit GetDefault();
4639 
4642  void Set(ExportIGESOptionsKit const & in_kit);
4643 
4646  void Show(ExportIGESOptionsKit & out_kit) const;
4647 
4651  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4652 
4656  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4657 
4660  bool Empty() const;
4661 
4665  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4666 
4670  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4671 
4675  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4676 
4677 
4683  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4684 
4690  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4691 
4697  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
4698 
4704  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
4705 
4711  ExportIGESOptionsKit & SetTessellation(bool in_state);
4712 
4716  ExportIGESOptionsKit & SetApplication(char const * in_name);
4717 
4721  ExportIGESOptionsKit & SetVersion(char const * in_version);
4722 
4723 
4726  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
4727 
4730  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
4731 
4734  ExportIGESOptionsKit & UnsetSolidsAsFaces();
4735 
4738  ExportIGESOptionsKit & UnsetHiddenObjects();
4739 
4742  ExportIGESOptionsKit & UnsetTessellation();
4743 
4746  ExportIGESOptionsKit & UnsetApplication();
4747 
4750  ExportIGESOptionsKit & UnsetVersion();
4751 
4754  ExportIGESOptionsKit & UnsetEverything();
4755 
4756 
4760  bool ShowAnalyticsAsNURBS(bool & out_state) const;
4761 
4765  bool ShowFacetedAsWireframe(bool & out_state) const;
4766 
4770  bool ShowSolidsAsFaces(bool & out_state) const;
4771 
4775  bool ShowHiddenObjects(bool & out_state) const;
4776 
4780  bool ShowTessellation(bool & out_state) const;
4781 
4785  bool ShowApplication(UTF8 & out_name) const;
4786 
4790  bool ShowVersion(UTF8 & out_version) const;
4791  };
4792 
4794  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
4795  {
4796  public:
4799 
4803 
4807 
4808  virtual ~ExportParasolidOptionsKit();
4809 
4810  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
4811  HPS::Type ObjectType() const { return staticType; }
4812 
4816  static ExportParasolidOptionsKit GetDefault();
4817 
4820  void Set(ExportParasolidOptionsKit const & in_kit);
4821 
4824  void Show(ExportParasolidOptionsKit & out_kit) const;
4825 
4829  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
4830 
4834  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
4835 
4838  bool Empty() const;
4839 
4843  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
4844 
4848  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
4849 
4853  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
4854 
4855 
4861  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
4862 
4868  ExportParasolidOptionsKit & SetTessellation(bool in_state);
4869 
4875  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
4876 
4880  ExportParasolidOptionsKit & SetApplication(char const * in_name);
4881 
4885  ExportParasolidOptionsKit & SetVersion(char const * in_version);
4886 
4892  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
4893 
4896  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
4897 
4900  ExportParasolidOptionsKit & UnsetTessellation();
4901 
4904  ExportParasolidOptionsKit & UnsetHiddenObjects();
4905 
4908  ExportParasolidOptionsKit & UnsetApplication();
4909 
4912  ExportParasolidOptionsKit & UnsetVersion();
4913 
4916  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
4917 
4920  ExportParasolidOptionsKit & UnsetEverything();
4921 
4922 
4926  bool ShowSolidsAsFaces(bool & out_state) const;
4927 
4931  bool ShowTessellation(bool & out_state) const;
4932 
4936  bool ShowHiddenObjects(bool & out_state) const;
4937 
4941  bool ShowApplication(UTF8 & out_name) const;
4942 
4946  bool ShowVersion(UTF8 & out_version) const;
4947 
4951  bool ShowExplodeMultiBodies(bool& out_state) const;
4952  };
4953 
4955  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
4956  {
4957  public:
4960 
4964 
4968 
4969  virtual ~ExportSTEPOptionsKit();
4970 
4971  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
4972  HPS::Type ObjectType() const { return staticType; }
4973 
4977  static ExportSTEPOptionsKit GetDefault();
4978 
4981  void Set(ExportSTEPOptionsKit const & in_kit);
4982 
4985  void Show(ExportSTEPOptionsKit & out_kit) const;
4986 
4990  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
4991 
4995  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
4996 
4999  bool Empty() const;
5000 
5004  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5005 
5009  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5010 
5014  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5015 
5016 
5022  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5023 
5029  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5030 
5036  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5037 
5043  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5044 
5048  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5049 
5053  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5054 
5058  ExportSTEPOptionsKit & SetPMI(bool in_state);
5059 
5063  ExportSTEPOptionsKit & SetCurves(bool in_state);
5064 
5068  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5069 
5073  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5074 
5078  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5079 
5082  ExportSTEPOptionsKit & UnsetFormat();
5083 
5086  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5087 
5090  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5091 
5094  ExportSTEPOptionsKit & UnsetNameShortening();
5095 
5098  ExportSTEPOptionsKit & UnsetApplication();
5099 
5102  ExportSTEPOptionsKit & UnsetVersion();
5103 
5106  ExportSTEPOptionsKit & UnsetPMI();
5107 
5110  ExportSTEPOptionsKit & UnsetCurves();
5111 
5114  ExportSTEPOptionsKit & UnsetAttributes();
5115 
5118  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5119 
5122  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5123 
5126  ExportSTEPOptionsKit & UnsetEverything();
5127 
5128 
5132  bool ShowFormat(STEP::Format & out_format) const;
5133 
5137  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5138 
5142  bool ShowFacetedAsWireframe(bool & out_state) const;
5143 
5147  bool ShowNameShortening(bool & out_state) const;
5148 
5152  bool ShowApplication(UTF8 & out_name) const;
5153 
5157  bool ShowVersion(UTF8 & out_version) const;
5158 
5162  bool ShowPMI(bool & out_state) const;
5163 
5167  bool ShowCurves(bool & out_state) const;
5168 
5172  bool ShowAttributes(bool & out_state) const;
5173 
5177  bool ShowPMIWithSemantic(bool & out_state) const;
5178 
5182  bool ShowPMIAsTessellated(bool & out_state) const;
5183  };
5184 #endif
5185 
5187  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5188  {
5189  public:
5192 
5196 
5200 
5201  virtual ~TessellationOptionsKit();
5202 
5203  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5204  HPS::Type ObjectType() const { return staticType; }
5205 
5209  static TessellationOptionsKit GetDefault();
5210 
5213  void Set(TessellationOptionsKit const & in_kit);
5214 
5217  void Show(TessellationOptionsKit & out_kit) const;
5218 
5222  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5223 
5227  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5228 
5231  bool Empty() const;
5232 
5236  bool Equals(TessellationOptionsKit const & in_kit) const;
5237 
5241  bool operator==(TessellationOptionsKit const & in_kit) const;
5242 
5246  bool operator!=(TessellationOptionsKit const & in_kit) const;
5247 
5248 
5252  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5253 
5260  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5261 
5271  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);
5272 
5276  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5277 
5281  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5282 
5283 
5286  TessellationOptionsKit & UnsetLevel();
5287 
5290  TessellationOptionsKit & UnsetAccuracy();
5291 
5294  TessellationOptionsKit & UnsetUVPointPreservation();
5295 
5298  TessellationOptionsKit & UnsetMaximumEdgeLength();
5299 
5302  TessellationOptionsKit & UnsetEverything();
5303 
5304 
5312  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5313 
5320  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5321 
5325  bool ShowUVPointPreservation(bool & out_state) const;
5326 
5330  bool ShowMaximumEdgeLength(double & out_length) const;
5331  };
5332 
5338  class EXCHANGE_API CommonMeasurementOperator : public Operator
5339  {
5340  public:
5341  enum class Tags
5342  {
5343  Name = 0,
5344  MeasurementType,
5345  Radius,
5346  Inverted,
5347  VectorX,
5348  VectorY,
5349  VectorZ,
5350  };
5351 
5353 
5354  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5355 
5357  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5358 
5359  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5360  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5361 
5362  Exchange::CADModel GetCADModel() const;
5363  void SetCADModel(Exchange::CADModel const & in_cad_model);
5364 
5366  size_t GetPrecision() const;
5367 
5370  void SetPrecision(size_t in_precision);
5371 
5373  MaterialMappingKit GetMaterial() const;
5374 
5377  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5378 
5380  TextAttributeKit GetTextAttributes() const;
5381 
5384  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5385 
5387  SegmentKey GetMeasurementSegment() const;
5388 
5390  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5391 
5392  /* Deletes all measurements */
5393  void DeleteMeasurements();
5394 
5395  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5396  {
5397  public:
5400  {
5401  channel = GetClassID();
5402  consumable = false;
5403  }
5404 
5405  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5406  {
5407  channel = GetClassID();
5408  consumable = false;
5409  measurement_key = in_measurement_key;
5410  view = in_view;
5411  }
5412 
5415  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5416  {
5417  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5418  {
5419  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5420  measurement_key = that.measurement_key;
5421  view = that.view;
5422  }
5423  else
5424  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5425  }
5426 
5428 
5431  Event * Clone() const
5432  {
5433  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5434  return new_event;
5435  }
5436 
5437  Key measurement_key;
5438  View view;
5439  };
5440 
5441  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5442  {
5443  public:
5446  {
5447  channel = GetClassID();
5448  consumable = false;
5449  }
5450 
5451  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5452  {
5453  channel = GetClassID();
5454  consumable = false;
5455  measurement_name = in_measurement_name;
5456  view = in_view;
5457  }
5458 
5461  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5462  {
5463  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5464  {
5465  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5466  measurement_name = that.measurement_name;
5467  view = that.view;
5468  }
5469  else
5470  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5471  }
5472 
5474 
5477  Event * Clone() const
5478  {
5479  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5480  return new_event;
5481  }
5482 
5483  UTF8 measurement_name;
5484  View view;
5485  };
5486 
5487  protected:
5488  Exchange::CADModel cad_model;
5489  size_t measurement_precision;
5490  UTF8 units;
5491  MaterialMappingKit materials;
5492  TextAttributeKit text_attributes;
5493  SegmentKey measurement_segment;
5494  GlyphDefinition left_arrow;
5495  GlyphDefinition right_arrow;
5496  SelectionOptionsKit selection_options;
5497  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5498  Vector camera_direction;
5499  PortfolioKey portfolio;
5500  SegmentKey style_segment;
5501  HighlightOptionsKit highlight_options;
5502 
5503  static size_t length_measurement_index;
5504  static size_t radius_measurement_index;
5505  static size_t distance_measurement_index;
5506  static size_t angle_measurement_index;
5507 
5508  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5509  void GetUnits();
5510  void SetGlyphColor();
5511  void GetCameraDirection();
5512  void SetupConstructionSegment();
5513  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5514  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5515  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5516  float GetModelScale(Exchange::Component const & component);
5517  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5518  };
5519 
5573  {
5574  public:
5575  enum class MeasurementType
5576  {
5577  PointToPoint,
5578  EdgeAndRadius,
5579  FeatureToFeature,
5580  FaceAngle,
5581  };
5582 
5584 
5585  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5586 
5588  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5589 
5590  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5591  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5592 
5597  virtual bool OnMouseDown(MouseState const & in_state) override;
5598 
5602  virtual bool OnMouseUp(MouseState const & in_state) override;
5603 
5609  virtual bool OnMouseMove(MouseState const & in_state) override;
5610 
5615  virtual bool OnTouchDown(TouchState const & in_state) override;
5616 
5620  virtual bool OnTouchUp(TouchState const & in_state) override;
5621 
5627  virtual bool OnTouchMove(TouchState const & in_state) override;
5628 
5632  virtual bool OnKeyDown(KeyboardState const & in_state) override;
5633 
5636  void SetMeasurementType(MeasurementType in_measurement_type);
5637 
5640  MeasurementType GetMeasurementType();
5641 
5644  void SetMouseOverHighlighting(bool in_highlighting);
5645 
5649  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
5650 
5653  bool GetMouseOverHighlighting();
5654 
5657  HighlightOptionsKit GetHighlightOptions();
5658 
5661  bool IsMeasurementActive();
5662 
5664  void DeleteLastMeasurement();
5665 
5666  private:
5667  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
5668  {
5669  Circle,
5670  Line,
5671  Generic,
5672  };
5673 
5674  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
5675  {
5676  public:
5677  Surface();
5678 
5679  enum class SurfaceType
5680  {
5681  Plane,
5682  ConeOrCylinder,
5683  Unsupported,
5684  };
5685 
5686  SurfaceType surface_type; //the type of surface being measured
5687  Point center; //the center point of the surface
5688  Vector normal; //the center line of surfaces of type Cylinder or Cone
5689  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
5690  ComponentPath path; //the ComponentPath to this surface
5691  };
5692 
5693  //bookkeeping
5694  MeasurementType measurement_type; //the type of measurement to be inserted
5695  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
5696  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
5697  TouchID current_touch_id; //the ID of the touch being processed
5698  SegmentKey current_measurement; //segment of the measurement being inserted / edited
5699  bool operator_active; //whether a measurement is in progress
5700  bool end_measurement; //whether we should end the current measurement
5701  CanvasArray canvases; //canvases related to the view where this operator is attached
5702 
5703  //measurement anchors
5704  size_t anchors; //valid for point-to-point and face-angle measurements
5705  bool anchors_in_place; //true if all the anchors have been placed
5706  Point first_click_position; //position of the first anchor
5707  Point second_click_position; //position of the second anchor
5708 
5709  //geometry for linear measurements
5710  MarkerKey anchor_one; //marker corresponding to the start of the measurement
5711  MarkerKey anchor_two; //marker corresponding to the end of the measurement
5712  LineKey distance_line; //a line representing the distance measured
5713  LineKey leader_line_one; //line connecting the first anchor point to the distance line
5714  LineKey leader_line_two; //line connecting the second anchor point to the distance line
5715  Point distance_point_one; //intersection of leader_line_one and distance_line
5716  Point distance_point_two; //intersection of leader_line_two and distance_line
5717  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
5718  TextKey text; //text representing the measurement and units
5719  UTF8 text_string; //the contents of the text
5720  Vector measurement_direction; //the direction of the measurement
5721  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
5722  Vector explicit_direction; //used if use_explicit_direction is true
5723 
5724  //geometry for radius measurement
5725  MarkerKey center_marker; //marker representing the center of the circle
5726  Point circle_center; //circle center
5727  float radius; //circle radius
5728 
5729  //edge specific data
5730  LineKey edge_line; //the edge being measured
5731  double edge_length; //length of the measured edge
5732  EdgeType edge_type; //the type of edge being measured
5733 
5734  //feature-to-feature specific data
5735  Surface surface_one; //data related to first selected surface
5736  Surface surface_two; //data related to second selected surface
5737  Plane measurement_plane; //the measurement plane
5738  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
5739 
5740  //angle specific data
5741  Vector leader_line_one_direction; //the direction of the first leader line
5742  Vector leader_line_two_direction; //the direction of the second leader line
5743  Vector first_face_normal; //the normal of the first selected face
5744  Vector second_face_normal; //the normal of the second selected face
5745  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'
5746  CircularArcKey measurement_arc; //an arc representing the measured angle
5747  LineKey line_to_leader_line; //line extending from one anchor to a leader line
5748  Vector mid_point_direction;
5749 
5750  //selection kits
5751  SelectionOptionsKit point_to_point_selection;
5752  SelectionOptionsKit edge_radius_selection;
5753  SelectionOptionsKit feature_to_feature_selection;
5754  SelectionOptionsKit angle_selection;
5755 
5756  //highlighting
5757  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
5758  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
5759  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
5760  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
5761  KeyPath highlighted_path; //highlighted_path
5762  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
5763  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
5764 
5765  //input handling
5766  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
5767  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
5768  bool InputUp(WindowKey & in_window);
5769  void ResetMeasurement();
5770 
5771  //inserting measurements
5772  void InsertPointToPointMeasurement(Point const & in_world_point);
5773  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
5774  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
5775  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
5776  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
5777  void InvertMeasuredAngle(WindowKey & in_window);
5778  void AdjustLineToCursor(Point const & cursor_position);
5779 
5780  //saving measurements
5781  void TagMeasurement();
5782  void TagPointToPointMeasurement();
5783  void TagEdgeMeasurement();
5784  void TagRadiusMeasurement();
5785  void TagGenericEdgeMeasurement();
5786  void TagFeatureToFeatureMeasurement();
5787  void TagAngleMeasurement();
5788 
5789  //restoring measurements
5790  void RestoreMeasurement(SegmentKey const & measurement_segment);
5791  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
5792  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
5793  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
5794  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
5795  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
5796  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
5797  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
5798 
5799  //topology functions
5800  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
5801  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
5802  void PlaneToCenterLineDistance();
5803  void PlaneToPlaneDistance();
5804  void LineToLineDistance();
5805  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);
5806  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
5807  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
5808  bool IsPlane(Exchange::Component const & face_component);
5809  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
5810  };
5811 
5812 private:
5814  Exchange();
5815 };
5816 
5817 }
5818 
5819 #endif
Definition: hps.h:6254
Definition: sprk_exchange.h:4055
Level
Definition: sprk_exchange.h:911
ConstructionEntities
Definition: sprk_exchange.h:1073
Definition: sprk_exchange.h:44
Definition: sprk_exchange.h:1024
Definition: sprk.h:273
Definition: sprk_exchange.h:1190
Definition: sprk_exchange.h:5338
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5865
Units
Definition: sprk_exchange.h:65
Definition: sprk.h:67
Simplification
Definition: sprk_exchange.h:3074
Definition: sprk.h:106
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5357
Definition: sprk_exchange.h:653
Version
Definition: sprk_exchange.h:1094
Definition: sprk_exchange.h:3363
Definition: sprk_exchange.h:921
Definition: sprk_exchange.h:754
SurfaceType
Definition: sprk_exchange.h:843
Definition: hps.h:1740
Format
Definition: sprk_exchange.h:1011
Definition: sprk_exchange.h:4496
Definition: sprk.h:242
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6720
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6696
Definition: hps.h:48680
Format
Definition: sprk_exchange.h:1195
Definition: hps.h:7760
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6690
Type
Definition: sprk_exchange.h:902
Definition: hps.h:16407
Definition: sprk_exchange.h:501
Definition: sprk_exchange.h:592
Definition: sprk_exchange.h:334
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5415
Definition: sprk_exchange.h:1443
Definition: sprk_exchange.h:274
Definition: sprk_exchange.h:3921
Merging
Definition: sprk_exchange.h:3083
Field
Definition: sprk_exchange.h:1001
Definition: hps.h:48578
Definition: hps.h:41966
Definition: sprk_exchange.h:3819
Definition: sprk_exchange.h:3096
Limit
Definition: sprk_exchange.h:926
Definition: hps.h:4539
TessellationLevel
Definition: sprk_exchange.h:975
Definition: sprk_exchange.h:897
Definition: sprk_exchange.h:4212
Definition: sprk_exchange.h:113
Definition: sprk_exchange.h:996
Definition: hps.h:4478
Definition: hps.h:7131
Definition: hps.h:48049
Definition: sprk_exchange.h:455
UnloadMode
Definition: sprk_exchange.h:82
Definition: hps.h:43974
Definition: hps.h:48465
Definition: sprk_dwg.h:43
AnnotationCaptureFitting
Definition: sprk_exchange.h:890
Definition: sprk_exchange.h:4395
Definition: sprk_exchange.h:961
Definition: hps.h:15794
Event * Clone() const
Definition: sprk_exchange.h:5477
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6676
intptr_t GetChannel() const
Definition: hps.h:6371
Definition: sprk_exchange.h:1089
SessionColor
Definition: sprk_exchange.h:1048
Definition: sprk.h:1778
Definition: hps.h:48787
LoadStatus
Definition: sprk_exchange.h:97
Definition: hps.h:45173
Definition: hps.h:47556
CurveType
Definition: sprk_exchange.h:866
Definition: sprk_exchange.h:546
Definition: hps.h:6338
Definition: hps.h:14044
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6688
Definition: sprk_exchange.h:5572
Definition: sprk.h:487
BRepCompression
Definition: sprk_exchange.h:1029
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:816
Definition: sprk.h:2161
ComponentType
Definition: sprk.h:1794
Accuracy
Definition: sprk_exchange.h:943
Definition: sprk_exchange.h:3672
Definition: sprk_exchange.h:4616
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5461
Definition: sprk.h:2660
FamilyTable
Definition: sprk_exchange.h:1061
Content
Definition: sprk_exchange.h:966
Definition: sprk_exchange.h:1668
Definition: sprk.h:2760
static MouseButtons ButtonLeft()
Definition: hps.h:48167
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5588
Definition: hps.h:7678
Definition: sprk_exchange.h:1043
AccurateEdges
Definition: sprk_exchange.h:3065
Event * Clone() const
Definition: sprk_exchange.h:5431
Definition: hps.h:9391
Definition: sprk_exchange.h:707
Definition: hps.h:24594
Healing
Definition: sprk_exchange.h:3056
Definition: sprk.h:2847
Definition: hps.h:31027
ImportMode
Definition: sprk_exchange.h:831
Definition: sprk_exchange.h:1106
Definition: hps.h:513
Definition: sprk.h:1110
Definition: sprk_exchange.h:3051
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:4794
Definition: sprk_exchange.h:203
Definition: hps.h:41462
Version
Definition: sprk_exchange.h:984
Definition: sprk_exchange.h:5187
Definition: hps.h:42597
Definition: sprk_exchange.h:4955