Overview

Sample Code

Programming Guide

API Reference

Support

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 
18 #ifdef _MSC_VER
19 #ifndef STATIC_APP
20 # ifdef SPRK_EXCHANGE
21 # define EXCHANGE_API __declspec (dllexport)
22 # else
23 # define EXCHANGE_API __declspec (dllimport)
24 # endif
25 #endif
26 #else
27 # include <stddef.h>
28 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
29 # ifndef STATIC_APP
30 # define EXCHANGE_API __attribute__ ((visibility ("default")))
31 # endif
32 # endif
33 #endif
34 
35 #ifndef EXCHANGE_API
36 # define EXCHANGE_API
37 #endif
38 
39 namespace HPS
40 {
41 
43 class EXCHANGE_API Exchange
44 {
45 public:
46 
47  class Component;
48  class Configuration;
49  class Sheet;
51  class TranslationNotifier;
54  class ReloadNotifier;
55 
56  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
57  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
58  typedef HPS::IntArray ParasolidEntityArray;
59 
62  enum class Units
63  {
64  Unknown,
65  Point,
66  Inch,
67  Millimeter,
68  Centimeter,
69  Pica,
70  Foot,
71  Yard,
72  Meter,
73  Kilometer,
74  Mile
75  };
76 
79  enum class UnloadMode
80  {
83  ExchangeAndVisualization,
84 
89  ExchangeOnly,
90  };
91 
94  enum class LoadStatus
95  {
97  Unknown,
99  Loaded,
101  VisualizationOnly,
103  PartiallyLoaded,
105  NotLoaded
106  };
107 
110  class EXCHANGE_API Component : public HPS::Component
111  {
112  public:
114  Component();
115 
119  Component(HPS::Component const & in_that);
120 
123  Component(Exchange::Component const & in_that);
124 
127  Component(Exchange::Component && in_that);
128 
129  virtual ~Component();
130 
131  HPS::Type ObjectType() const { return HPS::Type::ExchangeComponent; }
132 
133 #if !defined(_MSC_VER) || _MSC_VER >= 1900
134  Component & operator=(Component const & in_that) = default;
135 #endif
136 
140  Component & operator=(Exchange::Component && in_that);
141 
142 
145  A3DEntity * GetExchangeEntity() const;
146 
147 
153  void Tessellate(TessellationOptionsKit const & in_options);
154 
161  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
162 
169  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
170  };
171 
172  class EXCHANGE_API ProductOccurrence : public Exchange::Component
173  {
174  public:
177 
181  ProductOccurrence(HPS::Component const & in_that);
182 
186  ProductOccurrence(Component const & in_that);
187 
190  ProductOccurrence(ProductOccurrence const & in_sheet);
191 
196 
200  ProductOccurrence & operator=(ProductOccurrence && in_that);
201 
202  virtual ~ProductOccurrence();
203 
204  HPS::Type ObjectType() const { return HPS::Type::ExchangeProductOccurrence; }
205 
209  bool Equals(ProductOccurrence const & in_kit) const;
210 
214  bool operator==(ProductOccurrence const & in_kit) const;
215 
219  bool operator!=(ProductOccurrence const & in_kit) const;
220 
226  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
227 
233  LoadStatus GetLoadStatus() const;
234  };
235 
237  class EXCHANGE_API Sheet : public Exchange::Component
238  {
239  public:
241  Sheet();
242 
246  Sheet(HPS::Component const & in_that);
247 
251  Sheet(Component const & in_that);
252 
255  Sheet(Sheet const & in_sheet);
256 
260  Sheet(Sheet && in_that);
261 
265  Sheet & operator=(Sheet && in_that);
266 
267  virtual ~Sheet();
268 
269  HPS::Type ObjectType() const { return HPS::Type::ExchangeSheet; }
270 
274  bool Equals(Sheet const & in_kit) const;
275 
276 #if !defined(_MSC_VER) || _MSC_VER >= 1900
277  Sheet & operator=(Sheet const & in_that) = default;
278 #endif
279 
283  bool operator==(Sheet const & in_kit) const;
284 
288  bool operator!=(Sheet const & in_kit) const;
289 
290  /* Activates this sheet */
291  HPS::View Activate();
292  };
293 
296  class EXCHANGE_API CADModel : public HPS::CADModel
297  {
298  public:
300  CADModel();
301 
305  CADModel(Component const & in_that);
306 
310  CADModel(HPS::CADModel const & in_that);
311 
314  CADModel(Exchange::CADModel const & in_that);
315 
318  CADModel(Exchange::CADModel && in_that);
319 
320  virtual ~CADModel();
321 
322  HPS::Type ObjectType() const { return HPS::Type::ExchangeCADModel; }
323 
324 #if !defined(_MSC_VER) || _MSC_VER >= 1900
325  CADModel & operator=(Exchange::CADModel const & in_that) = default;
326 #endif
327 
331  CADModel & operator=(Exchange::CADModel && in_that);
332 
333 
336  A3DEntity * GetExchangeEntity() const;
337 
343  bool GetEntityOwnership() const;
344 
345 
349  UTF8Array GetCurrentConfiguration() const;
350 
354  ConfigurationArray GetConfigurations() const;
355 
356  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
357  * \return The list of sheets for this CADModel */
358  SheetArray GetSheets() const;
359 
365  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
366 
371  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
372 
378  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
379 
385  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
386  };
387 
390  class EXCHANGE_API Capture : public HPS::Capture
391  {
392  public:
394  Capture();
395 
399  Capture(Component const & in_that);
400 
404  Capture(HPS::Capture const & in_that);
405 
408  Capture(Exchange::Capture const & in_that);
409 
412  Capture(Exchange::Capture && in_that);
413 
414  virtual ~Capture();
415 
416  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
417 
418 #if !defined(_MSC_VER) || _MSC_VER >= 1900
419  Capture & operator=(Exchange::Capture const & in_that) = default;
420 #endif
421 
425  Capture & operator=(Exchange::Capture && in_that);
426 
427 
430  A3DEntity * GetExchangeEntity() const;
431  };
432 
435  class EXCHANGE_API Filter : public HPS::Filter
436  {
437  public:
439  Filter();
440 
444  Filter(Component const & in_that);
445 
449  Filter(HPS::Filter const & in_that);
450 
453  Filter(Exchange::Filter const & in_that);
454 
457  Filter(Exchange::Filter && in_that);
458 
459  virtual ~Filter();
460 
461  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
462 
463 #if !defined(_MSC_VER) || _MSC_VER >= 1900
464  Filter & operator=(Exchange::Filter const & in_that) = default;
465 #endif
466 
470  Filter & operator=(Exchange::Filter && in_that);
471 
472 
475  A3DEntity * GetExchangeEntity() const;
476  };
477 
479  class EXCHANGE_API Factory : public Sprocket
480  {
481  public:
486  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
487 
493  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
494 
498  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
499 
506  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
507 
511  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
512 
513  private:
515  Factory();
516  };
517 
519  class EXCHANGE_API ImportNotifier : public IONotifier
520  {
521  public:
523  ImportNotifier();
524 
527  ImportNotifier(ImportNotifier const & in_that);
528 
533  ImportNotifier(IONotifier const & in_that);
534 
538  ImportNotifier(ImportNotifier && in_that);
539 
543  ImportNotifier & operator=(ImportNotifier && in_that);
544 
545  virtual ~ImportNotifier();
546 
547  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
548 
552  ImportNotifier & operator=(ImportNotifier const & in_that);
553 
556  void Assign(ImportNotifier const & in_that);
557 
560  Exchange::CADModel GetCADModel() const;
561 
564  Time GetImportTime() const;
565 
568  Time GetParseTime() const;
569  };
570 
572  class EXCHANGE_API TranslationNotifier : public IONotifier
573  {
574  public:
577 
580  TranslationNotifier(TranslationNotifier const & in_that);
581 
586  TranslationNotifier(IONotifier const & in_that);
587 
592 
596  TranslationNotifier & operator=(TranslationNotifier && in_that);
597 
598  virtual ~TranslationNotifier();
599 
600  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
601 
605  TranslationNotifier & operator=(TranslationNotifier const & in_that);
606 
609  void Assign(TranslationNotifier const & in_that);
610 
613  Exchange::ParasolidEntityArray GetParasolidParts() const;
614 
617  HPS::Time GetImportTime() const;
618 
621  HPS::Time GetTranslationTime() const;
622  };
623 
625  class EXCHANGE_API ExportNotifier : public IONotifier
626  {
627  public:
629  ExportNotifier();
630 
633  ExportNotifier(ExportNotifier const & in_that);
634 
639  ExportNotifier(IONotifier const & in_that);
640 
644  ExportNotifier(ExportNotifier && in_that);
645 
649  ExportNotifier & operator=(ExportNotifier && in_that);
650 
651  virtual ~ExportNotifier();
652 
653  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
654 
658  ExportNotifier & operator=(ExportNotifier const & in_that);
659 
662  void Assign(ExportNotifier const & in_that);
663 
667  A3DAsmModelFile * GetModelFile() const;
668  };
669 
671  class EXCHANGE_API ReloadNotifier : public IONotifier
672  {
673  public:
675  ReloadNotifier();
676 
679  ReloadNotifier(ReloadNotifier const & in_that);
680 
685  ReloadNotifier(IONotifier const & in_that);
686 
690  ReloadNotifier(ReloadNotifier && in_that);
691 
695  ReloadNotifier & operator=(ReloadNotifier && in_that);
696 
697  virtual ~ReloadNotifier();
698 
699  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
700 
704  ReloadNotifier & operator=(ReloadNotifier const & in_that);
705 
708  void Assign(ReloadNotifier const & in_that);
709  };
710 
711 
712  class ImportOptionsKit;
713  class ModelFileImportOptionsKit;
714  class ExportACISOptionsKit;
715  class ExportIGESOptionsKit;
716  class ExportJTOptionsKit;
717  class ExportPRCOptionsKit;
718  class ExportSTEPOptionsKit;
719  class ExportSTLOptionsKit;
720  class ExportU3DOptionsKit;
721  class ExportXMLOptionsKit;
722 
723 
726  enum class BRepMode
727  {
730  TessellationOnly,
733  BRepOnly,
736  BRepAndTessellation,
737  };
738 
741  enum class ImportMode
742  {
745  Complete,
748  Incremental,
749  };
750 
754  {
755  PMIOnly,
756  ModelAndPMI
757  };
758 
760  class EXCHANGE_API Tessellation
761  {
762  public:
765  enum class Type
766  {
767  Standard,
768  Custom
769  };
770 
771 
774  enum class Level
775  {
776  ExtraLow,
777  Low,
778  Medium,
779  High,
780  ExtraHigh,
781  };
782 
784  class EXCHANGE_API Chord
785  {
786  public:
789  enum class Limit
790  {
793  Ratio,
796  Height
797  };
798 
799  private:
801  Chord();
802  };
803 
806  enum class Accuracy
807  {
810  Standard,
813  Accurate
814  };
815 
816  private:
818  Tessellation();
819  };
820 
822  class EXCHANGE_API JT
823  {
824  public:
827  enum class Content
828  {
829  Geometry,
830  Tessellation,
831  GeometryAndTessellation
832  };
833 
836  enum class TessellationLevel
837  {
838  Low,
839  Medium,
840  High,
841  };
842 
843  private:
845  JT();
846  };
847 
849  class EXCHANGE_API STEP
850  {
851  public:
854  enum class Field
855  {
856  ProductName,
857  NextAssemblyUsageOccurrenceID,
858  NextAssemblyUsageOccurrenceName,
859  NextAssemblyUsageOccurrenceDescription
860  };
861 
864  enum class Format
865  {
866  AP203,
867  AP214
868  };
869 
870  private:
872  STEP();
873  };
874 
876  class EXCHANGE_API PRC
877  {
878  public:
881  enum class BRepCompression
882  {
883  None,
884  Low,
885  Medium,
886  High
887  };
888 
889  private:
891  PRC();
892  };
893 
895  class EXCHANGE_API ProE
896  {
897  public:
900  enum class SessionColor
901  {
903  LastCreoVersion,
905  ExchangeDefault,
908  UserDefined
909  };
910 
911  private:
913  ProE();
914  };
915 
917  class EXCHANGE_API U3D
918  {
919  public:
922  enum class Version
923  {
924  ECMA1,
925  ECMA3
926  };
927 
928  private:
930  U3D();
931  };
932 
934  class EXCHANGE_API Configuration : public HPS::Sprocket
935  {
936  public:
938  Configuration();
939 
942  Configuration(char const * in_name);
943 
948  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
949 
953  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
954 
957  Configuration(Configuration const & in_configuration);
958 
962  Configuration(Configuration && in_that);
963 
967  Configuration & operator=(Configuration && in_that);
968 
969  virtual ~Configuration();
970 
971  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
972 
973 
976  void Set(Configuration const & in_kit);
977 
980  void Show(Configuration & out_kit) const;
981 
985  Configuration & operator=(Configuration const & in_kit);
986 
989  bool Empty() const;
990 
994  bool Equals(Configuration const & in_kit) const;
995 
999  bool operator==(Configuration const & in_kit) const;
1000 
1004  bool operator!=(Configuration const & in_kit) const;
1005 
1006 
1009  HPS::UTF8 GetName() const;
1010 
1013  ConfigurationArray GetSubconfigurations() const;
1014  };
1015 
1017  class EXCHANGE_API File
1018  {
1019  public:
1022  enum class Format
1023  {
1024  Unsupported,
1025  ACIS,
1026  CADDS,
1027  CATIAV4,
1028  CATIAV5,
1029  CGR,
1030  COLLADA,
1031  CreoProE,
1032  IDEAS,
1033  IFC,
1034  IGES,
1035  Inventor,
1036  JT,
1037  KeyholeMarkupLanguage,
1038  LatticeXVL,
1039  OneSpaceDesigner,
1040  Parasolid,
1041  PDF,
1042  PRC,
1043  Rhino,
1044  NXUnigraphics,
1045  SolidEdge,
1046  SolidWorks,
1047  STEP,
1048  StereoLithography,
1049  ThreeDStudioMax,
1050  ThreeDXML,
1051  Universal3D,
1052  VDAFS,
1053  VRML,
1054  WavefrontObject,
1055  };
1056 
1058  static Format GetFormat(char const * in_file_name);
1059 
1063  static ConfigurationArray GetConfigurations(char const * in_file_name);
1064 
1076  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);
1077 
1083  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1084 
1091  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1092 
1099  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1100 
1101 
1108  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1109 
1114  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1115 
1120  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1121 
1126  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1127 
1132  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1133 
1139  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1140 
1146  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1147 
1154  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1155 
1162  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1163 
1167  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1168 
1173  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1174 
1178  static ExportNotifier ExportPRC(KeyPath const & in_source);
1179 
1184  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1185 
1190  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1191 
1196  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1197 
1201  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1202 
1207  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1208 
1209  private:
1211  File();
1212  };
1213 
1215  class EXCHANGE_API ImportOptionsKit : public HPS::Sprocket
1216  {
1217  public:
1219  ImportOptionsKit();
1220 
1223  ImportOptionsKit(ImportOptionsKit const & in_kit);
1224 
1228  ImportOptionsKit(ImportOptionsKit && in_that);
1229 
1233  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1234 
1235  virtual ~ImportOptionsKit();
1236 
1237  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1238 
1242  static ImportOptionsKit GetDefault();
1243 
1246  void Set(ImportOptionsKit const & in_kit);
1247 
1250  void Show(ImportOptionsKit & out_kit) const;
1251 
1255  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1256 
1259  bool Empty() const;
1260 
1264  bool Equals(ImportOptionsKit const & in_kit) const;
1265 
1269  bool operator==(ImportOptionsKit const & in_kit) const;
1270 
1274  bool operator!=(ImportOptionsKit const & in_kit) const;
1275 
1276 
1282  ImportOptionsKit & SetBRepData(bool in_state);
1283 
1289  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1290 
1296  ImportOptionsKit & SetSolids(bool in_state);
1297 
1303  ImportOptionsKit & SetSurfaces(bool in_state);
1304 
1310  ImportOptionsKit & SetWireframes(bool in_state);
1311 
1317  ImportOptionsKit & SetPMI(bool in_state);
1318 
1325  ImportOptionsKit & SetAttributes(bool in_state);
1326 
1332  ImportOptionsKit & SetHiddenObjects(bool in_state);
1333 
1339  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1340 
1346  ImportOptionsKit & SetActiveFilter(bool in_state);
1347 
1353  ImportOptionsKit & SetDefaultUnits(Units in_units);
1354 
1361  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1362 
1368  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1369 
1375  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1376 
1382  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color);
1383 
1389  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1390 
1397  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1398 
1406  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1407 
1413  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1414 
1420  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1421 
1427  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1428 
1433  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1434 
1441  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1442 
1448  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1449 
1458  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1459 
1468  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1469 
1475  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1476 
1481  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1482 
1487  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1488 
1494  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1495 
1500  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1501 
1507  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1508 
1515  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1516 
1523  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1524 
1532  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1533 
1540  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1541 
1547  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1548 
1554  ImportOptionsKit & SetProECodePageName(char const * in_name);
1555 
1561  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1562 
1568  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1569 
1575  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1576 
1583  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
1584 
1590  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
1591 
1597  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
1598 
1604  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
1605 
1611  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
1612 
1618  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
1619 
1626  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
1627 
1633  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
1634 
1640  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
1641 
1648  ImportOptionsKit & SetIFCEdges(bool in_state);
1649 
1655  ImportOptionsKit & SetIFCMetadata(bool in_state);
1656 
1662  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
1663 
1669  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
1670 
1674  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
1675 
1687  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
1688 
1700  ImportOptionsKit & SetMode(ImportMode in_mode);
1701 
1711  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
1712 
1720  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
1721 
1728  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
1729 
1730 
1734  ImportOptionsKit & UnsetBRepData();
1735 
1738  ImportOptionsKit & UnsetBRepMode();
1739 
1742  ImportOptionsKit & UnsetSolids();
1743 
1746  ImportOptionsKit & UnsetSurfaces();
1747 
1750  ImportOptionsKit & UnsetWireframes();
1751 
1754  ImportOptionsKit & UnsetPMI();
1755 
1758  ImportOptionsKit & UnsetAttributes();
1759 
1762  ImportOptionsKit & UnsetHiddenObjects();
1763 
1766  ImportOptionsKit & UnsetConstructionAndReferences();
1767 
1770  ImportOptionsKit & UnsetActiveFilter();
1771 
1774  ImportOptionsKit & UnsetDefaultUnits();
1775 
1778  ImportOptionsKit & UnsetPMISubstitutionFont();
1779 
1782  ImportOptionsKit & UnsetPMIPrecision();
1783 
1786  ImportOptionsKit & UnsetPMIDefaultUnits();
1787 
1790  ImportOptionsKit & UnsetPMIDefaultColor();
1791 
1794  ImportOptionsKit & UnsetTessellationLevel();
1795 
1798  ImportOptionsKit & UnsetTessellationAccuracy();
1799 
1802  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
1803 
1806  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
1807 
1810  ImportOptionsKit & UnsetTextureDirectories();
1811 
1814  ImportOptionsKit & UnsetSearchDirectories();
1815 
1818  ImportOptionsKit & UnsetSearchDirectoriesByFile();
1819 
1822  ImportOptionsKit & UnsetConfiguration();
1823 
1826  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
1827 
1830  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
1831 
1834  ImportOptionsKit & UnsetCatiaV5Cache();
1835 
1838  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
1839 
1842  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
1843 
1846  ImportOptionsKit & UnsetProECodePageName();
1847 
1850  ImportOptionsKit & UnsetProEDimensionTolerance();
1851 
1854  ImportOptionsKit & UnsetProESubpartPMI();
1855 
1858  ImportOptionsKit & UnsetProESessionColor();
1859 
1862  ImportOptionsKit & UnsetSTEPNamePreference();
1863 
1866  ImportOptionsKit & UnsetSTEPFirstColorPreference();
1867 
1870  ImportOptionsKit & UnsetSTEPCodePageName();
1871 
1874  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
1875 
1878  ImportOptionsKit & UnsetSTEPOrientationHealing();
1879 
1882  ImportOptionsKit & UnsetIFCCodePageName();
1883 
1886  ImportOptionsKit & UnsetIFCAttributeXMLFile();
1887 
1890  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
1891 
1894  ImportOptionsKit & UnsetIFCFaceOptimization();
1895 
1898  ImportOptionsKit & UnsetIFCEdges();
1899 
1902  ImportOptionsKit & UnsetIFCMetadata();
1903 
1906  ImportOptionsKit & UnsetPDF3DStreamIndex();
1907 
1910  ImportOptionsKit & UnsetJTTessellationLevel();
1911 
1914  ImportOptionsKit & UnsetAnnotationCaptureFitting();
1915 
1918  ImportOptionsKit & UnsetLocation();
1919 
1922  ImportOptionsKit & UnsetMode();
1923 
1926  ImportOptionsKit & UnsetIncrementalComponentPaths();
1927 
1930  ImportOptionsKit & UnsetEverything();
1931 
1932 
1937  bool ShowBRepData(bool & out_state) const;
1938 
1942  bool ShowBRepMode(BRepMode & out_mode) const;
1943 
1947  bool ShowSolids(bool & out_state) const;
1948 
1952  bool ShowSurfaces(bool & out_state) const;
1953 
1957  bool ShowWireframes(bool & out_state) const;
1958 
1962  bool ShowPMI(bool & out_state) const;
1963 
1967  bool ShowAttributes(bool & out_state) const;
1968 
1972  bool ShowHiddenObjects(bool & out_state) const;
1973 
1977  bool ShowConstructionAndReferences(bool & out_state) const;
1978 
1982  bool ShowActiveFilter(bool & out_state) const;
1983 
1987  bool ShowDefaultUnits(Units & out_units) const;
1988 
1993  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
1994 
1998  bool ShowPMIPrecision(size_t & out_precision) const;
1999 
2003  bool ShowPMIDefaultUnits(Units & out_units) const;
2004 
2008  bool ShowPMIDefaultColor(RGBColor & out_color) const;
2009 
2017  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2018 
2023  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2024 
2028  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2029 
2033  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2034 
2038  bool ShowTextureDirectories(UTF8Array & out_directories);
2039 
2045  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2046 
2050  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2051 
2055  bool ShowConfiguration(UTF8Array & out_configuration) const;
2056 
2060  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2061 
2065  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2066 
2071  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2072 
2077  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2078 
2082  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2083 
2087  bool ShowProECodePageName(UTF8 & out_name) const;
2088 
2092  bool ShowProEDimensionTolerance(bool & out_state) const;
2093 
2097  bool ShowProESubpartPMI(bool & out_state) const;
2098 
2102  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2103 
2107  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2108 
2112  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2113 
2117  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2118 
2122  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2123 
2127  bool ShowSTEPOrientationHealing(bool & out_state) const;
2128 
2132  bool ShowIFCCodePageName(UTF8 & out_name) const;
2133 
2137  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2138 
2142  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2143 
2147  bool ShowIFCFaceOptimization(bool & out_state) const;
2148 
2152  bool ShowIFCEdges(bool & out_state) const;
2153 
2157  bool ShowIFCMetadata(bool & out_state) const;
2158 
2162  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2163 
2167  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2168 
2172  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2173 
2178  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2179 
2183  bool ShowMode(ImportMode & out_mode) const;
2184 
2188  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2189  };
2190 
2192  class EXCHANGE_API Translation
2193  {
2194  public:
2197  enum class Healing
2198  {
2199  Off,
2200  On,
2201  OnlyIfNotParasolid,
2202  };
2203 
2206  enum class AccurateEdges
2207  {
2208  Off,
2209  On,
2210  OnlyIfNotParasolid,
2211  };
2212 
2215  enum class Simplification
2216  {
2217  Off,
2218  On,
2219  OnlyIfNotParasolid,
2220  };
2221 
2224  enum class Merging
2225  {
2226  Off,
2227  On,
2228  OnlyIfNotParasolid,
2229  };
2230 
2231  private:
2233  Translation();
2234  };
2235 
2237  class EXCHANGE_API TranslationOptionsKit : public HPS::Sprocket
2238  {
2239  public:
2242 
2246 
2251 
2255  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2256 
2257  virtual ~TranslationOptionsKit();
2258 
2259  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2260 
2264  static TranslationOptionsKit GetDefault();
2265 
2268  void Set(TranslationOptionsKit const & in_kit);
2269 
2272  void Show(TranslationOptionsKit & out_kit) const;
2273 
2277  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2278 
2281  bool Empty() const;
2282 
2286  bool Equals(TranslationOptionsKit const & in_kit) const;
2287 
2291  bool operator==(TranslationOptionsKit const & in_kit) const;
2292 
2296  bool operator!=(TranslationOptionsKit const & in_kit) const;
2297 
2303  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2304 
2310  TranslationOptionsKit & SetTessellation(bool in_state);
2311 
2317  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2318 
2322  TranslationOptionsKit & SetApplication(char const * in_name);
2323 
2327  TranslationOptionsKit & SetVersion(char const * in_version);
2328 
2332  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2333 
2337  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2338 
2342  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
2343 
2347  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
2348 
2353  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
2354 
2358  TranslationOptionsKit & SetDisjointFaces(bool in_state);
2359 
2362  TranslationOptionsKit & UnsetSolidsAsFaces();
2363 
2366  TranslationOptionsKit & UnsetTessellation();
2367 
2370  TranslationOptionsKit & UnsetHiddenObjects();
2371 
2374  TranslationOptionsKit & UnsetApplication();
2375 
2378  TranslationOptionsKit & UnsetVersion();
2379 
2382  TranslationOptionsKit & UnsetHealing();
2383 
2386  TranslationOptionsKit & UnsetAccurateEdges();
2387 
2390  TranslationOptionsKit & UnsetSimplification();
2391 
2394  TranslationOptionsKit & UnsetEntityMerging();
2395 
2398  TranslationOptionsKit & UnsetSewing();
2399 
2402  TranslationOptionsKit & UnsetDisjointFaces();
2403 
2406  TranslationOptionsKit & UnsetEverything();
2407 
2408 
2412  bool ShowSolidsAsFaces(bool & out_state) const;
2413 
2417  bool ShowTessellation(bool & out_state) const;
2418 
2422  bool ShowHiddenObjects(bool & out_state) const;
2423 
2427  bool ShowApplication(UTF8 & out_name) const;
2428 
2432  bool ShowVersion(UTF8 & out_version) const;
2433 
2437  bool ShowHealing(Translation::Healing & out_healing) const;
2438 
2442  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
2443 
2447  bool ShowSimplification(Translation::Simplification & out_simplification) const;
2448 
2452  bool ShowEntityMerging(Translation::Merging & out_merging) const;
2453 
2458  bool ShowSewing(bool & out_state, double & out_tolerance) const;
2459 
2463  bool ShowDisjointFaces(bool & out_state) const;
2464  };
2465 
2466 
2467 
2472  class EXCHANGE_API ModelFileImportOptionsKit : public HPS::Sprocket
2473  {
2474  public:
2477 
2481 
2486 
2490  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
2491 
2492  virtual ~ModelFileImportOptionsKit();
2493 
2494  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
2495 
2499  static ModelFileImportOptionsKit GetDefault();
2500 
2503  void Set(ModelFileImportOptionsKit const & in_kit);
2504 
2507  void Show(ModelFileImportOptionsKit & out_kit) const;
2508 
2512  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
2513 
2516  bool Empty() const;
2517 
2521  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
2522 
2526  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
2527 
2531  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
2532 
2533 
2539  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
2540 
2547  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
2548 
2556  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
2557 
2563  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
2564 
2570  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
2571 
2578  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
2579 
2583  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2584 
2597  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2598 
2599 
2602  ModelFileImportOptionsKit & UnsetTessellationLevel();
2603 
2606  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
2607 
2610  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
2611 
2614  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2615 
2618  ModelFileImportOptionsKit & UnsetIFCEdges();
2619 
2622  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
2623 
2626  ModelFileImportOptionsKit & UnsetLocation();
2627 
2630  ModelFileImportOptionsKit & UnsetEverything();
2631 
2632 
2640  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2641 
2646  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2647 
2651  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2652 
2656  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2657 
2661  bool ShowIFCEdges(bool & out_state) const;
2662 
2666  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2667 
2672  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2673  };
2674 
2675 
2677  class EXCHANGE_API ExportACISOptionsKit : public HPS::Sprocket
2678  {
2679  public:
2682 
2686 
2690 
2691  virtual ~ExportACISOptionsKit();
2692 
2693  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
2694 
2698  static ExportACISOptionsKit GetDefault();
2699 
2702  void Set(ExportACISOptionsKit const & in_kit);
2703 
2706  void Show(ExportACISOptionsKit & out_kit) const;
2707 
2711  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
2712 
2716  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
2717 
2720  bool Empty() const;
2721 
2725  bool Equals(ExportACISOptionsKit const & in_kit) const;
2726 
2730  bool operator==(ExportACISOptionsKit const & in_kit) const;
2731 
2735  bool operator!=(ExportACISOptionsKit const & in_kit) const;
2736 
2737 
2743  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
2744 
2750  ExportACISOptionsKit & SetBinary(bool in_state);
2751 
2752 
2755  ExportACISOptionsKit & UnsetMillimeterUnits();
2756 
2759  ExportACISOptionsKit & UnsetBinary();
2760 
2763  ExportACISOptionsKit & UnsetEverything();
2764 
2765 
2769  bool ShowMillimeterUnits(bool & out_state) const;
2770 
2774  bool ShowBinary(bool & out_state) const;
2775  };
2776 
2778  class EXCHANGE_API ExportIGESOptionsKit : public HPS::Sprocket
2779  {
2780  public:
2783 
2787 
2791 
2792  virtual ~ExportIGESOptionsKit();
2793 
2794  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
2795 
2799  static ExportIGESOptionsKit GetDefault();
2800 
2803  void Set(ExportIGESOptionsKit const & in_kit);
2804 
2807  void Show(ExportIGESOptionsKit & out_kit) const;
2808 
2812  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
2813 
2817  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
2818 
2821  bool Empty() const;
2822 
2826  bool Equals(ExportIGESOptionsKit const & in_kit) const;
2827 
2831  bool operator==(ExportIGESOptionsKit const & in_kit) const;
2832 
2836  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
2837 
2838 
2844  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
2845 
2851  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
2852 
2858  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
2859 
2865  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
2866 
2872  ExportIGESOptionsKit & SetTessellation(bool in_state);
2873 
2877  ExportIGESOptionsKit & SetApplication(char const * in_name);
2878 
2882  ExportIGESOptionsKit & SetVersion(char const * in_version);
2883 
2884 
2887  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
2888 
2891  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
2892 
2895  ExportIGESOptionsKit & UnsetSolidsAsFaces();
2896 
2899  ExportIGESOptionsKit & UnsetHiddenObjects();
2900 
2903  ExportIGESOptionsKit & UnsetTessellation();
2904 
2907  ExportIGESOptionsKit & UnsetApplication();
2908 
2911  ExportIGESOptionsKit & UnsetVersion();
2912 
2915  ExportIGESOptionsKit & UnsetEverything();
2916 
2917 
2921  bool ShowAnalyticsAsNURBS(bool & out_state) const;
2922 
2926  bool ShowFacetedAsWireframe(bool & out_state) const;
2927 
2931  bool ShowSolidsAsFaces(bool & out_state) const;
2932 
2936  bool ShowHiddenObjects(bool & out_state) const;
2937 
2941  bool ShowTessellation(bool & out_state) const;
2942 
2946  bool ShowApplication(UTF8 & out_name) const;
2947 
2951  bool ShowVersion(UTF8 & out_version) const;
2952  };
2953 
2955  class EXCHANGE_API ExportJTOptionsKit : public HPS::Sprocket
2956  {
2957  public:
2960 
2963  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
2964 
2968 
2969  virtual ~ExportJTOptionsKit();
2970 
2971  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
2972 
2976  static ExportJTOptionsKit GetDefault();
2977 
2980  void Set(ExportJTOptionsKit const & in_kit);
2981 
2984  void Show(ExportJTOptionsKit & out_kit) const;
2985 
2989  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
2990 
2994  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
2995 
2998  bool Empty() const;
2999 
3003  bool Equals(ExportJTOptionsKit const & in_kit) const;
3004 
3008  bool operator==(ExportJTOptionsKit const & in_kit) const;
3009 
3013  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3014 
3015 
3021  ExportJTOptionsKit & SetContent(JT::Content in_content);
3022 
3028  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3029 
3035  ExportJTOptionsKit & SetPMI(bool in_state);
3036 
3037 
3040  ExportJTOptionsKit & UnsetContent();
3041 
3044  ExportJTOptionsKit & UnsetHiddenObjects();
3045 
3048  ExportJTOptionsKit & UnsetPMI();
3049 
3052  ExportJTOptionsKit & UnsetEverything();
3053 
3054 
3058  bool ShowContent(JT::Content & out_content) const;
3059 
3063  bool ShowHiddenObjects(bool & out_state) const;
3064 
3068  bool ShowPMI(bool & out_state) const;
3069  };
3070 
3072  class EXCHANGE_API ExportParasolidOptionsKit : public HPS::Sprocket
3073  {
3074  public:
3077 
3081 
3085 
3086  virtual ~ExportParasolidOptionsKit();
3087 
3088  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
3089 
3093  static ExportParasolidOptionsKit GetDefault();
3094 
3097  void Set(ExportParasolidOptionsKit const & in_kit);
3098 
3101  void Show(ExportParasolidOptionsKit & out_kit) const;
3102 
3106  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
3107 
3111  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
3112 
3115  bool Empty() const;
3116 
3120  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
3121 
3125  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
3126 
3130  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
3131 
3132 
3138  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
3139 
3145  ExportParasolidOptionsKit & SetTessellation(bool in_state);
3146 
3152  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
3153 
3157  ExportParasolidOptionsKit & SetApplication(char const * in_name);
3158 
3162  ExportParasolidOptionsKit & SetVersion(char const * in_version);
3163 
3164 
3167  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
3168 
3171  ExportParasolidOptionsKit & UnsetTessellation();
3172 
3175  ExportParasolidOptionsKit & UnsetHiddenObjects();
3176 
3179  ExportParasolidOptionsKit & UnsetApplication();
3180 
3183  ExportParasolidOptionsKit & UnsetVersion();
3184 
3187  ExportParasolidOptionsKit & UnsetEverything();
3188 
3189 
3193  bool ShowSolidsAsFaces(bool & out_state) const;
3194 
3198  bool ShowTessellation(bool & out_state) const;
3199 
3203  bool ShowHiddenObjects(bool & out_state) const;
3204 
3208  bool ShowApplication(UTF8 & out_name) const;
3209 
3213  bool ShowVersion(UTF8 & out_version) const;
3214  };
3215 
3217  class EXCHANGE_API ExportPRCOptionsKit : public HPS::Sprocket
3218  {
3219  public:
3222 
3225  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3226 
3230 
3231  virtual ~ExportPRCOptionsKit();
3232 
3233  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
3234 
3238  static ExportPRCOptionsKit GetDefault();
3239 
3242  void Set(ExportPRCOptionsKit const & in_kit);
3243 
3246  void Show(ExportPRCOptionsKit & out_kit) const;
3247 
3251  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
3252 
3256  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
3257 
3260  bool Empty() const;
3261 
3265  bool Equals(ExportPRCOptionsKit const & in_kit) const;
3266 
3270  bool operator==(ExportPRCOptionsKit const & in_kit) const;
3271 
3275  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
3276 
3277 
3283  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
3284 
3291  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
3292 
3298  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
3299 
3305  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
3306 
3311  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3312 
3318  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
3319 
3320 
3323  ExportPRCOptionsKit & UnsetTessellationCompression();
3324 
3327  ExportPRCOptionsKit & UnsetBRepCompression();
3328 
3331  ExportPRCOptionsKit & UnsetBRepRemoval();
3332 
3335  ExportPRCOptionsKit & UnsetAttributeRemoval();
3336 
3339  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
3340 
3343  ExportPRCOptionsKit & UnsetEverything();
3344 
3345 
3349  bool ShowTessellationCompression(bool & out_state) const;
3350 
3354  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
3355 
3359  bool ShowBRepRemoval(bool & out_state) const;
3360 
3364  bool ShowAttributeRemoval(bool & out_state) const;
3365 
3369  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3370  };
3371 
3373  class EXCHANGE_API ExportSTEPOptionsKit : public HPS::Sprocket
3374  {
3375  public:
3378 
3382 
3386 
3387  virtual ~ExportSTEPOptionsKit();
3388 
3389  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
3390 
3394  static ExportSTEPOptionsKit GetDefault();
3395 
3398  void Set(ExportSTEPOptionsKit const & in_kit);
3399 
3402  void Show(ExportSTEPOptionsKit & out_kit) const;
3403 
3407  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
3408 
3412  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
3413 
3416  bool Empty() const;
3417 
3421  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
3422 
3426  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
3427 
3431  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
3432 
3433 
3439  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
3440 
3446  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3447 
3453  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
3454 
3460  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
3461 
3465  ExportSTEPOptionsKit & SetApplication(char const * in_name);
3466 
3470  ExportSTEPOptionsKit & SetVersion(char const * in_version);
3471 
3472 
3475  ExportSTEPOptionsKit & UnsetFormat();
3476 
3479  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
3480 
3483  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
3484 
3487  ExportSTEPOptionsKit & UnsetNameShortening();
3488 
3491  ExportSTEPOptionsKit & UnsetApplication();
3492 
3495  ExportSTEPOptionsKit & UnsetVersion();
3496 
3499  ExportSTEPOptionsKit & UnsetEverything();
3500 
3501 
3505  bool ShowFormat(STEP::Format & out_format) const;
3506 
3510  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3511 
3515  bool ShowFacetedAsWireframe(bool & out_state) const;
3516 
3520  bool ShowNameShortening(bool & out_state) const;
3521 
3525  bool ShowApplication(UTF8 & out_name) const;
3526 
3530  bool ShowVersion(UTF8 & out_version) const;
3531  };
3532 
3534  class EXCHANGE_API ExportSTLOptionsKit : public HPS::Sprocket
3535  {
3536  public:
3539 
3542  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
3543 
3547 
3548  virtual ~ExportSTLOptionsKit();
3549 
3550  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
3551 
3555  static ExportSTLOptionsKit GetDefault();
3556 
3559  void Set(ExportSTLOptionsKit const & in_kit);
3560 
3563  void Show(ExportSTLOptionsKit & out_kit) const;
3564 
3568  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
3569 
3573  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
3574 
3577  bool Empty() const;
3578 
3582  bool Equals(ExportSTLOptionsKit const & in_kit) const;
3583 
3587  bool operator==(ExportSTLOptionsKit const & in_kit) const;
3588 
3592  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
3593 
3594 
3600  ExportSTLOptionsKit & SetBinary(bool in_state);
3601 
3607  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3608 
3615  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3616 
3622  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
3623 
3629  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
3630 
3637  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
3638 
3639 
3642  ExportSTLOptionsKit & UnsetBinary();
3643 
3646  ExportSTLOptionsKit & UnsetTessellationLevel();
3647 
3650  ExportSTLOptionsKit & UnsetTessellationAccuracy();
3651 
3654  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
3655 
3658  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
3659 
3662  ExportSTLOptionsKit & UnsetEverything();
3663 
3664 
3668  bool ShowBinary(bool & out_state) const;
3669 
3677  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3678 
3682  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
3683 
3687  bool ShowCurrentTessellationRetention(bool & out_state) const;
3688 
3692  bool ShowMaximumEdgeLength(double & out_length) const;
3693  };
3694 
3696  class EXCHANGE_API ExportU3DOptionsKit : public HPS::Sprocket
3697  {
3698  public:
3701 
3704  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
3705 
3709 
3710  virtual ~ExportU3DOptionsKit();
3711 
3712  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
3713 
3717  static ExportU3DOptionsKit GetDefault();
3718 
3721  void Set(ExportU3DOptionsKit const & in_kit);
3722 
3725  void Show(ExportU3DOptionsKit & out_kit) const;
3726 
3730  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
3731 
3735  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
3736 
3739  bool Empty() const;
3740 
3744  bool Equals(ExportU3DOptionsKit const & in_kit) const;
3745 
3749  bool operator==(ExportU3DOptionsKit const & in_kit) const;
3750 
3754  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
3755 
3756 
3762  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
3763 
3768  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
3769 
3770 
3773  ExportU3DOptionsKit & UnsetVersion();
3774 
3777  ExportU3DOptionsKit & UnsetCompression();
3778 
3781  ExportU3DOptionsKit & UnsetEverything();
3782 
3783 
3787  bool ShowVersion(U3D::Version & out_version) const;
3788 
3792  bool ShowCompression(unsigned char & out_level) const;
3793  };
3794 
3796  class EXCHANGE_API ExportXMLOptionsKit : public HPS::Sprocket
3797  {
3798  public:
3801 
3804  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
3805 
3809 
3810  virtual ~ExportXMLOptionsKit();
3811 
3812  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
3813 
3817  static ExportXMLOptionsKit GetDefault();
3818 
3821  void Set(ExportXMLOptionsKit const & in_kit);
3822 
3825  void Show(ExportXMLOptionsKit & out_kit) const;
3826 
3830  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
3831 
3835  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
3836 
3839  bool Empty() const;
3840 
3844  bool Equals(ExportXMLOptionsKit const & in_kit) const;
3845 
3849  bool operator==(ExportXMLOptionsKit const & in_kit) const;
3850 
3854  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
3855 
3856 
3862  ExportXMLOptionsKit & SetMetadata(bool in_state);
3863 
3869  ExportXMLOptionsKit & SetTransformations(bool in_state);
3870 
3876  ExportXMLOptionsKit & SetMaterials(bool in_state);
3877 
3878 
3881  ExportXMLOptionsKit & UnsetMetadata();
3882 
3885  ExportXMLOptionsKit & UnsetTransformations();
3886 
3889  ExportXMLOptionsKit & UnsetMaterials();
3890 
3893  ExportXMLOptionsKit & UnsetEverything();
3894 
3895 
3899  bool ShowMetadata(bool & out_state) const;
3900 
3904  bool ShowTransformations(bool & out_state) const;
3905 
3909  bool ShowMaterials(bool & out_state) const;
3910  };
3911 
3913  class EXCHANGE_API TessellationOptionsKit : public HPS::Sprocket
3914  {
3915  public:
3918 
3922 
3926 
3927  virtual ~TessellationOptionsKit();
3928 
3929  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
3930 
3934  static TessellationOptionsKit GetDefault();
3935 
3938  void Set(TessellationOptionsKit const & in_kit);
3939 
3942  void Show(TessellationOptionsKit & out_kit) const;
3943 
3947  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
3948 
3952  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
3953 
3956  bool Empty() const;
3957 
3961  bool Equals(TessellationOptionsKit const & in_kit) const;
3962 
3966  bool operator==(TessellationOptionsKit const & in_kit) const;
3967 
3971  bool operator!=(TessellationOptionsKit const & in_kit) const;
3972 
3973 
3977  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
3978 
3985  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3986 
3992  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3993 
3997  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
3998 
4002  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4003 
4004 
4007  TessellationOptionsKit & UnsetLevel();
4008 
4011  TessellationOptionsKit & UnsetAccuracy();
4012 
4015  TessellationOptionsKit & UnsetUVPointPreservation();
4016 
4019  TessellationOptionsKit & UnsetMaximumEdgeLength();
4020 
4023  TessellationOptionsKit & UnsetEverything();
4024 
4025 
4033  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4034 
4039  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
4040 
4044  bool ShowUVPointPreservation(bool & out_state) const;
4045 
4049  bool ShowMaximumEdgeLength(double & out_length) const;
4050  };
4051 
4057  class EXCHANGE_API CommonMeasurementOperator : public Operator
4058  {
4059  public:
4060  enum class Tags
4061  {
4062  Name = 0,
4063  MeasurementType,
4064  Radius,
4065  Inverted,
4066  VectorX,
4067  VectorY,
4068  VectorZ,
4069  };
4070 
4071  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4072 
4074  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
4075 
4076  virtual void OnViewAttached() OVERRIDE;
4077  virtual void OnViewDetached() OVERRIDE;
4078 
4079  Exchange::CADModel GetCADModel() const;
4080  void SetCADModel(Exchange::CADModel const & in_cad_model);
4081 
4083  size_t GetPrecision() const;
4084 
4087  void SetPrecision(size_t in_precision);
4088 
4090  MaterialMappingKit GetMaterial() const;
4091 
4094  void SetMaterial(MaterialMappingKit const & in_material_mapping);
4095 
4097  TextAttributeKit GetTextAttributes() const;
4098 
4101  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
4102 
4104  SegmentKey GetMeasurementSegment() const;
4105 
4107  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
4108 
4109  /* Deletes all measurements */
4110  void DeleteMeasurements();
4111 
4112  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
4113  {
4114  public:
4117  {
4118  channel = GetClassID();
4119  consumable = false;
4120  }
4121 
4122  MeasurementInsertedEvent(HPS::Key const & in_measurement_key) : Event()
4123  {
4124  channel = GetClassID();
4125  consumable = false;
4126  measurement_key = in_measurement_key;
4127  }
4128 
4131  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
4132  {
4133  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
4134  {
4135  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
4136  measurement_key = that.measurement_key;
4137  }
4138  else
4139  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4140  }
4141 
4143 
4146  Event * Clone() const
4147  {
4148  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
4149  return new_event;
4150  }
4151 
4152  Key measurement_key;
4153  };
4154 
4155  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
4156  {
4157  public:
4160  {
4161  channel = GetClassID();
4162  consumable = false;
4163  }
4164 
4165  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name) : Event()
4166  {
4167  channel = GetClassID();
4168  consumable = false;
4169  measurement_name = in_measurement_name;
4170  }
4171 
4174  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
4175  {
4176  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
4177  {
4178  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
4179  measurement_name = that.measurement_name;
4180  }
4181  else
4182  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4183  }
4184 
4186 
4189  Event * Clone() const
4190  {
4191  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
4192  return new_event;
4193  }
4194 
4195  UTF8 measurement_name;
4196  };
4197 
4198  protected:
4199  Exchange::CADModel cad_model;
4200  size_t measurement_precision;
4201  UTF8 units;
4202  MaterialMappingKit materials;
4203  TextAttributeKit text_attributes;
4204  SegmentKey measurement_segment;
4205  GlyphDefinition left_arrow;
4206  GlyphDefinition right_arrow;
4207  SelectionOptionsKit selection_options;
4208  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
4209  Vector camera_direction;
4210  PortfolioKey portfolio;
4211  SegmentKey style_segment;
4212  HighlightOptionsKit highlight_options;
4213 
4214  static size_t length_measurement_index;
4215  static size_t radius_measurement_index;
4216  static size_t distance_measurement_index;
4217  static size_t angle_measurement_index;
4218 
4219  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
4220  void GetUnits();
4221  void SetGlyphColor();
4222  void GetCameraDirection();
4223  void SetupConstructionSegment();
4224  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
4225  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
4226  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
4227  float GetModelScale(Exchange::Component const & component);
4228  double ConvertFromMillimeters(double in_measurement, UTF8 const & in_measurement_units);
4229  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
4230  };
4231 
4284  {
4285  public:
4286  enum class MeasurementType
4287  {
4288  PointToPoint,
4289  EdgeAndRadius,
4290  FeatureToFeature,
4291  FaceAngle,
4292  };
4293 
4294  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4295 
4297  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
4298 
4299  virtual void OnViewAttached() OVERRIDE;
4300  virtual void OnViewDetached() OVERRIDE;
4301 
4306  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
4307 
4311  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
4312 
4320  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
4321 
4325  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
4326 
4327  /* Sets the type of measurement to insert.
4328  * \param in_measurement_type The type of measurement to insert.*/
4329  void SetMeasurementType(MeasurementType in_measurement_type);
4330 
4333  MeasurementType GetMeasurementType();
4334 
4335  /* Whether measurable geometry should be highlighted when mousing over it
4336  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
4337  void SetMouseOverHighlighting(bool in_highlighting);
4338 
4339  /* Whether measurable geometry should be highlighted when mousing over it
4340  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
4341  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
4342  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
4343 
4344  /* Whether measurable geometry is highlighted when mousing over it
4345  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
4346  bool GetMouseOverHighlighting();
4347 
4348  /* Returns the highlight option kit currently used for mouse over highlighting.
4349  * \return the highlight option kit currently used for mouse over highlighting. */
4350  HighlightOptionsKit GetHighlightOptions();
4351 
4352  private:
4353  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
4354  {
4355  Circle,
4356  Line,
4357  Generic,
4358  };
4359 
4360  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
4361  {
4362  public:
4363  Surface();
4364 
4365  enum class SurfaceType
4366  {
4367  Plane,
4368  ConeOrCylinder,
4369  Unsupported,
4370  };
4371 
4372  SurfaceType surface_type; //the type of surface being measured
4373  Point center; //the center point of the surface
4374  Vector normal; //the center line of surfaces of type Cylinder or Cone
4375  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
4376  ComponentPath path; //the component path to this surface
4377  };
4378 
4379  //bookkeeping
4380  MeasurementType measurement_type; //the type of measurement to be inserted
4381  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
4382  TouchID tracked_touch_id;
4383  SegmentKey current_measurement; //segment of the measurement being inserted / edited
4384  bool operator_active; //whether a measurement is in progress
4385  bool end_measurement; //whether we should end the current measurement
4386  CanvasArray canvases; //canvases related to the view where this operator is attached
4387 
4388  //measurement anchors
4389  size_t anchors; //valid for point-to-point and face-angle measurements
4390  bool anchors_in_place; //true if all the anchors have been placed
4391  Point first_click_position; //position of the first anchor
4392  Point second_click_position; //position of the second anchor
4393 
4394  //geometry for linear measurements
4395  MarkerKey anchor_one; //marker corresponding to the start of the measurement
4396  MarkerKey anchor_two; //marker corresponding to the end of the measurement
4397  LineKey distance_line; //a line representing the distance measured
4398  LineKey leader_line_one; //line connecting the first anchor point to the distance line
4399  LineKey leader_line_two; //line connecting the second anchor point to the distance line
4400  Point distance_point_one; //intersection of leader_line_one and distance_line
4401  Point distance_point_two; //intersection of leader_line_two and distance_line
4402  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
4403  TextKey text; //text representing the measurement and units
4404  UTF8 text_string; //the contents of the text
4405  Vector measurement_direction; //the direction of the measurement
4406  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
4407  Vector explicit_direction; //used if use_explicit_direction is true
4408 
4409  //geometry for radius measurement
4410  MarkerKey center_marker; //marker representing the center of the circle
4411  Point circle_center; //circle center
4412  float radius; //circle radius
4413 
4414  //edge specific data
4415  LineKey edge_line; //the edge being measured
4416  double edge_length; //length of the measured edge
4417  EdgeType edge_type; //the type of edge being measured
4418 
4419  //feature-to-feature specific data
4420  Surface surface_one; //data related to first selected surface
4421  Surface surface_two; //data related to second selected surface
4422  Plane measurement_plane; //the measurement plane
4423  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
4424 
4425  //angle specific data
4426  Vector leader_line_one_direction; //the direction of the first leader line
4427  Vector leader_line_two_direction; //the direction of the second leader line
4428  Vector first_face_normal; //the normal of the first selected face
4429  Vector second_face_normal; //the normal of the second selected face
4430  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'
4431  CircularArcKey measurement_arc; //an arc representing the measured angle
4432  LineKey line_to_leader_line; //line extending from one anchor to a leader line
4433  Vector mid_point_direction;
4434 
4435  //selection kits
4436  SelectionOptionsKit point_to_point_selection;
4437  SelectionOptionsKit edge_radius_selection;
4438  SelectionOptionsKit feature_to_feature_selection;
4439  SelectionOptionsKit angle_selection;
4440 
4441  //highlighting
4442  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
4443  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
4444  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
4445  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
4446  KeyPath highlighted_path; //highlighted_path
4447  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
4448  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
4449 
4450  //input handling
4451  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
4452  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
4453  bool InputUp(WindowKey & in_window);
4454  void ResetMeasurement();
4455 
4456  //inserting measurements
4457  void InsertPointToPointMeasurement(Point const & in_world_point);
4458  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
4459  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4460  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
4461  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4462  void InvertMeasuredAngle(WindowKey & in_window);
4463  void AdjustLineToCursor(Point const & cursor_position);
4464 
4465  //saving measurements
4466  void TagMeasurement();
4467  void TagPointToPointMeasurement();
4468  void TagEdgeMeasurement();
4469  void TagRadiusMeasurement();
4470  void TagGenericEdgeMeasurement();
4471  void TagFeatureToFeatureMeasurement();
4472  void TagAngleMeasurement();
4473 
4474  //restoring measurements
4475  void RestoreMeasurement(SegmentKey const & measurement_segment);
4476  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
4477  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
4478  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
4479  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
4480  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
4481  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
4482  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
4483 
4484  //topology functions
4485  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
4486  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
4487  void PlaneToCenterLineDistance();
4488  void PlaneToPlaneDistance();
4489  void LineToLineDistance();
4490  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);
4491  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
4492  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
4493  bool IsPlane(Exchange::Component const & face_component);
4494  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
4495  };
4496 
4497 private:
4499  Exchange();
4500 };
4501 
4502 }
4503 
4504 #endif
Definition: hps.h:6069
Definition: sprk_exchange.h:3217
Level
Definition: sprk_exchange.h:774
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2971
Definition: sprk_exchange.h:43
Definition: sprk_exchange.h:876
Definition: sprk.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:269
Definition: sprk_exchange.h:1017
Definition: sprk_exchange.h:4057
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5578
Units
Definition: sprk_exchange.h:62
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2215
Definition: sprk.h:100
Definition: sprk_exchange.h:572
Version
Definition: sprk_exchange.h:922
Definition: sprk_exchange.h:2472
Definition: sprk_exchange.h:784
Definition: sprk_exchange.h:671
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4074
HPS::Type ObjectType() const
Definition: sprk_exchange.h:653
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3812
Definition: hps.h:1638
Format
Definition: sprk_exchange.h:864
HPS::Type ObjectType() const
Definition: sprk_exchange.h:699
Definition: sprk_exchange.h:3796
Definition: hps.h:42938
Format
Definition: sprk_exchange.h:1022
Definition: hps.h:7441
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3233
Type
Definition: sprk_exchange.h:765
Definition: hps.h:15148
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2794
Definition: sprk_exchange.h:435
Definition: sprk_exchange.h:519
Definition: sprk_exchange.h:296
HPS::Type ObjectType() const
Definition: sprk_exchange.h:416
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4297
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3088
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:4131
HPS::Type ObjectType() const
Definition: sprk_exchange.h:131
Definition: sprk_exchange.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3550
HPS::Type ObjectType() const
Definition: sprk_exchange.h:322
Definition: sprk_exchange.h:2955
Merging
Definition: sprk_exchange.h:2224
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2259
Field
Definition: sprk_exchange.h:854
Definition: hps.h:37542
HPS::Type ObjectType() const
Definition: sprk_exchange.h:971
Definition: sprk_exchange.h:2677
Definition: sprk_exchange.h:2237
Limit
Definition: sprk_exchange.h:789
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3389
TessellationLevel
Definition: sprk_exchange.h:836
Definition: sprk_exchange.h:760
Definition: sprk_exchange.h:3534
Definition: sprk_exchange.h:110
Definition: sprk_exchange.h:849
Definition: hps.h:4250
Definition: hps.h:6817
Definition: hps.h:42329
Definition: sprk_exchange.h:390
UnloadMode
Definition: sprk_exchange.h:79
Definition: hps.h:39316
Definition: hps.h:42725
AnnotationCaptureFitting
Definition: sprk_exchange.h:753
Definition: sprk_exchange.h:3696
Definition: sprk_exchange.h:822
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2693
Definition: hps.h:14562
Event * Clone() const
Definition: sprk_exchange.h:4189
intptr_t GetChannel() const
Definition: hps.h:6202
Definition: sprk_exchange.h:917
SessionColor
Definition: sprk_exchange.h:900
Definition: sprk.h:1614
Definition: hps.h:43048
LoadStatus
Definition: sprk_exchange.h:94
Definition: hps.h:40296
Definition: hps.h:41994
Definition: sprk_exchange.h:479
Definition: hps.h:6169
Definition: hps.h:13014
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3929
Definition: sprk_exchange.h:4283
Definition: sprk.h:445
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1237
BRepCompression
Definition: sprk_exchange.h:881
BRepMode
Definition: sprk_exchange.h:726
Definition: sprk.h:1876
ComponentType
Definition: sprk.h:1619
Accuracy
Definition: sprk_exchange.h:806
Definition: sprk_exchange.h:2778
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:4174
Definition: sprk.h:2187
Content
Definition: sprk_exchange.h:827
Definition: sprk_exchange.h:1215
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2494
HPS::Type ObjectType() const
Definition: sprk_exchange.h:600
Definition: sprk.h:2286
static MouseButtons ButtonLeft()
Definition: hps.h:42447
Definition: hps.h:7360
Definition: sprk_exchange.h:895
AccurateEdges
Definition: sprk_exchange.h:2206
Event * Clone() const
Definition: sprk_exchange.h:4146
HPS::Type ObjectType() const
Definition: sprk_exchange.h:461
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3712
Definition: hps.h:8938
HPS::Type ObjectType() const
Definition: sprk_exchange.h:204
Definition: sprk_exchange.h:625
Definition: hps.h:22314
Healing
Definition: sprk_exchange.h:2197
Definition: sprk.h:2372
Definition: hps.h:28444
ImportMode
Definition: sprk_exchange.h:741
Definition: sprk_exchange.h:934
Definition: sprk.h:1065
Definition: sprk_exchange.h:2192
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:3072
Definition: sprk_exchange.h:172
Definition: hps.h:37080
Definition: sprk_exchange.h:3913
HPS::Type ObjectType() const
Definition: sprk_exchange.h:547
Definition: hps.h:38128
Definition: sprk_exchange.h:3373