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 
391  void Tessellate(TessellationOptionsKit const & in_options);
392  };
393 
396  class EXCHANGE_API Capture : public HPS::Capture
397  {
398  public:
400  Capture();
401 
405  Capture(Component const & in_that);
406 
410  Capture(HPS::Capture const & in_that);
411 
414  Capture(Exchange::Capture const & in_that);
415 
418  Capture(Exchange::Capture && in_that);
419 
420  virtual ~Capture();
421 
422  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
423 
424 #if !defined(_MSC_VER) || _MSC_VER >= 1900
425  Capture & operator=(Exchange::Capture const & in_that) = default;
426 #endif
427 
431  Capture & operator=(Exchange::Capture && in_that);
432 
433 
436  A3DEntity * GetExchangeEntity() const;
437  };
438 
441  class EXCHANGE_API Filter : public HPS::Filter
442  {
443  public:
445  Filter();
446 
450  Filter(Component const & in_that);
451 
455  Filter(HPS::Filter const & in_that);
456 
459  Filter(Exchange::Filter const & in_that);
460 
463  Filter(Exchange::Filter && in_that);
464 
465  virtual ~Filter();
466 
467  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
468 
469 #if !defined(_MSC_VER) || _MSC_VER >= 1900
470  Filter & operator=(Exchange::Filter const & in_that) = default;
471 #endif
472 
476  Filter & operator=(Exchange::Filter && in_that);
477 
478 
481  A3DEntity * GetExchangeEntity() const;
482  };
483 
485  class EXCHANGE_API Factory : public Sprocket
486  {
487  public:
492  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
493 
499  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
500 
504  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
505 
512  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
513 
517  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
518 
519  private:
521  Factory();
522  };
523 
525  class EXCHANGE_API ImportNotifier : public IONotifier
526  {
527  public:
529  ImportNotifier();
530 
533  ImportNotifier(ImportNotifier const & in_that);
534 
539  ImportNotifier(IONotifier const & in_that);
540 
544  ImportNotifier(ImportNotifier && in_that);
545 
549  ImportNotifier & operator=(ImportNotifier && in_that);
550 
551  virtual ~ImportNotifier();
552 
553  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
554 
558  ImportNotifier & operator=(ImportNotifier const & in_that);
559 
562  void Assign(ImportNotifier const & in_that);
563 
566  Exchange::CADModel GetCADModel() const;
567 
570  Time GetImportTime() const;
571 
574  Time GetParseTime() const;
575  };
576 
578  class EXCHANGE_API TranslationNotifier : public IONotifier
579  {
580  public:
583 
586  TranslationNotifier(TranslationNotifier const & in_that);
587 
592  TranslationNotifier(IONotifier const & in_that);
593 
598 
602  TranslationNotifier & operator=(TranslationNotifier && in_that);
603 
604  virtual ~TranslationNotifier();
605 
606  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
607 
611  TranslationNotifier & operator=(TranslationNotifier const & in_that);
612 
615  void Assign(TranslationNotifier const & in_that);
616 
619  Exchange::ParasolidEntityArray GetParasolidParts() const;
620 
623  HPS::Time GetImportTime() const;
624 
627  HPS::Time GetTranslationTime() const;
628  };
629 
631  class EXCHANGE_API ExportNotifier : public IONotifier
632  {
633  public:
635  ExportNotifier();
636 
639  ExportNotifier(ExportNotifier const & in_that);
640 
645  ExportNotifier(IONotifier const & in_that);
646 
650  ExportNotifier(ExportNotifier && in_that);
651 
655  ExportNotifier & operator=(ExportNotifier && in_that);
656 
657  virtual ~ExportNotifier();
658 
659  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
660 
664  ExportNotifier & operator=(ExportNotifier const & in_that);
665 
668  void Assign(ExportNotifier const & in_that);
669 
673  A3DAsmModelFile * GetModelFile() const;
674  };
675 
677  class EXCHANGE_API ReloadNotifier : public IONotifier
678  {
679  public:
681  ReloadNotifier();
682 
685  ReloadNotifier(ReloadNotifier const & in_that);
686 
691  ReloadNotifier(IONotifier const & in_that);
692 
696  ReloadNotifier(ReloadNotifier && in_that);
697 
701  ReloadNotifier & operator=(ReloadNotifier && in_that);
702 
703  virtual ~ReloadNotifier();
704 
705  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
706 
710  ReloadNotifier & operator=(ReloadNotifier const & in_that);
711 
714  void Assign(ReloadNotifier const & in_that);
715  };
716 
717 
718  class ImportOptionsKit;
719  class ModelFileImportOptionsKit;
720  class ExportACISOptionsKit;
721  class ExportIGESOptionsKit;
722  class ExportJTOptionsKit;
723  class ExportPRCOptionsKit;
724  class ExportSTEPOptionsKit;
725  class ExportSTLOptionsKit;
726  class ExportU3DOptionsKit;
727  class ExportXMLOptionsKit;
728 
729 
732  enum class BRepMode
733  {
736  TessellationOnly,
739  BRepOnly,
742  BRepAndTessellation,
743  };
744 
747  enum class ImportMode
748  {
751  Complete,
754  Incremental,
755  };
756 
760  {
761  PMIOnly,
762  ModelAndPMI
763  };
764 
766  class EXCHANGE_API Tessellation
767  {
768  public:
771  enum class Type
772  {
773  Standard,
774  Custom
775  };
776 
777 
780  enum class Level
781  {
782  ExtraLow,
783  Low,
784  Medium,
785  High,
786  ExtraHigh,
787  };
788 
790  class EXCHANGE_API Chord
791  {
792  public:
795  enum class Limit
796  {
799  Ratio,
802  Height
803  };
804 
805  private:
807  Chord();
808  };
809 
812  enum class Accuracy
813  {
816  Standard,
819  Accurate
820  };
821 
822  private:
824  Tessellation();
825  };
826 
828  class EXCHANGE_API JT
829  {
830  public:
833  enum class Content
834  {
835  Geometry,
836  Tessellation,
837  GeometryAndTessellation
838  };
839 
842  enum class TessellationLevel
843  {
844  Low,
845  Medium,
846  High,
847  };
848 
849  private:
851  JT();
852  };
853 
855  class EXCHANGE_API STEP
856  {
857  public:
860  enum class Field
861  {
862  ProductName,
863  NextAssemblyUsageOccurrenceID,
864  NextAssemblyUsageOccurrenceName,
865  NextAssemblyUsageOccurrenceDescription
866  };
867 
870  enum class Format
871  {
872  AP203,
873  AP214,
874  AP242,
875  };
876 
877  private:
879  STEP();
880  };
881 
883  class EXCHANGE_API PRC
884  {
885  public:
888  enum class BRepCompression
889  {
890  None,
891  Low,
892  Medium,
893  High
894  };
895 
896  private:
898  PRC();
899  };
900 
902  class EXCHANGE_API ProE
903  {
904  public:
907  enum class SessionColor
908  {
910  LastCreoVersion,
912  ExchangeDefault,
915  UserDefined
916  };
917 
920  enum class FamilyTable
921  {
923  BRepOnly,
925  BRepOrTessellation,
927  BRepOrTessellationOrGeneric
928  };
929 
933  {
935  On,
937  Off,
939  AsDatum,
940  };
941 
942  private:
944  ProE();
945  };
946 
948  class EXCHANGE_API U3D
949  {
950  public:
953  enum class Version
954  {
955  ECMA1,
956  ECMA3
957  };
958 
959  private:
961  U3D();
962  };
963 
965  class EXCHANGE_API Configuration : public HPS::Sprocket
966  {
967  public:
969  Configuration();
970 
973  Configuration(char const * in_name);
974 
979  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
980 
984  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
985 
988  Configuration(Configuration const & in_configuration);
989 
993  Configuration(Configuration && in_that);
994 
998  Configuration & operator=(Configuration && in_that);
999 
1000  virtual ~Configuration();
1001 
1002  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
1003 
1004 
1007  void Set(Configuration const & in_kit);
1008 
1011  void Show(Configuration & out_kit) const;
1012 
1016  Configuration & operator=(Configuration const & in_kit);
1017 
1020  bool Empty() const;
1021 
1025  bool Equals(Configuration const & in_kit) const;
1026 
1030  bool operator==(Configuration const & in_kit) const;
1031 
1035  bool operator!=(Configuration const & in_kit) const;
1036 
1037 
1040  HPS::UTF8 GetName() const;
1041 
1044  ConfigurationArray GetSubconfigurations() const;
1045  };
1046 
1048  class EXCHANGE_API File
1049  {
1050  public:
1053  enum class Format
1054  {
1055  Unsupported,
1056  ACIS,
1057  CADDS,
1058  CATIAV4,
1059  CATIAV5,
1060  CGR,
1061  COLLADA,
1062  CreoProE,
1063  IDEAS,
1064  IFC,
1065  IGES,
1066  Inventor,
1067  JT,
1068  KeyholeMarkupLanguage,
1069  LatticeXVL,
1070  OneSpaceDesigner,
1071  Parasolid,
1072  PDF,
1073  PRC,
1074  Rhino,
1075  NXUnigraphics,
1076  SolidEdge,
1077  SolidWorks,
1078  STEP,
1079  StereoLithography,
1080  ThreeDStudioMax,
1081  ThreeDXML,
1082  Universal3D,
1083  VDAFS,
1084  VRML,
1085  WavefrontObject,
1086  };
1087 
1089  static Format GetFormat(char const * in_file_name);
1090 
1094  static ConfigurationArray GetConfigurations(char const * in_file_name);
1095 
1107  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);
1108 
1114  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1115 
1122  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1123 
1130  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1131 
1132 
1139  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1140 
1145  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1146 
1151  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1152 
1157  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1158 
1163  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1164 
1170  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1171 
1177  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1178 
1185  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1186 
1193  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1194 
1198  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1199 
1204  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1205 
1209  static ExportNotifier ExportPRC(KeyPath const & in_source);
1210 
1215  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1216 
1221  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1222 
1227  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1228 
1232  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1233 
1238  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1239 
1240  private:
1242  File();
1243  };
1244 
1246  class EXCHANGE_API ImportOptionsKit : public HPS::Sprocket
1247  {
1248  public:
1250  ImportOptionsKit();
1251 
1254  ImportOptionsKit(ImportOptionsKit const & in_kit);
1255 
1259  ImportOptionsKit(ImportOptionsKit && in_that);
1260 
1264  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1265 
1266  virtual ~ImportOptionsKit();
1267 
1268  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1269 
1273  static ImportOptionsKit GetDefault();
1274 
1277  void Set(ImportOptionsKit const & in_kit);
1278 
1281  void Show(ImportOptionsKit & out_kit) const;
1282 
1286  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1287 
1290  bool Empty() const;
1291 
1295  bool Equals(ImportOptionsKit const & in_kit) const;
1296 
1300  bool operator==(ImportOptionsKit const & in_kit) const;
1301 
1305  bool operator!=(ImportOptionsKit const & in_kit) const;
1306 
1307 
1313  ImportOptionsKit & SetBRepData(bool in_state);
1314 
1320  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1321 
1327  ImportOptionsKit & SetSolids(bool in_state);
1328 
1334  ImportOptionsKit & SetSurfaces(bool in_state);
1335 
1341  ImportOptionsKit & SetWireframes(bool in_state);
1342 
1348  ImportOptionsKit & SetPMI(bool in_state);
1349 
1356  ImportOptionsKit & SetAttributes(bool in_state);
1357 
1363  ImportOptionsKit & SetHiddenObjects(bool in_state);
1364 
1370  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1371 
1377  ImportOptionsKit & SetActiveFilter(bool in_state);
1378 
1384  ImportOptionsKit & SetDefaultUnits(Units in_units);
1385 
1392  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1393 
1399  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1400 
1406  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1407 
1415  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1416 
1422  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1423 
1430  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1431 
1439  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1440 
1446  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1447 
1453  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1454 
1460  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1461 
1466  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1467 
1474  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1475 
1481  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1482 
1491  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1492 
1501  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1502 
1508  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1509 
1514  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1515 
1520  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1521 
1527  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1528 
1533  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1534 
1540  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1541 
1548  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1549 
1556  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1557 
1565  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1566 
1573  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1574 
1580  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1581 
1587  ImportOptionsKit & SetProECodePageName(char const * in_name);
1588 
1594  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1595 
1601  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1602 
1608  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1609 
1616  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
1617 
1624  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
1625 
1632  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
1633 
1640  ImportOptionsKit & SetProEHomeView(bool in_state);
1641 
1648  ImportOptionsKit & SetProEExplodedViews(bool in_state);
1649 
1656  ImportOptionsKit & SetProEDatum(bool in_state);
1657 
1658 
1665  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
1666 
1673  ImportOptionsKit & SetProESkeletons(bool in_state);
1674 
1681  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
1682 
1688  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
1689 
1695  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
1696 
1702  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
1703 
1709  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
1710 
1716  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
1717 
1723  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
1724 
1731  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
1732 
1738  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
1739 
1745  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
1746 
1753  ImportOptionsKit & SetIFCEdges(bool in_state);
1754 
1760  ImportOptionsKit & SetIFCMetadata(bool in_state);
1761 
1767  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
1768 
1774  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
1775 
1781  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
1782 
1788  ImportOptionsKit & SetIGESSewingTolerance(double in_tolerance);
1789 
1793  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
1794 
1806  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
1807 
1819  ImportOptionsKit & SetMode(ImportMode in_mode);
1820 
1830  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
1831 
1839  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
1840 
1847  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
1848 
1849 
1853  ImportOptionsKit & UnsetBRepData();
1854 
1857  ImportOptionsKit & UnsetBRepMode();
1858 
1861  ImportOptionsKit & UnsetSolids();
1862 
1865  ImportOptionsKit & UnsetSurfaces();
1866 
1869  ImportOptionsKit & UnsetWireframes();
1870 
1873  ImportOptionsKit & UnsetPMI();
1874 
1877  ImportOptionsKit & UnsetAttributes();
1878 
1881  ImportOptionsKit & UnsetHiddenObjects();
1882 
1885  ImportOptionsKit & UnsetConstructionAndReferences();
1886 
1889  ImportOptionsKit & UnsetActiveFilter();
1890 
1893  ImportOptionsKit & UnsetDefaultUnits();
1894 
1897  ImportOptionsKit & UnsetPMISubstitutionFont();
1898 
1901  ImportOptionsKit & UnsetPMIPrecision();
1902 
1905  ImportOptionsKit & UnsetPMIDefaultUnits();
1906 
1909  ImportOptionsKit & UnsetPMIDefaultColor();
1910 
1913  ImportOptionsKit & UnsetTessellationLevel();
1914 
1917  ImportOptionsKit & UnsetTessellationAccuracy();
1918 
1921  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
1922 
1925  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
1926 
1929  ImportOptionsKit & UnsetTextureDirectories();
1930 
1933  ImportOptionsKit & UnsetSearchDirectories();
1934 
1937  ImportOptionsKit & UnsetSearchDirectoriesByFile();
1938 
1941  ImportOptionsKit & UnsetConfiguration();
1942 
1945  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
1946 
1949  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
1950 
1953  ImportOptionsKit & UnsetCatiaV5Cache();
1954 
1957  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
1958 
1961  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
1962 
1965  ImportOptionsKit & UnsetProECodePageName();
1966 
1969  ImportOptionsKit & UnsetProEDimensionTolerance();
1970 
1973  ImportOptionsKit & UnsetProESubpartPMI();
1974 
1977  ImportOptionsKit & UnsetProESessionColor();
1978 
1981  ImportOptionsKit & UnsetProEDatum();
1982 
1985  ImportOptionsKit & UnsetProEHomeView();
1986 
1989  ImportOptionsKit & UnsetProEExplodedViews();
1990 
1993  ImportOptionsKit & UnsetProEMissingBoolean();
1994 
1997  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
1998 
2001  ImportOptionsKit & UnsetProEFamilyTreeSource();
2002 
2005  ImportOptionsKit & UnsetProEConstructionEntities();
2006 
2009  ImportOptionsKit & UnsetProESkeletons();
2010 
2013  ImportOptionsKit & UnsetSTEPNamePreference();
2014 
2017  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2018 
2021  ImportOptionsKit & UnsetSTEPCodePageName();
2022 
2025  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2026 
2029  ImportOptionsKit & UnsetSTEPOrientationHealing();
2030 
2033  ImportOptionsKit & UnsetSTEPValidationProperties();
2034 
2037  ImportOptionsKit & UnsetIFCCodePageName();
2038 
2041  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2042 
2045  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2046 
2049  ImportOptionsKit & UnsetIFCFaceOptimization();
2050 
2053  ImportOptionsKit & UnsetIFCEdges();
2054 
2057  ImportOptionsKit & UnsetIFCMetadata();
2058 
2061  ImportOptionsKit & UnsetPDF3DStreamIndex();
2062 
2065  ImportOptionsKit & UnsetJTTessellationLevel();
2066 
2069  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2070 
2073  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2074 
2077  ImportOptionsKit & UnsetIGESSewingTolerance();
2078 
2081  ImportOptionsKit & UnsetLocation();
2082 
2085  ImportOptionsKit & UnsetMode();
2086 
2089  ImportOptionsKit & UnsetIncrementalComponentPaths();
2090 
2093  ImportOptionsKit & UnsetEverything();
2094 
2095 
2100  bool ShowBRepData(bool & out_state) const;
2101 
2105  bool ShowBRepMode(BRepMode & out_mode) const;
2106 
2110  bool ShowSolids(bool & out_state) const;
2111 
2115  bool ShowSurfaces(bool & out_state) const;
2116 
2120  bool ShowWireframes(bool & out_state) const;
2121 
2125  bool ShowPMI(bool & out_state) const;
2126 
2130  bool ShowAttributes(bool & out_state) const;
2131 
2135  bool ShowHiddenObjects(bool & out_state) const;
2136 
2140  bool ShowConstructionAndReferences(bool & out_state) const;
2141 
2145  bool ShowActiveFilter(bool & out_state) const;
2146 
2150  bool ShowDefaultUnits(Units & out_units) const;
2151 
2156  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2157 
2161  bool ShowPMIPrecision(size_t & out_precision) const;
2162 
2166  bool ShowPMIDefaultUnits(Units & out_units) const;
2167 
2172  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2173 
2181  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2182 
2187  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2188 
2192  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2193 
2197  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2198 
2202  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2203 
2209  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2210 
2214  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2215 
2219  bool ShowConfiguration(UTF8Array & out_configuration) const;
2220 
2224  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2225 
2229  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2230 
2235  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2236 
2241  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2242 
2246  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2247 
2251  bool ShowProECodePageName(UTF8 & out_name) const;
2252 
2256  bool ShowProEDimensionTolerance(bool & out_state) const;
2257 
2261  bool ShowProESubpartPMI(bool & out_state) const;
2262 
2266  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2267 
2271  bool ShowProEDatum(bool & out_state) const;
2272 
2276  bool ShowProEHomeView(bool & out_state) const;
2277 
2281  bool ShowProEExplodedViews(bool & out_state) const;
2282 
2286  bool ShowProEMissingBoolean(bool & out_state) const;
2287 
2291  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
2292 
2296  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
2297 
2301  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
2302 
2306  bool ShowProESkeletons(bool & out_state) const;
2307 
2311  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2312 
2316  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2317 
2321  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2322 
2326  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2327 
2331  bool ShowSTEPOrientationHealing(bool & out_state) const;
2332 
2336  bool ShowSTEPValidationProperties(bool & out_state) const;
2337 
2341  bool ShowIFCCodePageName(UTF8 & out_name) const;
2342 
2346  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2347 
2351  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2352 
2356  bool ShowIFCFaceOptimization(bool & out_state) const;
2357 
2361  bool ShowIFCEdges(bool & out_state) const;
2362 
2366  bool ShowIFCMetadata(bool & out_state) const;
2367 
2371  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2372 
2376  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2377 
2381  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
2382 
2386  bool ShowIGESSewingTolerance(double & out_tolerance) const;
2387 
2391  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2392 
2397  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2398 
2402  bool ShowMode(ImportMode & out_mode) const;
2403 
2407  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
2408  };
2409 
2411  class EXCHANGE_API Translation
2412  {
2413  public:
2416  enum class Healing
2417  {
2418  Off,
2419  On,
2420  OnlyIfNotParasolid,
2421  };
2422 
2425  enum class AccurateEdges
2426  {
2427  Off,
2428  On,
2429  OnlyIfNotParasolid,
2430  };
2431 
2434  enum class Simplification
2435  {
2436  Off,
2437  On,
2438  OnlyIfNotParasolid,
2439  };
2440 
2443  enum class Merging
2444  {
2445  Off,
2446  On,
2447  OnlyIfNotParasolid,
2448  };
2449 
2450  private:
2452  Translation();
2453  };
2454 
2456  class EXCHANGE_API TranslationOptionsKit : public HPS::Sprocket
2457  {
2458  public:
2461 
2465 
2470 
2474  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2475 
2476  virtual ~TranslationOptionsKit();
2477 
2478  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2479 
2483  static TranslationOptionsKit GetDefault();
2484 
2487  void Set(TranslationOptionsKit const & in_kit);
2488 
2491  void Show(TranslationOptionsKit & out_kit) const;
2492 
2496  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2497 
2500  bool Empty() const;
2501 
2505  bool Equals(TranslationOptionsKit const & in_kit) const;
2506 
2510  bool operator==(TranslationOptionsKit const & in_kit) const;
2511 
2515  bool operator!=(TranslationOptionsKit const & in_kit) const;
2516 
2522  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2523 
2529  TranslationOptionsKit & SetTessellation(bool in_state);
2530 
2536  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2537 
2541  TranslationOptionsKit & SetApplication(char const * in_name);
2542 
2546  TranslationOptionsKit & SetVersion(char const * in_version);
2547 
2551  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2552 
2556  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2557 
2561  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
2562 
2566  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
2567 
2572  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
2573 
2577  TranslationOptionsKit & SetDisjointFaces(bool in_state);
2578 
2581  TranslationOptionsKit & UnsetSolidsAsFaces();
2582 
2585  TranslationOptionsKit & UnsetTessellation();
2586 
2589  TranslationOptionsKit & UnsetHiddenObjects();
2590 
2593  TranslationOptionsKit & UnsetApplication();
2594 
2597  TranslationOptionsKit & UnsetVersion();
2598 
2601  TranslationOptionsKit & UnsetHealing();
2602 
2605  TranslationOptionsKit & UnsetAccurateEdges();
2606 
2609  TranslationOptionsKit & UnsetSimplification();
2610 
2613  TranslationOptionsKit & UnsetEntityMerging();
2614 
2617  TranslationOptionsKit & UnsetSewing();
2618 
2621  TranslationOptionsKit & UnsetDisjointFaces();
2622 
2625  TranslationOptionsKit & UnsetEverything();
2626 
2627 
2631  bool ShowSolidsAsFaces(bool & out_state) const;
2632 
2636  bool ShowTessellation(bool & out_state) const;
2637 
2641  bool ShowHiddenObjects(bool & out_state) const;
2642 
2646  bool ShowApplication(UTF8 & out_name) const;
2647 
2651  bool ShowVersion(UTF8 & out_version) const;
2652 
2656  bool ShowHealing(Translation::Healing & out_healing) const;
2657 
2661  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
2662 
2666  bool ShowSimplification(Translation::Simplification & out_simplification) const;
2667 
2671  bool ShowEntityMerging(Translation::Merging & out_merging) const;
2672 
2677  bool ShowSewing(bool & out_state, double & out_tolerance) const;
2678 
2682  bool ShowDisjointFaces(bool & out_state) const;
2683  };
2684 
2685 
2686 
2691  class EXCHANGE_API ModelFileImportOptionsKit : public HPS::Sprocket
2692  {
2693  public:
2696 
2700 
2705 
2709  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
2710 
2711  virtual ~ModelFileImportOptionsKit();
2712 
2713  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
2714 
2718  static ModelFileImportOptionsKit GetDefault();
2719 
2722  void Set(ModelFileImportOptionsKit const & in_kit);
2723 
2726  void Show(ModelFileImportOptionsKit & out_kit) const;
2727 
2731  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
2732 
2735  bool Empty() const;
2736 
2740  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
2741 
2745  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
2746 
2750  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
2751 
2752 
2758  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
2759 
2766  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
2767 
2775  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
2776 
2782  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
2783 
2789  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
2790 
2797  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
2798 
2802  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2803 
2816  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2817 
2818 
2821  ModelFileImportOptionsKit & UnsetTessellationLevel();
2822 
2825  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
2826 
2829  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
2830 
2833  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2834 
2837  ModelFileImportOptionsKit & UnsetIFCEdges();
2838 
2841  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
2842 
2845  ModelFileImportOptionsKit & UnsetLocation();
2846 
2849  ModelFileImportOptionsKit & UnsetEverything();
2850 
2851 
2859  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2860 
2865  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2866 
2870  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2871 
2875  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2876 
2880  bool ShowIFCEdges(bool & out_state) const;
2881 
2885  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2886 
2891  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2892  };
2893 
2894 
2896  class EXCHANGE_API ExportACISOptionsKit : public HPS::Sprocket
2897  {
2898  public:
2901 
2905 
2909 
2910  virtual ~ExportACISOptionsKit();
2911 
2912  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
2913 
2917  static ExportACISOptionsKit GetDefault();
2918 
2921  void Set(ExportACISOptionsKit const & in_kit);
2922 
2925  void Show(ExportACISOptionsKit & out_kit) const;
2926 
2930  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
2931 
2935  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
2936 
2939  bool Empty() const;
2940 
2944  bool Equals(ExportACISOptionsKit const & in_kit) const;
2945 
2949  bool operator==(ExportACISOptionsKit const & in_kit) const;
2950 
2954  bool operator!=(ExportACISOptionsKit const & in_kit) const;
2955 
2956 
2962  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
2963 
2969  ExportACISOptionsKit & SetBinary(bool in_state);
2970 
2971 
2974  ExportACISOptionsKit & UnsetMillimeterUnits();
2975 
2978  ExportACISOptionsKit & UnsetBinary();
2979 
2982  ExportACISOptionsKit & UnsetEverything();
2983 
2984 
2988  bool ShowMillimeterUnits(bool & out_state) const;
2989 
2993  bool ShowBinary(bool & out_state) const;
2994  };
2995 
2997  class EXCHANGE_API ExportIGESOptionsKit : public HPS::Sprocket
2998  {
2999  public:
3002 
3006 
3010 
3011  virtual ~ExportIGESOptionsKit();
3012 
3013  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
3014 
3018  static ExportIGESOptionsKit GetDefault();
3019 
3022  void Set(ExportIGESOptionsKit const & in_kit);
3023 
3026  void Show(ExportIGESOptionsKit & out_kit) const;
3027 
3031  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
3032 
3036  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
3037 
3040  bool Empty() const;
3041 
3045  bool Equals(ExportIGESOptionsKit const & in_kit) const;
3046 
3050  bool operator==(ExportIGESOptionsKit const & in_kit) const;
3051 
3055  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
3056 
3057 
3063  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3064 
3070  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
3071 
3077  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
3078 
3084  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
3085 
3091  ExportIGESOptionsKit & SetTessellation(bool in_state);
3092 
3096  ExportIGESOptionsKit & SetApplication(char const * in_name);
3097 
3101  ExportIGESOptionsKit & SetVersion(char const * in_version);
3102 
3103 
3106  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
3107 
3110  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
3111 
3114  ExportIGESOptionsKit & UnsetSolidsAsFaces();
3115 
3118  ExportIGESOptionsKit & UnsetHiddenObjects();
3119 
3122  ExportIGESOptionsKit & UnsetTessellation();
3123 
3126  ExportIGESOptionsKit & UnsetApplication();
3127 
3130  ExportIGESOptionsKit & UnsetVersion();
3131 
3134  ExportIGESOptionsKit & UnsetEverything();
3135 
3136 
3140  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3141 
3145  bool ShowFacetedAsWireframe(bool & out_state) const;
3146 
3150  bool ShowSolidsAsFaces(bool & out_state) const;
3151 
3155  bool ShowHiddenObjects(bool & out_state) const;
3156 
3160  bool ShowTessellation(bool & out_state) const;
3161 
3165  bool ShowApplication(UTF8 & out_name) const;
3166 
3170  bool ShowVersion(UTF8 & out_version) const;
3171  };
3172 
3174  class EXCHANGE_API ExportJTOptionsKit : public HPS::Sprocket
3175  {
3176  public:
3179 
3182  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
3183 
3187 
3188  virtual ~ExportJTOptionsKit();
3189 
3190  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
3191 
3195  static ExportJTOptionsKit GetDefault();
3196 
3199  void Set(ExportJTOptionsKit const & in_kit);
3200 
3203  void Show(ExportJTOptionsKit & out_kit) const;
3204 
3208  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
3209 
3213  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
3214 
3217  bool Empty() const;
3218 
3222  bool Equals(ExportJTOptionsKit const & in_kit) const;
3223 
3227  bool operator==(ExportJTOptionsKit const & in_kit) const;
3228 
3232  bool operator!=(ExportJTOptionsKit const & in_kit) const;
3233 
3234 
3240  ExportJTOptionsKit & SetContent(JT::Content in_content);
3241 
3247  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
3248 
3254  ExportJTOptionsKit & SetPMI(bool in_state);
3255 
3256 
3259  ExportJTOptionsKit & UnsetContent();
3260 
3263  ExportJTOptionsKit & UnsetHiddenObjects();
3264 
3267  ExportJTOptionsKit & UnsetPMI();
3268 
3271  ExportJTOptionsKit & UnsetEverything();
3272 
3273 
3277  bool ShowContent(JT::Content & out_content) const;
3278 
3282  bool ShowHiddenObjects(bool & out_state) const;
3283 
3287  bool ShowPMI(bool & out_state) const;
3288  };
3289 
3291  class EXCHANGE_API ExportParasolidOptionsKit : public HPS::Sprocket
3292  {
3293  public:
3296 
3300 
3304 
3305  virtual ~ExportParasolidOptionsKit();
3306 
3307  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
3308 
3312  static ExportParasolidOptionsKit GetDefault();
3313 
3316  void Set(ExportParasolidOptionsKit const & in_kit);
3317 
3320  void Show(ExportParasolidOptionsKit & out_kit) const;
3321 
3325  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
3326 
3330  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
3331 
3334  bool Empty() const;
3335 
3339  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
3340 
3344  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
3345 
3349  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
3350 
3351 
3357  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
3358 
3364  ExportParasolidOptionsKit & SetTessellation(bool in_state);
3365 
3371  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
3372 
3376  ExportParasolidOptionsKit & SetApplication(char const * in_name);
3377 
3381  ExportParasolidOptionsKit & SetVersion(char const * in_version);
3382 
3383 
3386  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
3387 
3390  ExportParasolidOptionsKit & UnsetTessellation();
3391 
3394  ExportParasolidOptionsKit & UnsetHiddenObjects();
3395 
3398  ExportParasolidOptionsKit & UnsetApplication();
3399 
3402  ExportParasolidOptionsKit & UnsetVersion();
3403 
3406  ExportParasolidOptionsKit & UnsetEverything();
3407 
3408 
3412  bool ShowSolidsAsFaces(bool & out_state) const;
3413 
3417  bool ShowTessellation(bool & out_state) const;
3418 
3422  bool ShowHiddenObjects(bool & out_state) const;
3423 
3427  bool ShowApplication(UTF8 & out_name) const;
3428 
3432  bool ShowVersion(UTF8 & out_version) const;
3433  };
3434 
3436  class EXCHANGE_API ExportPRCOptionsKit : public HPS::Sprocket
3437  {
3438  public:
3441 
3444  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3445 
3449 
3450  virtual ~ExportPRCOptionsKit();
3451 
3452  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
3453 
3457  static ExportPRCOptionsKit GetDefault();
3458 
3461  void Set(ExportPRCOptionsKit const & in_kit);
3462 
3465  void Show(ExportPRCOptionsKit & out_kit) const;
3466 
3470  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
3471 
3475  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
3476 
3479  bool Empty() const;
3480 
3484  bool Equals(ExportPRCOptionsKit const & in_kit) const;
3485 
3489  bool operator==(ExportPRCOptionsKit const & in_kit) const;
3490 
3494  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
3495 
3496 
3502  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
3503 
3510  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
3511 
3517  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
3518 
3524  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
3525 
3530  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3531 
3537  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
3538 
3539 
3542  ExportPRCOptionsKit & UnsetTessellationCompression();
3543 
3546  ExportPRCOptionsKit & UnsetBRepCompression();
3547 
3550  ExportPRCOptionsKit & UnsetBRepRemoval();
3551 
3554  ExportPRCOptionsKit & UnsetAttributeRemoval();
3555 
3558  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
3559 
3562  ExportPRCOptionsKit & UnsetEverything();
3563 
3564 
3568  bool ShowTessellationCompression(bool & out_state) const;
3569 
3573  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
3574 
3578  bool ShowBRepRemoval(bool & out_state) const;
3579 
3583  bool ShowAttributeRemoval(bool & out_state) const;
3584 
3588  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3589  };
3590 
3592  class EXCHANGE_API ExportSTEPOptionsKit : public HPS::Sprocket
3593  {
3594  public:
3597 
3601 
3605 
3606  virtual ~ExportSTEPOptionsKit();
3607 
3608  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
3609 
3613  static ExportSTEPOptionsKit GetDefault();
3614 
3617  void Set(ExportSTEPOptionsKit const & in_kit);
3618 
3621  void Show(ExportSTEPOptionsKit & out_kit) const;
3622 
3626  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
3627 
3631  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
3632 
3635  bool Empty() const;
3636 
3640  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
3641 
3645  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
3646 
3650  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
3651 
3652 
3658  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
3659 
3665  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3666 
3672  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
3673 
3679  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
3680 
3684  ExportSTEPOptionsKit & SetApplication(char const * in_name);
3685 
3689  ExportSTEPOptionsKit & SetVersion(char const * in_version);
3690 
3694  ExportSTEPOptionsKit & SetPMI(bool in_state);
3695 
3699  ExportSTEPOptionsKit & SetCurves(bool in_state);
3700 
3704  ExportSTEPOptionsKit & SetAttributes(bool in_state);
3705 
3706 
3709  ExportSTEPOptionsKit & UnsetFormat();
3710 
3713  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
3714 
3717  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
3718 
3721  ExportSTEPOptionsKit & UnsetNameShortening();
3722 
3725  ExportSTEPOptionsKit & UnsetApplication();
3726 
3729  ExportSTEPOptionsKit & UnsetVersion();
3730 
3733  ExportSTEPOptionsKit & UnsetPMI();
3734 
3737  ExportSTEPOptionsKit & UnsetCurves();
3738 
3741  ExportSTEPOptionsKit & UnsetAttributes();
3742 
3745  ExportSTEPOptionsKit & UnsetEverything();
3746 
3747 
3751  bool ShowFormat(STEP::Format & out_format) const;
3752 
3756  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3757 
3761  bool ShowFacetedAsWireframe(bool & out_state) const;
3762 
3766  bool ShowNameShortening(bool & out_state) const;
3767 
3771  bool ShowApplication(UTF8 & out_name) const;
3772 
3776  bool ShowVersion(UTF8 & out_version) const;
3777 
3781  bool ShowPMI(bool & out_state) const;
3782 
3786  bool ShowCurves(bool & out_state) const;
3787 
3791  bool ShowAttributes(bool & out_state) const;
3792  };
3793 
3795  class EXCHANGE_API ExportSTLOptionsKit : public HPS::Sprocket
3796  {
3797  public:
3800 
3803  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
3804 
3808 
3809  virtual ~ExportSTLOptionsKit();
3810 
3811  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
3812 
3816  static ExportSTLOptionsKit GetDefault();
3817 
3820  void Set(ExportSTLOptionsKit const & in_kit);
3821 
3824  void Show(ExportSTLOptionsKit & out_kit) const;
3825 
3829  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
3830 
3834  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
3835 
3838  bool Empty() const;
3839 
3843  bool Equals(ExportSTLOptionsKit const & in_kit) const;
3844 
3848  bool operator==(ExportSTLOptionsKit const & in_kit) const;
3849 
3853  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
3854 
3855 
3861  ExportSTLOptionsKit & SetBinary(bool in_state);
3862 
3868  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3869 
3876  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3877 
3883  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
3884 
3890  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
3891 
3898  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
3899 
3900 
3903  ExportSTLOptionsKit & UnsetBinary();
3904 
3907  ExportSTLOptionsKit & UnsetTessellationLevel();
3908 
3911  ExportSTLOptionsKit & UnsetTessellationAccuracy();
3912 
3915  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
3916 
3919  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
3920 
3923  ExportSTLOptionsKit & UnsetEverything();
3924 
3925 
3929  bool ShowBinary(bool & out_state) const;
3930 
3938  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3939 
3943  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
3944 
3948  bool ShowCurrentTessellationRetention(bool & out_state) const;
3949 
3953  bool ShowMaximumEdgeLength(double & out_length) const;
3954  };
3955 
3957  class EXCHANGE_API ExportU3DOptionsKit : public HPS::Sprocket
3958  {
3959  public:
3962 
3965  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
3966 
3970 
3971  virtual ~ExportU3DOptionsKit();
3972 
3973  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
3974 
3978  static ExportU3DOptionsKit GetDefault();
3979 
3982  void Set(ExportU3DOptionsKit const & in_kit);
3983 
3986  void Show(ExportU3DOptionsKit & out_kit) const;
3987 
3991  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
3992 
3996  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
3997 
4000  bool Empty() const;
4001 
4005  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4006 
4010  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4011 
4015  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4016 
4017 
4023  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4024 
4029  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4030 
4031 
4034  ExportU3DOptionsKit & UnsetVersion();
4035 
4038  ExportU3DOptionsKit & UnsetCompression();
4039 
4042  ExportU3DOptionsKit & UnsetEverything();
4043 
4044 
4048  bool ShowVersion(U3D::Version & out_version) const;
4049 
4053  bool ShowCompression(unsigned char & out_level) const;
4054  };
4055 
4057  class EXCHANGE_API ExportXMLOptionsKit : public HPS::Sprocket
4058  {
4059  public:
4062 
4065  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4066 
4070 
4071  virtual ~ExportXMLOptionsKit();
4072 
4073  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
4074 
4078  static ExportXMLOptionsKit GetDefault();
4079 
4082  void Set(ExportXMLOptionsKit const & in_kit);
4083 
4086  void Show(ExportXMLOptionsKit & out_kit) const;
4087 
4091  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4092 
4096  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4097 
4100  bool Empty() const;
4101 
4105  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4106 
4110  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4111 
4115  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4116 
4117 
4123  ExportXMLOptionsKit & SetMetadata(bool in_state);
4124 
4130  ExportXMLOptionsKit & SetTransformations(bool in_state);
4131 
4137  ExportXMLOptionsKit & SetMaterials(bool in_state);
4138 
4139 
4142  ExportXMLOptionsKit & UnsetMetadata();
4143 
4146  ExportXMLOptionsKit & UnsetTransformations();
4147 
4150  ExportXMLOptionsKit & UnsetMaterials();
4151 
4154  ExportXMLOptionsKit & UnsetEverything();
4155 
4156 
4160  bool ShowMetadata(bool & out_state) const;
4161 
4165  bool ShowTransformations(bool & out_state) const;
4166 
4170  bool ShowMaterials(bool & out_state) const;
4171  };
4172 
4174  class EXCHANGE_API TessellationOptionsKit : public HPS::Sprocket
4175  {
4176  public:
4179 
4183 
4187 
4188  virtual ~TessellationOptionsKit();
4189 
4190  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
4191 
4195  static TessellationOptionsKit GetDefault();
4196 
4199  void Set(TessellationOptionsKit const & in_kit);
4200 
4203  void Show(TessellationOptionsKit & out_kit) const;
4204 
4208  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
4209 
4213  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
4214 
4217  bool Empty() const;
4218 
4222  bool Equals(TessellationOptionsKit const & in_kit) const;
4223 
4227  bool operator==(TessellationOptionsKit const & in_kit) const;
4228 
4232  bool operator!=(TessellationOptionsKit const & in_kit) const;
4233 
4234 
4238  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
4239 
4246  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4247 
4253  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
4254 
4258  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
4259 
4263  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
4264 
4265 
4268  TessellationOptionsKit & UnsetLevel();
4269 
4272  TessellationOptionsKit & UnsetAccuracy();
4273 
4276  TessellationOptionsKit & UnsetUVPointPreservation();
4277 
4280  TessellationOptionsKit & UnsetMaximumEdgeLength();
4281 
4284  TessellationOptionsKit & UnsetEverything();
4285 
4286 
4294  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4295 
4300  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
4301 
4305  bool ShowUVPointPreservation(bool & out_state) const;
4306 
4310  bool ShowMaximumEdgeLength(double & out_length) const;
4311  };
4312 
4318  class EXCHANGE_API CommonMeasurementOperator : public Operator
4319  {
4320  public:
4321  enum class Tags
4322  {
4323  Name = 0,
4324  MeasurementType,
4325  Radius,
4326  Inverted,
4327  VectorX,
4328  VectorY,
4329  VectorZ,
4330  };
4331 
4333 
4334  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4335 
4337  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
4338 
4339  virtual void OnViewAttached() OVERRIDE;
4340  virtual void OnViewDetached() OVERRIDE;
4341 
4342  Exchange::CADModel GetCADModel() const;
4343  void SetCADModel(Exchange::CADModel const & in_cad_model);
4344 
4346  size_t GetPrecision() const;
4347 
4350  void SetPrecision(size_t in_precision);
4351 
4353  MaterialMappingKit GetMaterial() const;
4354 
4357  void SetMaterial(MaterialMappingKit const & in_material_mapping);
4358 
4360  TextAttributeKit GetTextAttributes() const;
4361 
4364  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
4365 
4367  SegmentKey GetMeasurementSegment() const;
4368 
4370  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
4371 
4372  /* Deletes all measurements */
4373  void DeleteMeasurements();
4374 
4375  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
4376  {
4377  public:
4380  {
4381  channel = GetClassID();
4382  consumable = false;
4383  }
4384 
4385  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
4386  {
4387  channel = GetClassID();
4388  consumable = false;
4389  measurement_key = in_measurement_key;
4390  view = in_view;
4391  }
4392 
4395  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
4396  {
4397  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
4398  {
4399  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
4400  measurement_key = that.measurement_key;
4401  view = that.view;
4402  }
4403  else
4404  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4405  }
4406 
4408 
4411  Event * Clone() const
4412  {
4413  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
4414  return new_event;
4415  }
4416 
4417  Key measurement_key;
4418  View view;
4419  };
4420 
4421  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
4422  {
4423  public:
4426  {
4427  channel = GetClassID();
4428  consumable = false;
4429  }
4430 
4431  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
4432  {
4433  channel = GetClassID();
4434  consumable = false;
4435  measurement_name = in_measurement_name;
4436  view = in_view;
4437  }
4438 
4441  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
4442  {
4443  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
4444  {
4445  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
4446  measurement_name = that.measurement_name;
4447  view = that.view;
4448  }
4449  else
4450  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4451  }
4452 
4454 
4457  Event * Clone() const
4458  {
4459  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
4460  return new_event;
4461  }
4462 
4463  UTF8 measurement_name;
4464  View view;
4465  };
4466 
4467  protected:
4468  Exchange::CADModel cad_model;
4469  size_t measurement_precision;
4470  UTF8 units;
4471  MaterialMappingKit materials;
4472  TextAttributeKit text_attributes;
4473  SegmentKey measurement_segment;
4474  GlyphDefinition left_arrow;
4475  GlyphDefinition right_arrow;
4476  SelectionOptionsKit selection_options;
4477  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
4478  Vector camera_direction;
4479  PortfolioKey portfolio;
4480  SegmentKey style_segment;
4481  HighlightOptionsKit highlight_options;
4482 
4483  static size_t length_measurement_index;
4484  static size_t radius_measurement_index;
4485  static size_t distance_measurement_index;
4486  static size_t angle_measurement_index;
4487 
4488  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
4489  void GetUnits();
4490  void SetGlyphColor();
4491  void GetCameraDirection();
4492  void SetupConstructionSegment();
4493  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
4494  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
4495  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
4496  float GetModelScale(Exchange::Component const & component);
4497  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
4498  };
4499 
4552  {
4553  public:
4554  enum class MeasurementType
4555  {
4556  PointToPoint,
4557  EdgeAndRadius,
4558  FeatureToFeature,
4559  FaceAngle,
4560  };
4561 
4563 
4564  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4565 
4567  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
4568 
4569  virtual void OnViewAttached() OVERRIDE;
4570  virtual void OnViewDetached() OVERRIDE;
4571 
4576  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
4577 
4581  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
4582 
4590  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
4591 
4595  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
4596 
4597  /* Sets the type of measurement to insert.
4598  * \param in_measurement_type The type of measurement to insert.*/
4599  void SetMeasurementType(MeasurementType in_measurement_type);
4600 
4603  MeasurementType GetMeasurementType();
4604 
4605  /* Whether measurable geometry should be highlighted when mousing over it
4606  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
4607  void SetMouseOverHighlighting(bool in_highlighting);
4608 
4609  /* Whether measurable geometry should be highlighted when mousing over it
4610  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
4611  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
4612  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
4613 
4614  /* Whether measurable geometry is highlighted when mousing over it
4615  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
4616  bool GetMouseOverHighlighting();
4617 
4618  /* Returns the highlight option kit currently used for mouse over highlighting.
4619  * \return the highlight option kit currently used for mouse over highlighting. */
4620  HighlightOptionsKit GetHighlightOptions();
4621 
4622  /* Whether a measurement is currently being inserted or edited.
4623  * \return <span class='code'>true</span> if a measurement is being inserted or manipulated, <span class='code'>false</span> otherwise. */
4624  bool IsMeasurementActive();
4625 
4626  private:
4627  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
4628  {
4629  Circle,
4630  Line,
4631  Generic,
4632  };
4633 
4634  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
4635  {
4636  public:
4637  Surface();
4638 
4639  enum class SurfaceType
4640  {
4641  Plane,
4642  ConeOrCylinder,
4643  Unsupported,
4644  };
4645 
4646  SurfaceType surface_type; //the type of surface being measured
4647  Point center; //the center point of the surface
4648  Vector normal; //the center line of surfaces of type Cylinder or Cone
4649  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
4650  ComponentPath path; //the component path to this surface
4651  };
4652 
4653  //bookkeeping
4654  MeasurementType measurement_type; //the type of measurement to be inserted
4655  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
4656  TouchID tracked_touch_id;
4657  SegmentKey current_measurement; //segment of the measurement being inserted / edited
4658  bool operator_active; //whether a measurement is in progress
4659  bool end_measurement; //whether we should end the current measurement
4660  CanvasArray canvases; //canvases related to the view where this operator is attached
4661 
4662  //measurement anchors
4663  size_t anchors; //valid for point-to-point and face-angle measurements
4664  bool anchors_in_place; //true if all the anchors have been placed
4665  Point first_click_position; //position of the first anchor
4666  Point second_click_position; //position of the second anchor
4667 
4668  //geometry for linear measurements
4669  MarkerKey anchor_one; //marker corresponding to the start of the measurement
4670  MarkerKey anchor_two; //marker corresponding to the end of the measurement
4671  LineKey distance_line; //a line representing the distance measured
4672  LineKey leader_line_one; //line connecting the first anchor point to the distance line
4673  LineKey leader_line_two; //line connecting the second anchor point to the distance line
4674  Point distance_point_one; //intersection of leader_line_one and distance_line
4675  Point distance_point_two; //intersection of leader_line_two and distance_line
4676  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
4677  TextKey text; //text representing the measurement and units
4678  UTF8 text_string; //the contents of the text
4679  Vector measurement_direction; //the direction of the measurement
4680  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
4681  Vector explicit_direction; //used if use_explicit_direction is true
4682 
4683  //geometry for radius measurement
4684  MarkerKey center_marker; //marker representing the center of the circle
4685  Point circle_center; //circle center
4686  float radius; //circle radius
4687 
4688  //edge specific data
4689  LineKey edge_line; //the edge being measured
4690  double edge_length; //length of the measured edge
4691  EdgeType edge_type; //the type of edge being measured
4692 
4693  //feature-to-feature specific data
4694  Surface surface_one; //data related to first selected surface
4695  Surface surface_two; //data related to second selected surface
4696  Plane measurement_plane; //the measurement plane
4697  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
4698 
4699  //angle specific data
4700  Vector leader_line_one_direction; //the direction of the first leader line
4701  Vector leader_line_two_direction; //the direction of the second leader line
4702  Vector first_face_normal; //the normal of the first selected face
4703  Vector second_face_normal; //the normal of the second selected face
4704  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'
4705  CircularArcKey measurement_arc; //an arc representing the measured angle
4706  LineKey line_to_leader_line; //line extending from one anchor to a leader line
4707  Vector mid_point_direction;
4708 
4709  //selection kits
4710  SelectionOptionsKit point_to_point_selection;
4711  SelectionOptionsKit edge_radius_selection;
4712  SelectionOptionsKit feature_to_feature_selection;
4713  SelectionOptionsKit angle_selection;
4714 
4715  //highlighting
4716  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
4717  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
4718  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
4719  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
4720  KeyPath highlighted_path; //highlighted_path
4721  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
4722  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
4723 
4724  //input handling
4725  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
4726  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
4727  bool InputUp(WindowKey & in_window);
4728  void ResetMeasurement();
4729 
4730  //inserting measurements
4731  void InsertPointToPointMeasurement(Point const & in_world_point);
4732  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
4733  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4734  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
4735  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4736  void InvertMeasuredAngle(WindowKey & in_window);
4737  void AdjustLineToCursor(Point const & cursor_position);
4738 
4739  //saving measurements
4740  void TagMeasurement();
4741  void TagPointToPointMeasurement();
4742  void TagEdgeMeasurement();
4743  void TagRadiusMeasurement();
4744  void TagGenericEdgeMeasurement();
4745  void TagFeatureToFeatureMeasurement();
4746  void TagAngleMeasurement();
4747 
4748  //restoring measurements
4749  void RestoreMeasurement(SegmentKey const & measurement_segment);
4750  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
4751  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
4752  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
4753  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
4754  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
4755  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
4756  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
4757 
4758  //topology functions
4759  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
4760  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
4761  void PlaneToCenterLineDistance();
4762  void PlaneToPlaneDistance();
4763  void LineToLineDistance();
4764  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);
4765  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
4766  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
4767  bool IsPlane(Exchange::Component const & face_component);
4768  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
4769  };
4770 
4771 private:
4773  Exchange();
4774 };
4775 
4776 }
4777 
4778 #endif
Definition: hps.h:6097
Definition: sprk_exchange.h:3436
Level
Definition: sprk_exchange.h:780
ConstructionEntities
Definition: sprk_exchange.h:932
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3190
Definition: sprk_exchange.h:43
Definition: sprk_exchange.h:883
Definition: sprk.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:269
Definition: sprk_exchange.h:1048
Definition: sprk_exchange.h:4318
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5606
Units
Definition: sprk_exchange.h:62
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2434
Definition: sprk.h:100
Definition: sprk_exchange.h:578
Version
Definition: sprk_exchange.h:953
Definition: sprk_exchange.h:2691
Definition: sprk_exchange.h:790
Definition: sprk_exchange.h:677
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4337
HPS::Type ObjectType() const
Definition: sprk_exchange.h:659
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4073
Definition: hps.h:1655
Format
Definition: sprk_exchange.h:870
HPS::Type ObjectType() const
Definition: sprk_exchange.h:705
Definition: sprk_exchange.h:4057
Definition: hps.h:43370
Format
Definition: sprk_exchange.h:1053
Definition: hps.h:7473
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3452
Type
Definition: sprk_exchange.h:771
Definition: hps.h:15390
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3013
Definition: sprk_exchange.h:441
Definition: sprk_exchange.h:525
Definition: sprk_exchange.h:296
HPS::Type ObjectType() const
Definition: sprk_exchange.h:422
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4567
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3307
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:4395
HPS::Type ObjectType() const
Definition: sprk_exchange.h:131
Definition: sprk_exchange.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3811
HPS::Type ObjectType() const
Definition: sprk_exchange.h:322
Definition: sprk_exchange.h:3174
Merging
Definition: sprk_exchange.h:2443
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2478
Field
Definition: sprk_exchange.h:860
Definition: hps.h:37952
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1002
Definition: sprk_exchange.h:2896
Definition: sprk_exchange.h:2456
Limit
Definition: sprk_exchange.h:795
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3608
TessellationLevel
Definition: sprk_exchange.h:842
Definition: sprk_exchange.h:766
Definition: sprk_exchange.h:3795
Definition: sprk_exchange.h:110
Definition: sprk_exchange.h:855
Definition: hps.h:4275
Definition: hps.h:6846
Definition: hps.h:42761
Definition: sprk_exchange.h:396
UnloadMode
Definition: sprk_exchange.h:79
Definition: hps.h:39745
Definition: hps.h:43157
AnnotationCaptureFitting
Definition: sprk_exchange.h:759
Definition: sprk_exchange.h:3957
Definition: sprk_exchange.h:828
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2912
Definition: hps.h:14804
Event * Clone() const
Definition: sprk_exchange.h:4457
intptr_t GetChannel() const
Definition: hps.h:6230
Definition: sprk_exchange.h:948
SessionColor
Definition: sprk_exchange.h:907
Definition: sprk.h:1614
Definition: hps.h:43480
LoadStatus
Definition: sprk_exchange.h:94
Definition: hps.h:40725
Definition: hps.h:42426
Definition: sprk_exchange.h:485
Definition: hps.h:6197
Definition: hps.h:13110
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4190
Definition: sprk_exchange.h:4551
Definition: sprk.h:445
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1268
BRepCompression
Definition: sprk_exchange.h:888
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:732
Definition: sprk.h:1880
ComponentType
Definition: sprk.h:1619
Accuracy
Definition: sprk_exchange.h:812
Definition: sprk_exchange.h:2997
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:4441
Definition: sprk.h:2191
FamilyTable
Definition: sprk_exchange.h:920
Content
Definition: sprk_exchange.h:833
Definition: sprk_exchange.h:1246
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2713
HPS::Type ObjectType() const
Definition: sprk_exchange.h:606
Definition: sprk.h:2290
static MouseButtons ButtonLeft()
Definition: hps.h:42879
Definition: hps.h:7392
Definition: sprk_exchange.h:902
AccurateEdges
Definition: sprk_exchange.h:2425
Event * Clone() const
Definition: sprk_exchange.h:4411
HPS::Type ObjectType() const
Definition: sprk_exchange.h:467
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3973
Definition: hps.h:8972
HPS::Type ObjectType() const
Definition: sprk_exchange.h:204
Definition: sprk_exchange.h:631
Definition: hps.h:22556
Healing
Definition: sprk_exchange.h:2416
Definition: sprk.h:2376
Definition: hps.h:28759
ImportMode
Definition: sprk_exchange.h:747
Definition: sprk_exchange.h:965
Definition: sprk.h:1065
Definition: sprk_exchange.h:2411
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:3291
Definition: sprk_exchange.h:172
Definition: hps.h:37490
Definition: sprk_exchange.h:4174
HPS::Type ObjectType() const
Definition: sprk_exchange.h:553
Definition: hps.h:38546
Definition: sprk_exchange.h:3592