Session.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口JA API的头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Session.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件由程序自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/NXVariant.hxx>
#include <NXOpen/CAE_GRMSearch.hxx>
#include <NXOpen/Display_TransientText.hxx>
#include <NXOpen/ErrorList.hxx>
#include <NXOpen/BaseSession.hxx>
#include <NXOpen/PDM_PersistentSettings.hxx>
#include <NXOpen/PDM_SessionSettings.hxx>
#include <NXOpen/PartCleanup.hxx>
#include <NXOpen/TableEditorDefaultDataProvider.hxx>
#include <NXOpen/libnxopencpp_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    class Session;
    namespace AECDesign
    {
        class AECDesignSession;
    }
    namespace Appearance
    {
        class AppearanceUtils;
    }
    class AssembliesUtils;
    class AttributeManager;
    namespace AutomatedTesting
    {
        class TestingManager;
    }
    class BasePart;
    namespace CAE
    {
        class AfuManager;
    }
    namespace CAE
    {
        class CaeSession;
    }
    namespace CAE
    {
        class CurveOperation;
    }
    namespace CAE
    {
        namespace FTK
        {
            class DataManager;
        }
    }
    namespace CAE
    {
        namespace FTK
        {
            class FTKManager;
        }
    }
    namespace CAE
    {
        class GRMSearch;
    }
    namespace CAE
    {
        class Post;
    }
    namespace CAE
    {
        class ResultManager;
    }
    namespace CAE
    {
        namespace Xyplot
        {
            class XYPlotManager;
        }
}
    namespace CAM
    {
        class CAMSession;
    }
    namespace CollaborationApplication
    {
        class SessionManager;
    }
    class CollaborativeContentManager;
    class DMUSessionCollection;
    namespace DesignSimulation
    {
        class PerformancePredictorManager;
    }
    class DexManager;
    namespace Diagramming
    {
        class SheetManager;
    }
    namespace Display
    {
        class TransientText;
    }
    class DisplayManager;
    class DrawShapeTaskEnvironment;
    class DrawingUtils;
    class EngineeringFunction;
    class ErrorList;
    namespace Features
    {
        class CustomFeatureClassManager;
    }
    namespace Features
    {
        class FeatureColorManager;
    }
    namespace Features
    {
        class UserDefinedFeatureClassManager;
    }
    namespace Gateway
    {
        class BookmarkFile;
    }
    class ImplicitModelingTaskEnvironment;
    class Information;
    namespace Issue
    {
        class IssueManager;
    }
    class JournalManager;
    class LicenseManager;
    class LinkedPartManager;
    class ListingWindow;
    class LogFile;
    class MathUtils;
    class Measurement;
    namespace Mechatronics
    {
        class MechatronicsSession;
    }
    namespace MendixReporting
    {
        class CheckerDataStatus;
    }
    class MorphMeshTaskEnvironment;
    namespace Motion
    {
        class MotionSession;
    }
    namespace Motion
    {
        class MotionSimulation;
    }
    namespace Options
    {
        class OptionsManager;
    }
    namespace PDM
    {
        class ConfigurationManager;
    }
    namespace PDM
    {
        class PdmManager;
    }
    namespace PDM
    {
        class PdmSearchManager;
    }
    namespace PDM
    {
        class PdmSession;
    }
    namespace PDM
    {
        class PersistentSettings;
    }
    namespace PDM
    {
        class RequirementUtils;
    }
