Positioning_Constraint.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
//  NX JA API的C++接口头文件
//--------------------------------------------------------------------------
//
//  源文件:
//     Positioning_Constraint.ja
//
//  生成工具:
//     apiwrap
//
//  警告:
//    此文件为自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/NXObject.hxx>
#include <NXOpen/Positioning_ConstraintReference.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_positioning_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    namespace Positioning
    {
        class Constraint;
    }
    class Expression;
    class NXObject;
    namespace Positioning
    {
        class ConstraintReference;
    }
    namespace Positioning
    {
        class DisplayedConstraint;
    }
    namespace Positioning
    {
        class _ConstraintBuilder;
        class ConstraintImpl;
        class NXOPENCPP_POSITIONINGEXPORT  Constraint : public NXOpen::NXObject
        {
            public: enum Type
            {
                TypeUndefined,
                TypeTouch,
                TypeConcentric,
                TypeFix,
                TypeDistance,
                TypeParallel,
                TypePerpendicular,
                TypeCenter12,
                TypeCenter22,
                TypeAngle,
                TypeFit,
                TypeBond,
                TypeOrientAngle,
                TypeSplineData,
                TypeSplineLength,
                TypeLinearPattern,
                TypeCircularPattern,
                TypeLinear2dPattern,
                TypeRadiantPattern,
                TypeAlignLock,
                TypeCommonOffsetTransform,
                TypeHinge,
                TypeSlider,
                TypeCylindrical,
                TypeBall,
                TypeScrew,
                TypeGear,
                TypeRackPinion,
                TypeCable
            };

            public: enum Alignment
            {
                AlignmentInferAlign,
                AlignmentCoAlign,
                AlignmentContraAlign
            };

            public: enum SolverStatus
            {
                SolverStatusNewlyCreated,
                SolverStatusSuppressed,
                SolverStatusOutOfDate,
                SolverStatusOverConstrained,
                SolverStatusNotConsistentDims,
                SolverStatusNotConsistentOther,
                SolverStatusNotConsistentUnknown,
                SolverStatusBetweenFixed,
                SolverStatusNotSolved,
                SolverStatusSolved,
                SolverStatusCannotSolve,
                SolverStatusDelayed,
                SolverStatusIgnoredInArrangement,
                SolverStatusInternallyInconsistent,
                SolverStatusUnloadedGeometry,
                SolverStatusPendingConvertedMc,
                SolverStatusConflictingWithWave,
                SolverStatusInconsistentLimits,
                SolverStatusBeyondLimits
            };

            public: enum SplineType
            {
                SplineTypeByPoles,
                SplineTypeByPoints,
                SplineTypeInvalid
            };
            private: ConstraintImpl * m_constraint_impl;
            private: friend class  _ConstraintBuilder;
            protected: Constraint();
public: ~Constraint();
            public: std::vector<NXOpen::Positioning::ConstraintReference *> GetReferences
            (
            );
            public: void DeleteConstraintReference
            (
                NXOpen::Positioning::ConstraintReference * constraintReference 
            );
            public: NXOpen::Positioning::ConstraintReference * CreateConstraintReference
            (
                NXOpen::NXObject * movableObject ,
                NXOpen::NXObject * geometry ,
                bool usesAxis ,
                bool isIndirect 
            );
            public: NXOpen::Positioning::ConstraintReference * CreateConstraintReference
            (
                NXOpen::NXObject * movableObject ,
                NXOpen::NXObject * geometry ,
                bool usesAxis ,
                bool isIndirect ,
                bool usePortRotate 
            );
            public: void EditConstraintReference
            (
                NXOpen::Positioning::ConstraintReference * constraintReference ,
                NXOpen::NXObject * movableObject ,
                NXOpen::NXObject * geometry ,
                bool usesAxis ,
                bool isIndirect ,
                bool usePortRotate 
            );
            public: NXOpen::Positioning::Constraint::Type ConstraintType
            (
            );
            public: void SetConstraintType
            (
                NXOpen::Positioning::Constraint::Type constraintType 
            );
            public: void SetConstraintAlignment
            (
                NXOpen::Positioning::Constraint::Alignment alignment 
            );
            public: NXOpen::Positioning::Constraint::Alignment ConstraintAlignment
            (
            );
            public: void FlipAlignment
            (
            );
            public: void SetSuppressed
            (
                bool suppressed 
            );
            public: bool Suppressed
            (
            );
            public: void SetExpression
            (
                const NXString & expression 
            );
            void SetExpression
            (
                const char * expression 
            );
            public: NXOpen::Expression * Expression
            (
            );
            public: NXOpen::Positioning::Constraint::SolverStatus GetConstraintStatus
            (
            );
            public: void SetAlignmentHint
            (
                NXOpen::Positioning::Constraint::Alignment alignment 
            );
            public: void SetPersistent
            (
                bool persistent 
            );
            public: bool Persistent
            (
            );
            public: void SetAutomatic
            (
                bool isauto 
            );
            public: bool Automatic
            (
            );
            public: void GenerateConversionReport
            (
                std::vector<NXString> & lines 
            );
            public: void ReverseDirection
            (
            );
            public: NXOpen::Positioning::Constraint::SplineType SplinePointsType
            (
            );
            public: void SetSplinePointsType
            (
                NXOpen::Positioning::Constraint::SplineType splineType 
            );
            public: NXOpen::Positioning::DisplayedConstraint * GetDisplayedConstraint
            (
            );
            public: bool ExpressionDriven
            (
            );
            public: void SetExpressionDriven
            (
                bool expressionDriven 
            );
            public: bool UpperLimitEnabled
            (
            );
            public: void SetUpperLimitEnabled
            (
                bool hasLimit 
            );
            public: bool LowerLimitEnabled
            (
            );
            public: void SetLowerLimitEnabled
            (
                bool hasLimit 
            );
            public: NXOpen::Expression * UpperLimitExpression
            (
            );
            public: NXString UpperLimitRightHandSide
            (
            );
            public: void SetUpperLimitRightHandSide
            (
                const NXString & limitRightHandSide 
            );
            void SetUpperLimitRightHandSide
            (
                const char * limitRightHandSide 
            );
            public: NXOpen::Expression * LowerLimitExpression
            (
            );
            public: NXString LowerLimitRightHandSide
            (
            );
            public: void SetLowerLimitRightHandSide
            (
                const NXString & limitRightHandSide 
            );
            void SetLowerLimitRightHandSide
            (
                const char * limitRightHandSide 
            );
            public: void Renew
            (
            );
            public: NXOpen::Expression * SecondExpression
            (
            );
            public: NXString SecondExpressionRightHandSide
            (
            );
            public: void SetSecondExpressionRightHandSide
            (
                const NXString & secondExpressionRightHandSide 
            );
            void SetSecondExpressionRightHandSide
            (
                const char * secondExpressionRightHandSide 
            );
            public: bool SecondExpressionDriven
            (
            );
            public: void SetSecondExpressionDriven
            (
                bool secondExpressionDriven 
            );
            public: bool SecondUpperLimitEnabled
            (
            );
            public: void SetSecondUpperLimitEnabled
            (
                bool hasLimit 
            );
            public: bool SecondLowerLimitEnabled
            (
            );
            public: void SetSecondLowerLimitEnabled
            (
                bool hasLimit 
            );
            public: NXOpen::Expression * SecondUpperLimitExpression
            (
            );
            public: NXString SecondUpperLimitRightHandSide
            (
            );
            public: void SetSecondUpperLimitRightHandSide
            (
                const NXString & limitRightHandSide 
            );
            void SetSecondUpperLimitRightHandSide
            (
                const char * limitRightHandSide 
            );
            public: NXOpen::Expression * SecondLowerLimitExpression
            (
            );
            public: NXString SecondLowerLimitRightHandSide
            (
            );
            public: void SetSecondLowerLimitRightHandSide
            (
                const NXString & limitRightHandSide 
            );
            void SetSecondLowerLimitRightHandSide
            (
                const char * limitRightHandSide 
            );
            public: NXOpen::Expression * OffsetExpression
            (
            );
            public: NXString OffsetRightHandSide
            (
            );
            public: void SetOffsetRightHandSide
            (
                const NXString & offset 
            );
            void SetOffsetRightHandSide
            (
                const char * offset 
            );
            public: NXOpen::Positioning::ConstraintReference * CreateCouplerReference
            (
                NXOpen::NXObject * coupledConstraint 
            );
            public: void EditCouplerReference
            (
                NXOpen::Positioning::ConstraintReference * couplerReference ,
                NXOpen::NXObject * coupledConstraint 
            );
            public: void SetConstraintSecondAlignment
            (
                NXOpen::Positioning::Constraint::Alignment secondAlignment 
            );
            public: NXOpen::Positioning::Constraint::Alignment ConstraintSecondAlignment
            (
            );
        };
    }
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __GNUC__
#ifndef NX_NO_GCC_DEPRECATION_WARNINGS
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
#endif
#endif
#undef EXPORTLIBRARY