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  class EXCHANGE_API Component : public HPS::Component
80  {
81  public:
83  Component();
84 
88  Component(HPS::Component const & in_that);
89 
92  Component(Exchange::Component const & in_that);
93 
96  Component(Exchange::Component && in_that);
97 
98  virtual ~Component();
99 
100  HPS::Type ObjectType() const { return HPS::Type::ExchangeComponent; }
101 
102 #if !defined(_MSC_VER) || _MSC_VER >= 1900
103  Component & operator=(Component const & in_that) = default;
104 #endif
105 
109  Component & operator=(Exchange::Component && in_that);
110 
111 
114  A3DEntity * GetExchangeEntity() const;
115 
116 
122  void Tessellate(TessellationOptionsKit const & in_options);
123 
130  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
131 
138  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
139  };
140 
141  class EXCHANGE_API ProductOccurrence : public Exchange::Component
142  {
143  public:
146 
150  ProductOccurrence(HPS::Component const & in_that);
151 
155  ProductOccurrence(Component const & in_that);
156 
159  ProductOccurrence(ProductOccurrence const & in_sheet);
160 
165 
169  ProductOccurrence & operator=(ProductOccurrence && in_that);
170 
171  virtual ~ProductOccurrence();
172 
173  HPS::Type ObjectType() const { return HPS::Type::ExchangeProductOccurrence; }
174 
178  bool Equals(ProductOccurrence const & in_kit) const;
179 
183  bool operator==(ProductOccurrence const & in_kit) const;
184 
188  bool operator!=(ProductOccurrence const & in_kit) const;
189  };
190 
192  class EXCHANGE_API Sheet : public Exchange::Component
193  {
194  public:
196  Sheet();
197 
201  Sheet(HPS::Component const & in_that);
202 
206  Sheet(Component const & in_that);
207 
210  Sheet(Sheet const & in_sheet);
211 
215  Sheet(Sheet && in_that);
216 
220  Sheet & operator=(Sheet && in_that);
221 
222  virtual ~Sheet();
223 
224  HPS::Type ObjectType() const { return HPS::Type::ExchangeSheet; }
225 
229  bool Equals(Sheet const & in_kit) const;
230 
231 #if !defined(_MSC_VER) || _MSC_VER >= 1900
232  Sheet & operator=(Sheet const & in_that) = default;
233 #endif
234 
238  bool operator==(Sheet const & in_kit) const;
239 
243  bool operator!=(Sheet const & in_kit) const;
244 
245  /* Activates this sheet */
246  HPS::View Activate();
247  };
248 
251  class EXCHANGE_API CADModel : public HPS::CADModel
252  {
253  public:
255  CADModel();
256 
260  CADModel(Component const & in_that);
261 
265  CADModel(HPS::CADModel const & in_that);
266 
269  CADModel(Exchange::CADModel const & in_that);
270 
273  CADModel(Exchange::CADModel && in_that);
274 
275  virtual ~CADModel();
276 
277  HPS::Type ObjectType() const { return HPS::Type::ExchangeCADModel; }
278 
279 #if !defined(_MSC_VER) || _MSC_VER >= 1900
280  CADModel & operator=(Exchange::CADModel const & in_that) = default;
281 #endif
282 
286  CADModel & operator=(Exchange::CADModel && in_that);
287 
288 
291  A3DEntity * GetExchangeEntity() const;
292 
298  bool GetEntityOwnership() const;
299 
300 
304  UTF8Array GetCurrentConfiguration() const;
305 
309  ConfigurationArray GetConfigurations() const;
310 
311  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
312  * \return The list of sheets for this CADModel */
313  SheetArray GetSheets() const;
314 
320  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
321 
326  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
327 
333  void ShowAllPMI(Canvas & in_canvas, size_t in_layer = 0);
334 
340  void HideAllPMI(Canvas & in_canvas, size_t in_layer = 0);
341  };
342 
345  class EXCHANGE_API Capture : public HPS::Capture
346  {
347  public:
349  Capture();
350 
354  Capture(Component const & in_that);
355 
359  Capture(HPS::Capture const & in_that);
360 
363  Capture(Exchange::Capture const & in_that);
364 
367  Capture(Exchange::Capture && in_that);
368 
369  virtual ~Capture();
370 
371  HPS::Type ObjectType() const { return HPS::Type::ExchangeCapture; }
372 
373 #if !defined(_MSC_VER) || _MSC_VER >= 1900
374  Capture & operator=(Exchange::Capture const & in_that) = default;
375 #endif
376 
380  Capture & operator=(Exchange::Capture && in_that);
381 
382 
385  A3DEntity * GetExchangeEntity() const;
386  };
387 
390  class EXCHANGE_API Filter : public HPS::Filter
391  {
392  public:
394  Filter();
395 
399  Filter(Component const & in_that);
400 
404  Filter(HPS::Filter const & in_that);
405 
408  Filter(Exchange::Filter const & in_that);
409 
412  Filter(Exchange::Filter && in_that);
413 
414  virtual ~Filter();
415 
416  HPS::Type ObjectType() const { return HPS::Type::ExchangeFilter; }
417 
418 #if !defined(_MSC_VER) || _MSC_VER >= 1900
419  Filter & operator=(Exchange::Filter const & in_that) = default;
420 #endif
421 
425  Filter & operator=(Exchange::Filter && in_that);
426 
427 
430  A3DEntity * GetExchangeEntity() const;
431  };
432 
434  class EXCHANGE_API Factory : public Sprocket
435  {
436  public:
441  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
442 
448  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
449 
453  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
454 
461  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
462 
466  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
467 
468  private:
470  Factory();
471  };
472 
474  class EXCHANGE_API ImportNotifier : public IONotifier
475  {
476  public:
478  ImportNotifier();
479 
482  ImportNotifier(ImportNotifier const & in_that);
483 
488  ImportNotifier(IONotifier const & in_that);
489 
493  ImportNotifier(ImportNotifier && in_that);
494 
498  ImportNotifier & operator=(ImportNotifier && in_that);
499 
500  virtual ~ImportNotifier();
501 
502  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportNotifier; };
503 
507  ImportNotifier & operator=(ImportNotifier const & in_that);
508 
511  void Assign(ImportNotifier const & in_that);
512 
515  Exchange::CADModel GetCADModel() const;
516 
519  Time GetImportTime() const;
520 
523  Time GetParseTime() const;
524  };
525 
527  class EXCHANGE_API TranslationNotifier : public IONotifier
528  {
529  public:
532 
535  TranslationNotifier(TranslationNotifier const & in_that);
536 
541  TranslationNotifier(IONotifier const & in_that);
542 
547 
551  TranslationNotifier & operator=(TranslationNotifier && in_that);
552 
553  virtual ~TranslationNotifier();
554 
555  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationNotifier; };
556 
560  TranslationNotifier & operator=(TranslationNotifier const & in_that);
561 
564  void Assign(TranslationNotifier const & in_that);
565 
568  Exchange::ParasolidEntityArray GetParasolidParts() const;
569 
572  HPS::Time GetImportTime() const;
573 
576  HPS::Time GetTranslationTime() const;
577  };
578 
580  class EXCHANGE_API ExportNotifier : public IONotifier
581  {
582  public:
584  ExportNotifier();
585 
588  ExportNotifier(ExportNotifier const & in_that);
589 
594  ExportNotifier(IONotifier const & in_that);
595 
599  ExportNotifier(ExportNotifier && in_that);
600 
604  ExportNotifier & operator=(ExportNotifier && in_that);
605 
606  virtual ~ExportNotifier();
607 
608  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportNotifier; };
609 
613  ExportNotifier & operator=(ExportNotifier const & in_that);
614 
617  void Assign(ExportNotifier const & in_that);
618 
622  A3DAsmModelFile * GetModelFile() const;
623  };
624 
626  class EXCHANGE_API ReloadNotifier : public IONotifier
627  {
628  public:
630  ReloadNotifier();
631 
634  ReloadNotifier(ReloadNotifier const & in_that);
635 
640  ReloadNotifier(IONotifier const & in_that);
641 
645  ReloadNotifier(ReloadNotifier && in_that);
646 
650  ReloadNotifier & operator=(ReloadNotifier && in_that);
651 
652  virtual ~ReloadNotifier();
653 
654  HPS::Type ObjectType() const { return HPS::Type::ExchangeReloadNotifier; };
655 
659  ReloadNotifier & operator=(ReloadNotifier const & in_that);
660 
663  void Assign(ReloadNotifier const & in_that);
664  };
665 
666 
667  class ImportOptionsKit;
668  class ModelFileImportOptionsKit;
669  class ExportACISOptionsKit;
670  class ExportIGESOptionsKit;
671  class ExportJTOptionsKit;
672  class ExportPRCOptionsKit;
673  class ExportSTEPOptionsKit;
674  class ExportSTLOptionsKit;
675  class ExportU3DOptionsKit;
676  class ExportXMLOptionsKit;
677 
678 
681  enum class BRepMode
682  {
685  TessellationOnly,
688  BRepOnly,
691  BRepAndTessellation,
692  };
693 
697  {
698  PMIOnly,
699  ModelAndPMI
700  };
701 
703  class EXCHANGE_API Tessellation
704  {
705  public:
708  enum class Type
709  {
710  Standard,
711  Custom
712  };
713 
714 
717  enum class Level
718  {
719  ExtraLow,
720  Low,
721  Medium,
722  High,
723  ExtraHigh,
724  };
725 
727  class EXCHANGE_API Chord
728  {
729  public:
732  enum class Limit
733  {
736  Ratio,
739  Height
740  };
741 
742  private:
744  Chord();
745  };
746 
749  enum class Accuracy
750  {
753  Standard,
756  Accurate
757  };
758 
759  private:
761  Tessellation();
762  };
763 
765  class EXCHANGE_API JT
766  {
767  public:
770  enum class Content
771  {
772  Geometry,
773  Tessellation,
774  GeometryAndTessellation
775  };
776 
779  enum class TessellationLevel
780  {
781  Low,
782  Medium,
783  High,
784  };
785 
786  private:
788  JT();
789  };
790 
792  class EXCHANGE_API STEP
793  {
794  public:
797  enum class Field
798  {
799  ProductName,
800  NextAssemblyUsageOccurrenceID,
801  NextAssemblyUsageOccurrenceName,
802  NextAssemblyUsageOccurrenceDescription
803  };
804 
807  enum class Format
808  {
809  AP203,
810  AP214
811  };
812 
813  private:
815  STEP();
816  };
817 
819  class EXCHANGE_API PRC
820  {
821  public:
824  enum class BRepCompression
825  {
826  None,
827  Low,
828  Medium,
829  High
830  };
831 
832  private:
834  PRC();
835  };
836 
838  class EXCHANGE_API ProE
839  {
840  public:
843  enum class SessionColor
844  {
846  LastCreoVersion,
848  ExchangeDefault,
851  UserDefined
852  };
853 
854  private:
856  ProE();
857  };
858 
860  class EXCHANGE_API U3D
861  {
862  public:
865  enum class Version
866  {
867  ECMA1,
868  ECMA3
869  };
870 
871  private:
873  U3D();
874  };
875 
877  class EXCHANGE_API Configuration : public HPS::Sprocket
878  {
879  public:
881  Configuration();
882 
885  Configuration(char const * in_name);
886 
891  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
892 
896  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
897 
900  Configuration(Configuration const & in_configuration);
901 
905  Configuration(Configuration && in_that);
906 
910  Configuration & operator=(Configuration && in_that);
911 
912  virtual ~Configuration();
913 
914  HPS::Type ObjectType() const { return HPS::Type::ExchangeConfiguration; }
915 
916 
919  void Set(Configuration const & in_kit);
920 
923  void Show(Configuration & out_kit) const;
924 
928  Configuration & operator=(Configuration const & in_kit);
929 
932  bool Empty() const;
933 
937  bool Equals(Configuration const & in_kit) const;
938 
942  bool operator==(Configuration const & in_kit) const;
943 
947  bool operator!=(Configuration const & in_kit) const;
948 
949 
952  HPS::UTF8 GetName() const;
953 
956  ConfigurationArray GetSubconfigurations() const;
957  };
958 
960  class EXCHANGE_API File
961  {
962  public:
965  enum class Format
966  {
967  Unsupported,
968  ACIS,
969  CADDS,
970  CATIAV4,
971  CATIAV5,
972  CGR,
973  COLLADA,
974  CreoProE,
975  IDEAS,
976  IFC,
977  IGES,
978  Inventor,
979  JT,
980  KeyholeMarkupLanguage,
981  LatticeXVL,
982  OneSpaceDesigner,
983  Parasolid,
984  PDF,
985  PRC,
986  Rhino,
987  NXUnigraphics,
988  SolidEdge,
989  SolidWorks,
990  STEP,
991  StereoLithography,
992  ThreeDStudioMax,
993  ThreeDXML,
994  Universal3D,
995  VDAFS,
996  VRML,
997  WavefrontObject,
998  };
999 
1001  static Format GetFormat(char const * in_file_name);
1002 
1006  static ConfigurationArray GetConfigurations(char const * in_file_name);
1007 
1019  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);
1020 
1026  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1027 
1034  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1035 
1042  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1043 
1044 
1051  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1052 
1057  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1058 
1063  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1064 
1069  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1070 
1075  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1076 
1082  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1083 
1089  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1090 
1097  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1098 
1105  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1106 
1110  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1111 
1116  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1117 
1121  static ExportNotifier ExportPRC(KeyPath const & in_source);
1122 
1127  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1128 
1133  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1134 
1139  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1140 
1144  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1145 
1150  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1151 
1152  private:
1154  File();
1155  };
1156 
1158  class EXCHANGE_API ImportOptionsKit : public HPS::Sprocket
1159  {
1160  public:
1162  ImportOptionsKit();
1163 
1166  ImportOptionsKit(ImportOptionsKit const & in_kit);
1167 
1171  ImportOptionsKit(ImportOptionsKit && in_that);
1172 
1176  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1177 
1178  virtual ~ImportOptionsKit();
1179 
1180  HPS::Type ObjectType() const { return HPS::Type::ExchangeImportOptionsKit; }
1181 
1185  static ImportOptionsKit GetDefault();
1186 
1189  void Set(ImportOptionsKit const & in_kit);
1190 
1193  void Show(ImportOptionsKit & out_kit) const;
1194 
1198  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1199 
1202  bool Empty() const;
1203 
1207  bool Equals(ImportOptionsKit const & in_kit) const;
1208 
1212  bool operator==(ImportOptionsKit const & in_kit) const;
1213 
1217  bool operator!=(ImportOptionsKit const & in_kit) const;
1218 
1219 
1225  ImportOptionsKit & SetBRepData(bool in_state);
1226 
1232  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1233 
1239  ImportOptionsKit & SetSolids(bool in_state);
1240 
1246  ImportOptionsKit & SetSurfaces(bool in_state);
1247 
1253  ImportOptionsKit & SetWireframes(bool in_state);
1254 
1260  ImportOptionsKit & SetPMI(bool in_state);
1261 
1268  ImportOptionsKit & SetAttributes(bool in_state);
1269 
1275  ImportOptionsKit & SetHiddenObjects(bool in_state);
1276 
1282  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1283 
1289  ImportOptionsKit & SetActiveFilter(bool in_state);
1290 
1296  ImportOptionsKit & SetDefaultUnits(Units in_units);
1297 
1304  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1305 
1311  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1312 
1318  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1319 
1325  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color);
1326 
1332  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1333 
1340  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1341 
1349  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
1350 
1356  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1357 
1363  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1364 
1370  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1371 
1376  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
1377 
1384  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
1385 
1391  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
1392 
1401  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
1402 
1411  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
1412 
1418  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
1419 
1424  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
1425 
1430  ImportOptionsKit & SetConfiguration(char const * in_configuration);
1431 
1437  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
1438 
1443  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
1444 
1450  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
1451 
1458  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
1459 
1466  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
1467 
1475  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
1476 
1483  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
1484 
1490  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
1491 
1497  ImportOptionsKit & SetProECodePageName(char const * in_name);
1498 
1504  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
1505 
1511  ImportOptionsKit & SetProESubpartPMI(bool in_state);
1512 
1518  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
1519 
1526  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
1527 
1533  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
1534 
1540  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
1541 
1547  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
1548 
1554  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
1555 
1561  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
1562 
1569  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
1570 
1576  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
1577 
1583  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
1584 
1591  ImportOptionsKit & SetIFCEdges(bool in_state);
1592 
1598  ImportOptionsKit & SetIFCMetadata(bool in_state);
1599 
1605  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
1606 
1612  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
1613 
1617  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
1618 
1630  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
1631 
1632 
1636  ImportOptionsKit & UnsetBRepData();
1637 
1640  ImportOptionsKit & UnsetBRepMode();
1641 
1644  ImportOptionsKit & UnsetSolids();
1645 
1648  ImportOptionsKit & UnsetSurfaces();
1649 
1652  ImportOptionsKit & UnsetWireframes();
1653 
1656  ImportOptionsKit & UnsetPMI();
1657 
1660  ImportOptionsKit & UnsetAttributes();
1661 
1664  ImportOptionsKit & UnsetHiddenObjects();
1665 
1668  ImportOptionsKit & UnsetConstructionAndReferences();
1669 
1672  ImportOptionsKit & UnsetActiveFilter();
1673 
1676  ImportOptionsKit & UnsetDefaultUnits();
1677 
1680  ImportOptionsKit & UnsetPMISubstitutionFont();
1681 
1684  ImportOptionsKit & UnsetPMIPrecision();
1685 
1688  ImportOptionsKit & UnsetPMIDefaultUnits();
1689 
1692  ImportOptionsKit & UnsetPMIDefaultColor();
1693 
1696  ImportOptionsKit & UnsetTessellationLevel();
1697 
1700  ImportOptionsKit & UnsetTessellationAccuracy();
1701 
1704  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
1705 
1708  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
1709 
1712  ImportOptionsKit & UnsetTextureDirectories();
1713 
1716  ImportOptionsKit & UnsetSearchDirectories();
1717 
1720  ImportOptionsKit & UnsetSearchDirectoriesByFile();
1721 
1724  ImportOptionsKit & UnsetConfiguration();
1725 
1728  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
1729 
1732  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
1733 
1736  ImportOptionsKit & UnsetCatiaV5Cache();
1737 
1740  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
1741 
1744  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
1745 
1748  ImportOptionsKit & UnsetProECodePageName();
1749 
1752  ImportOptionsKit & UnsetProEDimensionTolerance();
1753 
1756  ImportOptionsKit & UnsetProESubpartPMI();
1757 
1760  ImportOptionsKit & UnsetProESessionColor();
1761 
1764  ImportOptionsKit & UnsetSTEPNamePreference();
1765 
1768  ImportOptionsKit & UnsetSTEPFirstColorPreference();
1769 
1772  ImportOptionsKit & UnsetSTEPCodePageName();
1773 
1776  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
1777 
1780  ImportOptionsKit & UnsetSTEPOrientationHealing();
1781 
1784  ImportOptionsKit & UnsetIFCCodePageName();
1785 
1788  ImportOptionsKit & UnsetIFCAttributeXMLFile();
1789 
1792  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
1793 
1796  ImportOptionsKit & UnsetIFCFaceOptimization();
1797 
1800  ImportOptionsKit & UnsetIFCEdges();
1801 
1804  ImportOptionsKit & UnsetIFCMetadata();
1805 
1808  ImportOptionsKit & UnsetPDF3DStreamIndex();
1809 
1812  ImportOptionsKit & UnsetJTTessellationLevel();
1813 
1816  ImportOptionsKit & UnsetAnnotationCaptureFitting();
1817 
1820  ImportOptionsKit & UnsetLocation();
1821 
1824  ImportOptionsKit & UnsetEverything();
1825 
1826 
1831  bool ShowBRepData(bool & out_state) const;
1832 
1836  bool ShowBRepMode(BRepMode & out_mode) const;
1837 
1841  bool ShowSolids(bool & out_state) const;
1842 
1846  bool ShowSurfaces(bool & out_state) const;
1847 
1851  bool ShowWireframes(bool & out_state) const;
1852 
1856  bool ShowPMI(bool & out_state) const;
1857 
1861  bool ShowAttributes(bool & out_state) const;
1862 
1866  bool ShowHiddenObjects(bool & out_state) const;
1867 
1871  bool ShowConstructionAndReferences(bool & out_state) const;
1872 
1876  bool ShowActiveFilter(bool & out_state) const;
1877 
1881  bool ShowDefaultUnits(Units & out_units) const;
1882 
1887  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
1888 
1892  bool ShowPMIPrecision(size_t & out_precision) const;
1893 
1897  bool ShowPMIDefaultUnits(Units & out_units) const;
1898 
1902  bool ShowPMIDefaultColor(RGBColor & out_color) const;
1903 
1911  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
1912 
1917  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
1918 
1922  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
1923 
1927  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
1928 
1932  bool ShowTextureDirectories(UTF8Array & out_directories);
1933 
1939  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
1940 
1944  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
1945 
1949  bool ShowConfiguration(UTF8Array & out_configuration) const;
1950 
1954  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
1955 
1959  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
1960 
1965  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
1966 
1971  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
1972 
1976  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
1977 
1981  bool ShowProECodePageName(UTF8 & out_name) const;
1982 
1986  bool ShowProEDimensionTolerance(bool & out_state) const;
1987 
1991  bool ShowProESubpartPMI(bool & out_state) const;
1992 
1996  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
1997 
2001  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
2002 
2006  bool ShowSTEPFirstColorPreference(bool & out_state) const;
2007 
2011  bool ShowSTEPCodePageName(UTF8 & out_name) const;
2012 
2016  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
2017 
2021  bool ShowSTEPOrientationHealing(bool & out_state) const;
2022 
2026  bool ShowIFCCodePageName(UTF8 & out_name) const;
2027 
2031  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
2032 
2036  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
2037 
2041  bool ShowIFCFaceOptimization(bool & out_state) const;
2042 
2046  bool ShowIFCEdges(bool & out_state) const;
2047 
2051  bool ShowIFCMetadata(bool & out_state) const;
2052 
2056  bool ShowPDF3DStreamIndex(size_t & out_index) const;
2057 
2061  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
2062 
2066  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2067 
2072  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2073  };
2074 
2076  class EXCHANGE_API Translation
2077  {
2078  public:
2081  enum class Healing
2082  {
2083  Off,
2084  On,
2085  OnlyIfNotParasolid,
2086  };
2087 
2090  enum class AccurateEdges
2091  {
2092  Off,
2093  On,
2094  OnlyIfNotParasolid,
2095  };
2096 
2099  enum class Simplification
2100  {
2101  Off,
2102  On,
2103  OnlyIfNotParasolid,
2104  };
2105 
2108  enum class Merging
2109  {
2110  Off,
2111  On,
2112  OnlyIfNotParasolid,
2113  };
2114 
2115  private:
2117  Translation();
2118  };
2119 
2121  class EXCHANGE_API TranslationOptionsKit : public HPS::Sprocket
2122  {
2123  public:
2126 
2130 
2135 
2139  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
2140 
2141  virtual ~TranslationOptionsKit();
2142 
2143  HPS::Type ObjectType() const { return HPS::Type::ExchangeTranslationOptionsKit; }
2144 
2148  static TranslationOptionsKit GetDefault();
2149 
2152  void Set(TranslationOptionsKit const & in_kit);
2153 
2156  void Show(TranslationOptionsKit & out_kit) const;
2157 
2161  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
2162 
2165  bool Empty() const;
2166 
2170  bool Equals(TranslationOptionsKit const & in_kit) const;
2171 
2175  bool operator==(TranslationOptionsKit const & in_kit) const;
2176 
2180  bool operator!=(TranslationOptionsKit const & in_kit) const;
2181 
2187  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
2188 
2194  TranslationOptionsKit & SetTessellation(bool in_state);
2195 
2201  TranslationOptionsKit & SetHiddenObjects(bool in_state);
2202 
2206  TranslationOptionsKit & SetApplication(char const * in_name);
2207 
2211  TranslationOptionsKit & SetVersion(char const * in_version);
2212 
2216  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
2217 
2221  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
2222 
2226  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
2227 
2231  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
2232 
2237  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
2238 
2242  TranslationOptionsKit & SetDisjointFaces(bool in_state);
2243 
2246  TranslationOptionsKit & UnsetSolidsAsFaces();
2247 
2250  TranslationOptionsKit & UnsetTessellation();
2251 
2254  TranslationOptionsKit & UnsetHiddenObjects();
2255 
2258  TranslationOptionsKit & UnsetApplication();
2259 
2262  TranslationOptionsKit & UnsetVersion();
2263 
2266  TranslationOptionsKit & UnsetHealing();
2267 
2270  TranslationOptionsKit & UnsetAccurateEdges();
2271 
2274  TranslationOptionsKit & UnsetSimplification();
2275 
2278  TranslationOptionsKit & UnsetEntityMerging();
2279 
2282  TranslationOptionsKit & UnsetSewing();
2283 
2286  TranslationOptionsKit & UnsetDisjointFaces();
2287 
2290  TranslationOptionsKit & UnsetEverything();
2291 
2292 
2296  bool ShowSolidsAsFaces(bool & out_state) const;
2297 
2301  bool ShowTessellation(bool & out_state) const;
2302 
2306  bool ShowHiddenObjects(bool & out_state) const;
2307 
2311  bool ShowApplication(UTF8 & out_name) const;
2312 
2316  bool ShowVersion(UTF8 & out_version) const;
2317 
2321  bool ShowHealing(Translation::Healing & out_healing) const;
2322 
2326  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
2327 
2331  bool ShowSimplification(Translation::Simplification & out_simplification) const;
2332 
2336  bool ShowEntityMerging(Translation::Merging & out_merging) const;
2337 
2342  bool ShowSewing(bool & out_state, double & out_tolerance) const;
2343 
2347  bool ShowDisjointFaces(bool & out_state) const;
2348  };
2349 
2350 
2351 
2356  class EXCHANGE_API ModelFileImportOptionsKit : public HPS::Sprocket
2357  {
2358  public:
2361 
2365 
2370 
2374  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
2375 
2376  virtual ~ModelFileImportOptionsKit();
2377 
2378  HPS::Type ObjectType() const { return HPS::Type::ExchangeModelFileImportOptionsKit; }
2379 
2383  static ModelFileImportOptionsKit GetDefault();
2384 
2387  void Set(ModelFileImportOptionsKit const & in_kit);
2388 
2391  void Show(ModelFileImportOptionsKit & out_kit) const;
2392 
2396  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
2397 
2400  bool Empty() const;
2401 
2405  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
2406 
2410  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
2411 
2415  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
2416 
2417 
2423  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
2424 
2431  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
2432 
2440  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
2441 
2447  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
2448 
2454  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
2455 
2462  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
2463 
2467  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2468 
2481  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2482 
2483 
2486  ModelFileImportOptionsKit & UnsetTessellationLevel();
2487 
2490  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
2491 
2494  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
2495 
2498  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2499 
2502  ModelFileImportOptionsKit & UnsetIFCEdges();
2503 
2506  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
2507 
2510  ModelFileImportOptionsKit & UnsetLocation();
2511 
2514  ModelFileImportOptionsKit & UnsetEverything();
2515 
2516 
2524  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2525 
2530  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
2531 
2535  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2536 
2540  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2541 
2545  bool ShowIFCEdges(bool & out_state) const;
2546 
2550  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
2551 
2556  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
2557  };
2558 
2559 
2561  class EXCHANGE_API ExportACISOptionsKit : public HPS::Sprocket
2562  {
2563  public:
2566 
2570 
2574 
2575  virtual ~ExportACISOptionsKit();
2576 
2577  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportACISOptionsKit; }
2578 
2582  static ExportACISOptionsKit GetDefault();
2583 
2586  void Set(ExportACISOptionsKit const & in_kit);
2587 
2590  void Show(ExportACISOptionsKit & out_kit) const;
2591 
2595  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
2596 
2600  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
2601 
2604  bool Empty() const;
2605 
2609  bool Equals(ExportACISOptionsKit const & in_kit) const;
2610 
2614  bool operator==(ExportACISOptionsKit const & in_kit) const;
2615 
2619  bool operator!=(ExportACISOptionsKit const & in_kit) const;
2620 
2621 
2627  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
2628 
2634  ExportACISOptionsKit & SetBinary(bool in_state);
2635 
2636 
2639  ExportACISOptionsKit & UnsetMillimeterUnits();
2640 
2643  ExportACISOptionsKit & UnsetBinary();
2644 
2647  ExportACISOptionsKit & UnsetEverything();
2648 
2649 
2653  bool ShowMillimeterUnits(bool & out_state) const;
2654 
2658  bool ShowBinary(bool & out_state) const;
2659  };
2660 
2662  class EXCHANGE_API ExportIGESOptionsKit : public HPS::Sprocket
2663  {
2664  public:
2667 
2671 
2675 
2676  virtual ~ExportIGESOptionsKit();
2677 
2678  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportIGESOptionsKit; }
2679 
2683  static ExportIGESOptionsKit GetDefault();
2684 
2687  void Set(ExportIGESOptionsKit const & in_kit);
2688 
2691  void Show(ExportIGESOptionsKit & out_kit) const;
2692 
2696  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
2697 
2701  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
2702 
2705  bool Empty() const;
2706 
2710  bool Equals(ExportIGESOptionsKit const & in_kit) const;
2711 
2715  bool operator==(ExportIGESOptionsKit const & in_kit) const;
2716 
2720  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
2721 
2722 
2728  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
2729 
2735  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
2736 
2742  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
2743 
2749  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
2750 
2756  ExportIGESOptionsKit & SetTessellation(bool in_state);
2757 
2761  ExportIGESOptionsKit & SetApplication(char const * in_name);
2762 
2766  ExportIGESOptionsKit & SetVersion(char const * in_version);
2767 
2768 
2771  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
2772 
2775  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
2776 
2779  ExportIGESOptionsKit & UnsetSolidsAsFaces();
2780 
2783  ExportIGESOptionsKit & UnsetHiddenObjects();
2784 
2787  ExportIGESOptionsKit & UnsetTessellation();
2788 
2791  ExportIGESOptionsKit & UnsetApplication();
2792 
2795  ExportIGESOptionsKit & UnsetVersion();
2796 
2799  ExportIGESOptionsKit & UnsetEverything();
2800 
2801 
2805  bool ShowAnalyticsAsNURBS(bool & out_state) const;
2806 
2810  bool ShowFacetedAsWireframe(bool & out_state) const;
2811 
2815  bool ShowSolidsAsFaces(bool & out_state) const;
2816 
2820  bool ShowHiddenObjects(bool & out_state) const;
2821 
2825  bool ShowTessellation(bool & out_state) const;
2826 
2830  bool ShowApplication(UTF8 & out_name) const;
2831 
2835  bool ShowVersion(UTF8 & out_version) const;
2836  };
2837 
2839  class EXCHANGE_API ExportJTOptionsKit : public HPS::Sprocket
2840  {
2841  public:
2844 
2847  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
2848 
2852 
2853  virtual ~ExportJTOptionsKit();
2854 
2855  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportJTOptionsKit; }
2856 
2860  static ExportJTOptionsKit GetDefault();
2861 
2864  void Set(ExportJTOptionsKit const & in_kit);
2865 
2868  void Show(ExportJTOptionsKit & out_kit) const;
2869 
2873  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
2874 
2878  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
2879 
2882  bool Empty() const;
2883 
2887  bool Equals(ExportJTOptionsKit const & in_kit) const;
2888 
2892  bool operator==(ExportJTOptionsKit const & in_kit) const;
2893 
2897  bool operator!=(ExportJTOptionsKit const & in_kit) const;
2898 
2899 
2905  ExportJTOptionsKit & SetContent(JT::Content in_content);
2906 
2912  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
2913 
2919  ExportJTOptionsKit & SetPMI(bool in_state);
2920 
2921 
2924  ExportJTOptionsKit & UnsetContent();
2925 
2928  ExportJTOptionsKit & UnsetHiddenObjects();
2929 
2932  ExportJTOptionsKit & UnsetPMI();
2933 
2936  ExportJTOptionsKit & UnsetEverything();
2937 
2938 
2942  bool ShowContent(JT::Content & out_content) const;
2943 
2947  bool ShowHiddenObjects(bool & out_state) const;
2948 
2952  bool ShowPMI(bool & out_state) const;
2953  };
2954 
2956  class EXCHANGE_API ExportParasolidOptionsKit : public HPS::Sprocket
2957  {
2958  public:
2961 
2965 
2969 
2970  virtual ~ExportParasolidOptionsKit();
2971 
2972  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportParasolidOptionsKit; }
2973 
2977  static ExportParasolidOptionsKit GetDefault();
2978 
2981  void Set(ExportParasolidOptionsKit const & in_kit);
2982 
2985  void Show(ExportParasolidOptionsKit & out_kit) const;
2986 
2990  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
2991 
2995  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
2996 
2999  bool Empty() const;
3000 
3004  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
3005 
3009  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
3010 
3014  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
3015 
3016 
3022  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
3023 
3029  ExportParasolidOptionsKit & SetTessellation(bool in_state);
3030 
3036  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
3037 
3041  ExportParasolidOptionsKit & SetApplication(char const * in_name);
3042 
3046  ExportParasolidOptionsKit & SetVersion(char const * in_version);
3047 
3048 
3051  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
3052 
3055  ExportParasolidOptionsKit & UnsetTessellation();
3056 
3059  ExportParasolidOptionsKit & UnsetHiddenObjects();
3060 
3063  ExportParasolidOptionsKit & UnsetApplication();
3064 
3067  ExportParasolidOptionsKit & UnsetVersion();
3068 
3071  ExportParasolidOptionsKit & UnsetEverything();
3072 
3073 
3077  bool ShowSolidsAsFaces(bool & out_state) const;
3078 
3082  bool ShowTessellation(bool & out_state) const;
3083 
3087  bool ShowHiddenObjects(bool & out_state) const;
3088 
3092  bool ShowApplication(UTF8 & out_name) const;
3093 
3097  bool ShowVersion(UTF8 & out_version) const;
3098  };
3099 
3101  class EXCHANGE_API ExportPRCOptionsKit : public HPS::Sprocket
3102  {
3103  public:
3106 
3109  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
3110 
3114 
3115  virtual ~ExportPRCOptionsKit();
3116 
3117  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportPRCOptionsKit; }
3118 
3122  static ExportPRCOptionsKit GetDefault();
3123 
3126  void Set(ExportPRCOptionsKit const & in_kit);
3127 
3130  void Show(ExportPRCOptionsKit & out_kit) const;
3131 
3135  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
3136 
3140  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
3141 
3144  bool Empty() const;
3145 
3149  bool Equals(ExportPRCOptionsKit const & in_kit) const;
3150 
3154  bool operator==(ExportPRCOptionsKit const & in_kit) const;
3155 
3159  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
3160 
3161 
3167  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
3168 
3175  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
3176 
3182  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
3183 
3189  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
3190 
3195  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3196 
3202  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
3203 
3204 
3207  ExportPRCOptionsKit & UnsetTessellationCompression();
3208 
3211  ExportPRCOptionsKit & UnsetBRepCompression();
3212 
3215  ExportPRCOptionsKit & UnsetBRepRemoval();
3216 
3219  ExportPRCOptionsKit & UnsetAttributeRemoval();
3220 
3223  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
3224 
3227  ExportPRCOptionsKit & UnsetEverything();
3228 
3229 
3233  bool ShowTessellationCompression(bool & out_state) const;
3234 
3238  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
3239 
3243  bool ShowBRepRemoval(bool & out_state) const;
3244 
3248  bool ShowAttributeRemoval(bool & out_state) const;
3249 
3253  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3254  };
3255 
3257  class EXCHANGE_API ExportSTEPOptionsKit : public HPS::Sprocket
3258  {
3259  public:
3262 
3266 
3270 
3271  virtual ~ExportSTEPOptionsKit();
3272 
3273  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTEPOptionsKit; }
3274 
3278  static ExportSTEPOptionsKit GetDefault();
3279 
3282  void Set(ExportSTEPOptionsKit const & in_kit);
3283 
3286  void Show(ExportSTEPOptionsKit & out_kit) const;
3287 
3291  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
3292 
3296  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
3297 
3300  bool Empty() const;
3301 
3305  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
3306 
3310  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
3311 
3315  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
3316 
3317 
3323  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
3324 
3330  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
3331 
3337  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
3338 
3344  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
3345 
3349  ExportSTEPOptionsKit & SetApplication(char const * in_name);
3350 
3354  ExportSTEPOptionsKit & SetVersion(char const * in_version);
3355 
3356 
3359  ExportSTEPOptionsKit & UnsetFormat();
3360 
3363  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
3364 
3367  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
3368 
3371  ExportSTEPOptionsKit & UnsetNameShortening();
3372 
3375  ExportSTEPOptionsKit & UnsetApplication();
3376 
3379  ExportSTEPOptionsKit & UnsetVersion();
3380 
3383  ExportSTEPOptionsKit & UnsetEverything();
3384 
3385 
3389  bool ShowFormat(STEP::Format & out_format) const;
3390 
3394  bool ShowAnalyticsAsNURBS(bool & out_state) const;
3395 
3399  bool ShowFacetedAsWireframe(bool & out_state) const;
3400 
3404  bool ShowNameShortening(bool & out_state) const;
3405 
3409  bool ShowApplication(UTF8 & out_name) const;
3410 
3414  bool ShowVersion(UTF8 & out_version) const;
3415  };
3416 
3418  class EXCHANGE_API ExportSTLOptionsKit : public HPS::Sprocket
3419  {
3420  public:
3423 
3426  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
3427 
3431 
3432  virtual ~ExportSTLOptionsKit();
3433 
3434  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportSTLOptionsKit; }
3435 
3439  static ExportSTLOptionsKit GetDefault();
3440 
3443  void Set(ExportSTLOptionsKit const & in_kit);
3444 
3447  void Show(ExportSTLOptionsKit & out_kit) const;
3448 
3452  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
3453 
3457  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
3458 
3461  bool Empty() const;
3462 
3466  bool Equals(ExportSTLOptionsKit const & in_kit) const;
3467 
3471  bool operator==(ExportSTLOptionsKit const & in_kit) const;
3472 
3476  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
3477 
3478 
3484  ExportSTLOptionsKit & SetBinary(bool in_state);
3485 
3491  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3492 
3499  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3500 
3506  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
3507 
3513  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
3514 
3521  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
3522 
3523 
3526  ExportSTLOptionsKit & UnsetBinary();
3527 
3530  ExportSTLOptionsKit & UnsetTessellationLevel();
3531 
3534  ExportSTLOptionsKit & UnsetTessellationAccuracy();
3535 
3538  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
3539 
3542  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
3543 
3546  ExportSTLOptionsKit & UnsetEverything();
3547 
3548 
3552  bool ShowBinary(bool & out_state) const;
3553 
3561  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3562 
3566  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
3567 
3571  bool ShowCurrentTessellationRetention(bool & out_state) const;
3572 
3576  bool ShowMaximumEdgeLength(double & out_length) const;
3577  };
3578 
3580  class EXCHANGE_API ExportU3DOptionsKit : public HPS::Sprocket
3581  {
3582  public:
3585 
3588  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
3589 
3593 
3594  virtual ~ExportU3DOptionsKit();
3595 
3596  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportU3DOptionsKit; }
3597 
3601  static ExportU3DOptionsKit GetDefault();
3602 
3605  void Set(ExportU3DOptionsKit const & in_kit);
3606 
3609  void Show(ExportU3DOptionsKit & out_kit) const;
3610 
3614  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
3615 
3619  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
3620 
3623  bool Empty() const;
3624 
3628  bool Equals(ExportU3DOptionsKit const & in_kit) const;
3629 
3633  bool operator==(ExportU3DOptionsKit const & in_kit) const;
3634 
3638  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
3639 
3640 
3646  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
3647 
3652  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
3653 
3654 
3657  ExportU3DOptionsKit & UnsetVersion();
3658 
3661  ExportU3DOptionsKit & UnsetCompression();
3662 
3665  ExportU3DOptionsKit & UnsetEverything();
3666 
3667 
3671  bool ShowVersion(U3D::Version & out_version) const;
3672 
3676  bool ShowCompression(unsigned char & out_level) const;
3677  };
3678 
3680  class EXCHANGE_API ExportXMLOptionsKit : public HPS::Sprocket
3681  {
3682  public:
3685 
3688  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
3689 
3693 
3694  virtual ~ExportXMLOptionsKit();
3695 
3696  HPS::Type ObjectType() const { return HPS::Type::ExchangeExportXMLOptionsKit; }
3697 
3701  static ExportXMLOptionsKit GetDefault();
3702 
3705  void Set(ExportXMLOptionsKit const & in_kit);
3706 
3709  void Show(ExportXMLOptionsKit & out_kit) const;
3710 
3714  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
3715 
3719  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
3720 
3723  bool Empty() const;
3724 
3728  bool Equals(ExportXMLOptionsKit const & in_kit) const;
3729 
3733  bool operator==(ExportXMLOptionsKit const & in_kit) const;
3734 
3738  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
3739 
3740 
3746  ExportXMLOptionsKit & SetMetadata(bool in_state);
3747 
3753  ExportXMLOptionsKit & SetTransformations(bool in_state);
3754 
3760  ExportXMLOptionsKit & SetMaterials(bool in_state);
3761 
3762 
3765  ExportXMLOptionsKit & UnsetMetadata();
3766 
3769  ExportXMLOptionsKit & UnsetTransformations();
3770 
3773  ExportXMLOptionsKit & UnsetMaterials();
3774 
3777  ExportXMLOptionsKit & UnsetEverything();
3778 
3779 
3783  bool ShowMetadata(bool & out_state) const;
3784 
3788  bool ShowTransformations(bool & out_state) const;
3789 
3793  bool ShowMaterials(bool & out_state) const;
3794  };
3795 
3797  class EXCHANGE_API TessellationOptionsKit : public HPS::Sprocket
3798  {
3799  public:
3802 
3806 
3810 
3811  virtual ~TessellationOptionsKit();
3812 
3813  HPS::Type ObjectType() const { return HPS::Type::ExchangeTessellationOptionsKit; }
3814 
3818  static TessellationOptionsKit GetDefault();
3819 
3822  void Set(TessellationOptionsKit const & in_kit);
3823 
3826  void Show(TessellationOptionsKit & out_kit) const;
3827 
3831  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
3832 
3836  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
3837 
3840  bool Empty() const;
3841 
3845  bool Equals(TessellationOptionsKit const & in_kit) const;
3846 
3850  bool operator==(TessellationOptionsKit const & in_kit) const;
3851 
3855  bool operator!=(TessellationOptionsKit const & in_kit) const;
3856 
3857 
3861  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
3862 
3869  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3870 
3876  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true);
3877 
3881  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
3882 
3886  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
3887 
3888 
3891  TessellationOptionsKit & UnsetLevel();
3892 
3895  TessellationOptionsKit & UnsetAccuracy();
3896 
3899  TessellationOptionsKit & UnsetUVPointPreservation();
3900 
3903  TessellationOptionsKit & UnsetMaximumEdgeLength();
3904 
3907  TessellationOptionsKit & UnsetEverything();
3908 
3909 
3917  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3918 
3923  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals) const;
3924 
3928  bool ShowUVPointPreservation(bool & out_state) const;
3929 
3933  bool ShowMaximumEdgeLength(double & out_length) const;
3934  };
3935 
3941  class EXCHANGE_API CommonMeasurementOperator : public Operator
3942  {
3943  public:
3944  enum class Tags
3945  {
3946  Name = 0,
3947  MeasurementType,
3948  Radius,
3949  Inverted,
3950  VectorX,
3951  VectorY,
3952  VectorZ,
3953  };
3954 
3955  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
3956 
3958  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_ExchangeCommonMeasurementOperator"; }
3959 
3960  virtual void OnViewAttached() OVERRIDE;
3961  virtual void OnViewDetached() OVERRIDE;
3962 
3963  Exchange::CADModel GetCADModel() const;
3964  void SetCADModel(Exchange::CADModel const & in_cad_model);
3965 
3967  size_t GetPrecision() const;
3968 
3971  void SetPrecision(size_t in_precision);
3972 
3974  MaterialMappingKit GetMaterial() const;
3975 
3978  void SetMaterial(MaterialMappingKit const & in_material_mapping);
3979 
3981  TextAttributeKit GetTextAttributes() const;
3982 
3985  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
3986 
3988  SegmentKey GetMeasurementSegment() const;
3989 
3991  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
3992 
3993  /* Deletes all measurements */
3994  void DeleteMeasurements();
3995 
3996  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
3997  {
3998  public:
4001  {
4002  channel = GetClassID();
4003  consumable = false;
4004  }
4005 
4006  MeasurementInsertedEvent(HPS::Key const & in_measurement_key) : Event()
4007  {
4008  channel = GetClassID();
4009  consumable = false;
4010  measurement_key = in_measurement_key;
4011  }
4012 
4015  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
4016  {
4017  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
4018  {
4019  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
4020  measurement_key = that.measurement_key;
4021  }
4022  else
4023  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
4024  }
4025 
4027 
4030  Event * Clone() const
4031  {
4032  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
4033  return new_event;
4034  }
4035 
4036  Key measurement_key;
4037  };
4038 
4039  protected:
4040  Exchange::CADModel cad_model;
4041  size_t measurement_precision;
4042  UTF8 units;
4043  MaterialMappingKit materials;
4044  TextAttributeKit text_attributes;
4045  SegmentKey measurement_segment;
4046  GlyphDefinition left_arrow;
4047  GlyphDefinition right_arrow;
4048  SelectionOptionsKit selection_options;
4049  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
4050  Vector camera_direction;
4051  PortfolioKey portfolio;
4052  SegmentKey style_segment;
4053  HighlightOptionsKit highlight_options;
4054  HPS::UTF8Array measurement_operators;
4055 
4056  static size_t length_measurement_index;
4057  static size_t radius_measurement_index;
4058  static size_t distance_measurement_index;
4059  static size_t angle_measurement_index;
4060 
4061  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
4062  void GetUnits();
4063  void SetGlyphColor();
4064  void GetCameraDirection();
4065  void SetupConstructionSegment();
4066  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
4067  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
4068  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
4069  float GetModelScale(Exchange::Component const & component);
4070  double ConvertFromMillimeters(double in_measurement, UTF8 const & in_measurement_units);
4071  };
4072 
4125  {
4126  public:
4127  enum class MeasurementType
4128  {
4129  PointToPoint,
4130  EdgeAndRadius,
4131  FeatureToFeature,
4132  FaceAngle,
4133  };
4134 
4135  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
4136 
4138  virtual HPS::UTF8 GetName() const OVERRIDE{ return "HPS_ExchangeMeasurementOperator"; }
4139 
4140  virtual void OnViewAttached() OVERRIDE;
4141  virtual void OnViewDetached() OVERRIDE;
4142 
4147  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
4148 
4152  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
4153 
4161  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
4162 
4166  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
4167 
4168  /* Sets the type of measurement to insert.
4169  * \param in_measurement_type The type of measurement to insert.*/
4170  void SetMeasurementType(MeasurementType in_measurement_type);
4171 
4174  MeasurementType GetMeasurementType();
4175 
4176  /* Whether measurable geometry should be highlighted when mousing over it
4177  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it. */
4178  void SetMouseOverHighlighting(bool in_highlighting);
4179 
4180  /* Whether measurable geometry should be highlighted when mousing over it
4181  * \param in_highlighting Whether measurable geometry should be highlighted when mousing over it.
4182  * \param in_highlight_options_kit The highlight kit used for mouse over highlights */
4183  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
4184 
4185  /* Whether measurable geometry is highlighted when mousing over it
4186  * \return <span class='code'>true</span> if measurable geometry is highlighted on mouse over, <span class='code'>false</span> otherwise. */
4187  bool GetMouseOverHighlighting();
4188 
4189  /* Returns the highlight option kit currently used for mouse over highlighting.
4190  * \return the highlight option kit currently used for mouse over highlighting. */
4191  HighlightOptionsKit GetHighlightOptions();
4192 
4193  private:
4194  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
4195  {
4196  Circle,
4197  Line,
4198  Generic,
4199  };
4200 
4201  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
4202  {
4203  public:
4204  Surface();
4205 
4206  enum class SurfaceType
4207  {
4208  Plane,
4209  ConeOrCylinder,
4210  Unsupported,
4211  };
4212 
4213  SurfaceType surface_type; //the type of surface being measured
4214  Point center; //the center point of the surface
4215  Vector normal; //the center line of surfaces of type Cylinder or Cone
4216  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
4217  ComponentPath path; //the component path to this surface
4218  };
4219 
4220  //bookkeeping
4221  MeasurementType measurement_type; //the type of measurement to be inserted
4222  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
4223  TouchID tracked_touch_id;
4224  SegmentKey current_measurement; //segment of the measurement being inserted / edited
4225  bool operator_active; //whether a measurement is in progress
4226  bool end_measurement; //whether we should end the current measurement
4227 
4228  //measurement anchors
4229  size_t anchors; //valid for point-to-point and face-angle measurements
4230  bool anchors_in_place; //true if all the anchors have been placed
4231  Point first_click_position; //position of the first anchor
4232  Point second_click_position; //position of the second anchor
4233 
4234  //geometry for linear measurements
4235  MarkerKey anchor_one; //marker corresponding to the start of the measurement
4236  MarkerKey anchor_two; //marker corresponding to the end of the measurement
4237  LineKey distance_line; //a line representing the distance measured
4238  LineKey leader_line_one; //line connecting the first anchor point to the distance line
4239  LineKey leader_line_two; //line connecting the second anchor point to the distance line
4240  Point distance_point_one; //intersection of leader_line_one and distance_line
4241  Point distance_point_two; //intersection of leader_line_two and distance_line
4242  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
4243  TextKey text; //text representing the measurement and units
4244  UTF8 text_string; //the contents of the text
4245  Vector measurement_direction; //the direction of the measurement
4246  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
4247  Vector explicit_direction; //used if use_explicit_direction is true
4248 
4249  //geometry for radius measurement
4250  MarkerKey center_marker; //marker representing the center of the circle
4251  Point circle_center; //circle center
4252  float radius; //circle radius
4253 
4254  //edge specific data
4255  LineKey edge_line; //the edge being measured
4256  double edge_length; //length of the measured edge
4257  EdgeType edge_type; //the type of edge being measured
4258 
4259  //feature-to-feature specific data
4260  Surface surface_one; //data related to first selected surface
4261  Surface surface_two; //data related to second selected surface
4262  Plane measurement_plane; //the measurement plane
4263  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
4264 
4265  //angle specific data
4266  Vector leader_line_one_direction; //the direction of the first leader line
4267  Vector leader_line_two_direction; //the direction of the second leader line
4268  Vector first_face_normal; //the normal of the first selected face
4269  Vector second_face_normal; //the normal of the second selected face
4270  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'
4271  CircularArcKey measurement_arc; //an arc representing the measured angle
4272  LineKey line_to_leader_line; //line extending from one anchor to a leader line
4273  Vector mid_point_direction;
4274 
4275  //selection kits
4276  SelectionOptionsKit point_to_point_selection;
4277  SelectionOptionsKit edge_radius_selection;
4278  SelectionOptionsKit feature_to_feature_selection;
4279  SelectionOptionsKit angle_selection;
4280 
4281  //highlighting
4282  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
4283  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
4284  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
4285  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
4286  KeyPath highlighted_path; //highlighted_path
4287  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
4288  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
4289 
4290  //input handling
4291  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
4292  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
4293  bool InputUp(WindowKey & in_window);
4294  void ResetMeasurement();
4295 
4296  //inserting measurements
4297  void InsertPointToPointMeasurement(Point const & in_world_point);
4298  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
4299  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4300  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
4301  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
4302  void InvertMeasuredAngle(WindowKey & in_window);
4303  void AdjustLineToCursor(Point const & cursor_position);
4304 
4305  //saving measurements
4306  void TagMeasurement();
4307  void TagPointToPointMeasurement();
4308  void TagEdgeMeasurement();
4309  void TagRadiusMeasurement();
4310  void TagGenericEdgeMeasurement();
4311  void TagFeatureToFeatureMeasurement();
4312  void TagAngleMeasurement();
4313 
4314  //restoring measurements
4315  void RestoreMeasurement(SegmentKey const & measurement_segment);
4316  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
4317  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
4318  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
4319  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
4320  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
4321  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
4322  void RestoreLinearMeasurement(SegmentKey const & measurement_segment);
4323 
4324  //topology functions
4325  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
4326  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
4327  void PlaneToCenterLineDistance();
4328  void PlaneToPlaneDistance();
4329  void LineToLineDistance();
4330  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);
4331  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
4332  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
4333  bool IsPlane(Exchange::Component const & face_component);
4334  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
4335  };
4336 
4337 private:
4339  Exchange();
4340 };
4341 
4342 }
4343 
4344 #endif
Definition: hps.h:6070
Definition: sprk_exchange.h:3101
Level
Definition: sprk_exchange.h:717
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2855
Definition: sprk_exchange.h:43
Definition: sprk_exchange.h:819
Definition: sprk.h:237
HPS::Type ObjectType() const
Definition: sprk_exchange.h:224
Definition: sprk_exchange.h:960
Definition: sprk_exchange.h:3941
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5579
Units
Definition: sprk_exchange.h:62
Definition: sprk.h:66
Simplification
Definition: sprk_exchange.h:2099
Definition: sprk.h:100
Definition: sprk_exchange.h:527
Version
Definition: sprk_exchange.h:865
Definition: sprk_exchange.h:2356
Definition: sprk_exchange.h:727
Definition: sprk_exchange.h:626
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:3958
HPS::Type ObjectType() const
Definition: sprk_exchange.h:608
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3696
Definition: hps.h:1639
Format
Definition: sprk_exchange.h:807
HPS::Type ObjectType() const
Definition: sprk_exchange.h:654
Definition: sprk_exchange.h:3680
Definition: hps.h:42942
Format
Definition: sprk_exchange.h:965
Definition: hps.h:7445
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3117
Type
Definition: sprk_exchange.h:708
Definition: hps.h:15152
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2678
Definition: sprk_exchange.h:390
Definition: sprk_exchange.h:474
Definition: sprk_exchange.h:251
HPS::Type ObjectType() const
Definition: sprk_exchange.h:371
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_exchange.h:4138
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2972
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:4015
HPS::Type ObjectType() const
Definition: sprk_exchange.h:100
Definition: sprk_exchange.h:192
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3434
HPS::Type ObjectType() const
Definition: sprk_exchange.h:277
Definition: sprk_exchange.h:2839
Merging
Definition: sprk_exchange.h:2108
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2143
Field
Definition: sprk_exchange.h:797
Definition: hps.h:37546
HPS::Type ObjectType() const
Definition: sprk_exchange.h:914
Definition: sprk_exchange.h:2561
Definition: sprk_exchange.h:2121
Limit
Definition: sprk_exchange.h:732
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3273
TessellationLevel
Definition: sprk_exchange.h:779
Definition: sprk_exchange.h:703
Definition: sprk_exchange.h:3418
Definition: sprk_exchange.h:79
Definition: sprk_exchange.h:792
Definition: hps.h:4251
Definition: hps.h:6818
Definition: hps.h:42333
Definition: sprk_exchange.h:345
Definition: hps.h:39320
Definition: hps.h:42729
AnnotationCaptureFitting
Definition: sprk_exchange.h:696
Definition: sprk_exchange.h:3580
Definition: sprk_exchange.h:765
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2577
Definition: hps.h:14566
intptr_t GetChannel() const
Definition: hps.h:6203
Definition: sprk_exchange.h:860
SessionColor
Definition: sprk_exchange.h:843
Definition: sprk.h:1614
Definition: hps.h:43052
Definition: hps.h:40300
Definition: hps.h:41998
Definition: sprk_exchange.h:434
Definition: hps.h:6170
Definition: hps.h:13018
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3813
Definition: sprk_exchange.h:4124
Definition: sprk.h:445
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1180
BRepCompression
Definition: sprk_exchange.h:824
Definition: sprk_parasolid.h:39
BRepMode
Definition: sprk_exchange.h:681
Definition: sprk.h:1876
ComponentType
Definition: sprk.h:1619
Accuracy
Definition: sprk_exchange.h:749
Definition: sprk_exchange.h:2662
Definition: sprk.h:2187
Content
Definition: sprk_exchange.h:770
Definition: sprk_exchange.h:1158
HPS::Type ObjectType() const
Definition: sprk_exchange.h:2378
HPS::Type ObjectType() const
Definition: sprk_exchange.h:555
Definition: sprk.h:2286
static MouseButtons ButtonLeft()
Definition: hps.h:42451
Definition: hps.h:7364
Definition: sprk_exchange.h:838
AccurateEdges
Definition: sprk_exchange.h:2090
Event * Clone() const
Definition: sprk_exchange.h:4030
HPS::Type ObjectType() const
Definition: sprk_exchange.h:416
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3596
Definition: hps.h:8942
HPS::Type ObjectType() const
Definition: sprk_exchange.h:173
Definition: sprk_exchange.h:580
Definition: hps.h:22318
Healing
Definition: sprk_exchange.h:2081
Definition: sprk.h:2372
Definition: hps.h:28448
Definition: sprk_exchange.h:877
Definition: sprk.h:1065
Definition: sprk_exchange.h:2076
static Model CreateModel(char const *in_name="")
Definition: sprk_exchange.h:2956
Definition: sprk_exchange.h:141
Definition: hps.h:37084
Definition: sprk_exchange.h:3797
HPS::Type ObjectType() const
Definition: sprk_exchange.h:502
Definition: hps.h:38132
Definition: sprk_exchange.h:3257