namespace PDM
    {
        class SessionSettings;
    }
    namespace PDM
    {
        class WebAppSession;
    }
    class PartCleanup;
    class PartCollection;
    class PolygonModelingTaskEnvironment;
    namespace Preferences
    {
        class SessionPreferences;
    }
    class PvtransManager;
    namespace Report
    {
        class ReportManager;
    }
    namespace Routing
    {
        class CustomManager;
    }
    namespace Routing
    {
        class DesignRuleManager;
    }
    namespace RoutingCommon
    {
        class CustomManager;
    }
    namespace SIM
    {
        namespace PostConfigurator
        {
            class PostConfiguratorManager;
        }
    }
    namespace ShipDesign
    {
        class ShipSession;
    }
    class Sketch;
    class SpreadsheetManager;
    namespace StructureDesign
    {
        class FrameTaskEnvironment;
    }
    namespace StructureDesign
    {
        class StructureDesignSession;
    }
    class StudioMaterialManager;
    class SubdivisionTaskEnvironment;
    class TableEditorDefaultDataProvider;
    class TaggedObject;
    class TextureModelingTaskEnvironment;
    namespace Tooling
    {
        class ToolingSession;
    }
    class TopologyOptimizationTaskEnvironment;
    class Update;
    namespace UserDefinedObjects
    {
        class UserDefinedClassManager;
    }
    namespace Validate
    {
        namespace Corrosion
        {
            class Manager;
        }
    }
    namespace Validate
    {
        class ValidationManager;
    }
    namespace Validate
    {
        class XmlComparator;
    }
    namespace VisualReporting
    {
        class VisualReportManager;
    }
    namespace Weld
    {
        class CustomManager;
    }
    namespace Weld
    {
        class WeldCpdUtils;
    }
    class SessionImpl;
    class NXOPENCPPEXPORT  Session : public NXOpen::BaseSession
    {
        public: enum LibraryUnloadOption
        {
            LibraryUnloadOptionImmediately = 1,
            LibraryUnloadOptionExplicitly,
            LibraryUnloadOptionAtTermination
        };

        public: enum UndoMarkId { UndoMarkIdDummyMember }; // 用作ID
        public: enum MarkVisibility
        {
            MarkVisibilityVisible ,
            MarkVisibilityInvisible ,
            MarkVisibilityAnyVisibility
        };

        public: enum ProjectAssignmentObjectType
        {
            ProjectAssignmentObjectTypePart,
            ProjectAssignmentObjectTypePartrev,
            ProjectAssignmentObjectTypeAppdata,
            ProjectAssignmentObjectTypeCollaborativeProductDevelopmentDe
        };

        public: enum ProjectAssignmentState
        {
            ProjectAssignmentStateNone = 10,
            ProjectAssignmentStatePartial,
            ProjectAssignmentStateFull
        };

        public:
        struct UndoMarkData
        {
            public: NXOpen::Session::UndoMarkId Id;
            public: NXOpen::Session::MarkVisibility Visibility;
            public: UndoMarkData() :
                Id((NXOpen::Session::UndoMarkId)0),
                Visibility((NXOpen::Session::MarkVisibility)0)
{
            }
            public: UndoMarkData(NXOpen::Session::UndoMarkId idInitial ,
                    NXOpen::Session::MarkVisibility visibilityInitial ) :
                Id(idInitial),
                Visibility(visibilityInitial)
            {
            }
        };

        public: enum TransientPartPolicy
        {
            TransientPartPolicyRetainTransience,
            TransientPartPolicyRemoveTransience
        };

        public: enum CustomerDefaultSearchOption
        {
            CustomerDefaultSearchOptionNone ,
            CustomerDefaultSearchOptionMetric ,
            CustomerDefaultSearchOptionEnglish
        };
        private: SessionImpl * m_session_impl;
        private: static Session *theSession;
        public: static Session *GetSession();
        private: friend class  _SessionBuilder;
        protected: Session();
        public: ~Session();
        public: NXOpen::Session::UndoMarkId SetUndoMark
        (
            NXOpen::Session::MarkVisibility markVisibility  ,
            const NXString & name 
        );
        NXOpen::Session::UndoMarkId SetUndoMark
        (
            NXOpen::Session::MarkVisibility markVisibility  ,
            const char * name 
        );
        public: void UndoToLastVisibleMark
        (
        );
        public: void UndoLastNVisibleMarks
        (
            int n ,
            bool* marksRecycled ,
            bool* undoUnavailable 
        );
        public: void Redo
        (
        );
        public: void UndoToMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        void UndoToMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: void UndoToMarkWithStatus
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        void UndoToMarkWithStatus
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: void DeleteUndoMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        void DeleteUndoMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: void DeleteUndoMarksUpToMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName ,
            bool deleteAllIfNotFound 
        );
        void DeleteUndoMarksUpToMark
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName ,
            bool deleteAllIfNotFound 
        );
        public: void DeleteAllUndoMarks
        (
        );
        public: void SetUndoMarkVisibility
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName ,
            NXOpen::Session::MarkVisibility visibility 
        );
        void SetUndoMarkVisibility
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName ,
            NXOpen::Session::MarkVisibility visibility 
        );
        public: NXOpen::Session::MarkVisibility GetUndoMarkVisibility
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        NXOpen::Session::MarkVisibility GetUndoMarkVisibility
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: NXString GetUndoMarkName
        (
            NXOpen::Session::UndoMarkId markId 
        );
        public: void SetUndoMarkName
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        void SetUndoMarkName
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: bool DoesUndoMarkExist
        (
            NXOpen::Session::UndoMarkId markId ,
            const NXString & markName 
        );
        bool DoesUndoMarkExist
        (
            NXOpen::Session::UndoMarkId markId ,
            const char * markName 
        );
        public: std::vector<NXOpen::Session::UndoMarkData> GetAllUndoMarks
        (
            NXOpen::Session::MarkVisibility visibility 
        );
        public: std::vector<NXOpen::Session::UndoMarkData> GetAllVisibleUndoMarks
        (
        );
        public: NXOpen::Session::UndoMarkId GetNewestUndoMark
        (
            NXOpen::Session::MarkVisibility visibility 
        );
        public: NXOpen::Session::UndoMarkId NewestVisibleUndoMark
        (
        );
        public: void BeginTaskEnvironment
        (
        );
        public: void DeleteUndoMarksSetInTaskEnvironment
        (
        );
        public: void EndTaskEnvironment
        (
        );
        public: bool IsInTaskEnvironment
        (
        );
        public: NXOpen::Sketch * ActiveSketch
        (
        );
        public: NXOpen::PartCleanup * NewPartCleanup
        (
        );
        public: NXOpen::ErrorList * NewErrorList
        (
        );
        public: NXOpen::PDM::SessionSettings * NewDatabaseSessionOptions
        (
        );
        public: NXOpen::PDM::PersistentSettings * NewDatabasePersistentOptions
        (
        );
        public: NXOpen::CAE::GRMSearch * NewCaeGrmsearch
        (
        );
        public: NXString ExecutingJournal
        (
        );
        public: std::vector<NXOpen::NXVariant> ExecuteGrip
        (
            const NXString & gripExecutable ,
            const std::vector<NXOpen::NXVariant> & inputArgs 
        );
        std::vector<NXOpen::NXVariant> ExecuteGrip
        (
            const char * gripExecutable ,
            const std::vector<NXOpen::NXVariant> & inputArgs 
        );
        public: NXOpen::NXVariant Execute
        (
            const NXString & libName ,
            const NXString & className ,
            const NXString & methodName ,
            const std::vector<NXOpen::NXVariant> & inputArgs 
        );
        NXOpen::NXVariant Execute
        (
            const char * libName ,
            const char * className ,
            const char * methodName ,
            const std::vector<NXOpen::NXVariant> & inputArgs 
        );
        public: NX_DEPRECATED("在NX2406.0.0中已弃用。请使用NXOpen::Session::Execute代替。") void ExecuteWithStringArguments
        (
            const NXString & libName ,
            const NXString & entryPointName ,
            std::vector<NXString> & inputArgs 
        );
        void ExecuteWithStringArguments
        (
            const char * libName ,
            const char * entryPointName ,
            std::vector<NXString> & inputArgs 
        );
        public: void CreateCamSession
        (
        );
        public: bool IsCamSessionInitialized
        (
        );
        public: void CreateInspectionSession
        (
        );
        public: bool IsInspectionSessionInitialized
        (
        );
        public: void SetTransientPartPersistencePolicy
        (
            NXOpen::Session::TransientPartPolicy policy 
        );
        public: NXOpen::Session::TransientPartPolicy TransientPartPersistencePolicy
        (
        );
        public: NXString GetProperty
        (
            NXOpen::TaggedObject * object ,
            const NXString & propertyName 
        );
        NXString GetProperty
        (
            NXOpen::TaggedObject * object ,
            const char * propertyName 
        );
        public: void SetProperty
        (
            NXOpen::TaggedObject * object ,
            const NXString & propertyName ,
            const NXString & value 
        );
        void SetProperty
        (
            NXOpen::TaggedObject * object ,
            const char * propertyName ,
            const char * value 
        );
        public: std::vector<NXString> GetNamedProperties
        (
            NXOpen::TaggedObject * object 
        );
        public: std::vector<NXString> GetClasses
        (
        );
        public: void GetNamedProperties
        (
            const NXString & className ,
            std::vector<NXString> & properties ,
            std::vector<NXString> & propertyTypes 
        );
        void GetNamedProperties
        (
            const char * className ,
            std::vector<NXString> & properties ,
            std::vector<NXString> & propertyTypes 
        );
        public: void CleanUpFacetedFacesAndEdges
        (
        );
        public: void AssignRemoveProjects
        (
            std::vector<NXString> & cliNames ,
            const std::vector<NXOpen::Session::ProjectAssignmentObjectType> & objectTypes ,
            std::vector<NXString> & projectNames ,
            const std::vector<NXOpen::Session::ProjectAssignmentState> & assignmentStates 
        );
        public: NXString GetEnvironmentVariableValue
        (
            const NXString & envVaribable 
        );
        NXString GetEnvironmentVariableValue
        (
            const char * envVaribable 
        );
        public: bool IsBatch
        (
        );
        public: void SetEnvironmentVariableValue
        (
            const NXString & envVaribable ,
            const NXString & envValue 
        );
        void SetEnvironmentVariableValue
        (
            const char * envVaribable ,
            const char * envValue 
        );
        public: bool EnableRedo
        (
            bool enableRedo 
        );
        public: NXOpen::Display::TransientText * NewTransientText
        (
        );
        public: void AssignRemoveProjectsBasedOnPartOccs
        (
            const std::vector<NXOpen::TaggedObject *> & partOccs ,
            const std::vector<NXOpen::Session::ProjectAssignmentObjectType> & objectTypes ,
            std::vector<NXString> & projectNames ,
            const std::vector<NXOpen::Session::ProjectAssignmentState> & assignmentStates 
        );
        public: void ApplicationSwitchOnActiveDisplayedPart
        (
        );
        public: void ApplicationSwitchImmediate
        (
            const NXString & applicationName 
        );
        void ApplicationSwitchImmediate
        (
            const char * applicationName 
        );
        public: NXString ApplicationName
        (
        );
        public: NXOpen::TableEditorDefaultDataProvider * CreateTableEditorDefaultDataProvider
        (
            NXOpen::BasePart * part 
        );
        public: bool DeleteTransientDynamicSectionCutData
        (
        );
        public: void ExitPartNavigator
        (
        );
        public: void OpenPartNavigator
        (
        );
        public: bool IsPartNavigatorOpen
        (
        );
        public: bool IsPartNavigatorFrozen
        (
        );
        public: void FreezePartNavigator
        (
        );
        public: void UnfreezePartNavigator
        (
        );
        public: void GetMinimallyLoadedParts
        (
            std::vector<NXOpen::BasePart *> & minimallyLoadedParts 
        );

        public: NXString GetTranslatedString
        (
            const NXString & fileName ,
            const NXString & uniqueID ,
            const NXString & stringToTranslate ,
            const NXString & context 
        );
        NXString GetTranslatedString
        (
            const char * fileName ,
            const char * uniqueID ,
            const char * stringToTranslate ,
            const char * context 
        );

        public: NXString ReleaseNumber
        (
        );

        public: NXString FullReleaseNumber
        (
        );

        public: bool IsFunctionalRelease
        (
        );
        public: int CompatibleBaseRelease
        (
        );

        public: NXString GroupBuild
        (
        );

        public: void CreateRoutingSession
        (
        );
        public: bool GetCustomerDefaultValue
        (
            const NXString & defaultName ,
            NXOpen::Session::CustomerDefaultSearchOption customerDefaultSearchOption  ,
            NXString* defaultValue 
        );
        bool GetCustomerDefaultValue
        (
            const char * defaultName ,
            NXOpen::Session::CustomerDefaultSearchOption customerDefaultSearchOption  ,
            NXString* defaultValue 
        );
        public: NXOpen::CAE::AfuManager *AfuManager();
        public: NXOpen::DexManager *DexManager();
        public: NXOpen::PvtransManager *PvtransManager();
        public: NXOpen::CAE::FTK::FTKManager *FTKManager();
        public: NXOpen::CAE::Post *Post();
        public: NXOpen::CAE::ResultManager *ResultManager();
        public: NXOpen::CAE::CaeSession *CaeSession();
        public: NXOpen::Update *UpdateManager();
        public: NXOpen::PartCollection *Parts();
        public: NXOpen::Weld::CustomManager *WeldCustomManager();
        public: NXOpen::Validate::ValidationManager *ValidationManager();

        public: NXOpen::MendixReporting::CheckerDataStatus *CheckerDataStatus();

        public: NXOpen::AutomatedTesting::TestingManager *AutomatedTestingManager();

        public: NXOpen::ListingWindow *ListingWindow();
        public: NXOpen::SpreadsheetManager *SpreadsheetManager();
        public: NXOpen::DisplayManager *DisplayManager();
        public: NXOpen::MathUtils *MathUtils();
        public: NXOpen::EngineeringFunction *EngineeringFunction();
        public: NXOpen::Measurement *Measurement();
        public: NXOpen::Information *Information();
        public: NXOpen::Preferences::SessionPreferences *Preferences();
        public: NXOpen::LogFile *LogFile();
        public: NXOpen::CAM::CAMSession *CAMSession();
        public: NXOpen::Routing::DesignRuleManager *DesignRuleManager();
        public: NXOpen::Routing::CustomManager *RouteCustomManager();
        public: NXOpen::RoutingCommon::CustomManager *RoutingCustomManager();
        public: NXOpen::Options::OptionsManager *OptionsManager();
        public: NXOpen::LicenseManager *LicenseManager();
        public: NXOpen::UserDefinedObjects::UserDefinedClassManager *UserDefinedClassManager();
        public: NXOpen::AssembliesUtils *AssembliesUtils();
        public: NXOpen::DrawingUtils *DrawingUtils();
        public: NXOpen::PDM::RequirementUtils *RequirementUtils();
        public: NXOpen::Motion::MotionSession *MotionSession();
        public: NXOpen::Motion::MotionSimulation *MotionSimulation();
        public: NXOpen::PDM::PdmSearchManager *PdmSearchManager();
        public: NXOpen::Validate::XmlComparator *XmlComparator();
        public: NXOpen::CAE::FTK::DataManager *DataManager();
        public: NXOpen::VisualReporting::VisualReportManager *VisualReportManager();
        public: NXOpen::CAE::Xyplot::XYPlotManager *XYPlotManager();
        public: NXOpen::PDM::PdmSession *PdmSession();
        public: NXOpen::PDM::PdmManager *PdmManager();
        public: NXOpen::Tooling::ToolingSession *ToolingSession();
        public: NXOpen::Features::UserDefinedFeatureClassManager *UserDefinedFeatureClassManager();
        public: NXOpen::Issue::IssueManager *IssueManager();
        public: NXOpen::AttributeManager *AttributeManager();
        public: NXOpen::LinkedPartManager *LinkedPartManager();
        public: NXOpen::CollaborativeContentManager *CollaborativeContentManager();
        public: NXOpen::Mechatronics::MechatronicsSession *MechatronicsSession();
        public: NXOpen::PDM::ConfigurationManager *ConfigurationManager();
        public: NXOpen::Gateway::BookmarkFile *BookmarkFile();
        public: NXOpen::SubdivisionTaskEnvironment *SubdivisionTaskEnvironment();
        public: NXOpen::Weld::WeldCpdUtils *WeldCpdUtils();
        public: NXOpen::Features::CustomFeatureClassManager *CustomFeatureClassManager();
        public: NXOpen::SIM::PostConfigurator::PostConfiguratorManager *PostConfiguratorManager();
        public: NXOpen::JournalManager *JournalManager();
        public: NXOpen::PDM::WebAppSession *WebAppSession();
        public: NXOpen::Report::ReportManager *ReportManager();
        public: NXOpen::ShipDesign::ShipSession *ShipSession();
        public: NXOpen::Diagramming::SheetManager *SheetManager();
        public: NXOpen::PolygonModelingTaskEnvironment *PolygonModelingTaskEnvironment();
        public: NXOpen::CAE::CurveOperation *CurveOperation();
        public: NXOpen::StudioMaterialManager *StudioMaterialManager();
        public: NXOpen::TextureModelingTaskEnvironment *TextureModelingTaskEnvironment();
        public: NXOpen::MorphMeshTaskEnvironment *MorphMeshTaskEnvironment();
        public: NXOpen::StructureDesign::StructureDesignSession *StructureDesignSession();

        public: NXOpen::TopologyOptimizationTaskEnvironment *TopologyOptimizationTaskEnvironment();

        public: NXOpen::StructureDesign::FrameTaskEnvironment *FrameTaskEnvironment();
        public: NXOpen::CollaborationApplication::SessionManager *SessionManager();
        public: NXOpen::DMUSessionCollection *DMUSessionCollection();
        public: NXOpen::DrawShapeTaskEnvironment *DrawShapeTaskEnvironment();
        public: NXOpen::Appearance::AppearanceUtils *AppearanceUtils();
        public: NXOpen::Features::FeatureColorManager *FeatureColorManager();
        public: NXOpen::DesignSimulation::PerformancePredictorManager *PerformancePredictorManager();

        public: NXOpen::Validate::Corrosion::Manager *CorrosionManager();

        public: NXOpen::ImplicitModelingTaskEnvironment *ImplicitModelingTaskEnvironment();
        public: NXOpen::AECDesign::AECDesignSession *AECDesignSession();
    };
}
#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