solidworksw.hpp

Go to the documentation of this file.

#ifndef __DTK_SOLIDWORKSW_H__
#define __DTK_SOLIDWORKSW_H__
#include "def/define.h"
#include "struct/str_def.h"
#include "util/BaseTypes/dtk_metadata.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/util_draw_dtk.hpp"
#include "util/util_stl_dtk.hpp"
////////////////////////////////////////////////////////////
//                    solidworksw.h                          //
////////////////////////////////////////////////////////////
 
//! \brief Exported APIs for solidworks Write Library
 
namespace sw
{
     namespace sww
     {
          //language for writing part and assembly
          enum language
          {
               french = 0,
               english = 1,
               italian = 2,
               deutch = 3,
               chinese = 4
          };
 
          //! \class FileDescription 
          //! \brief This class provides several informations about a Solidworks File.\n
          //! It can be used with sw::OpenPart and OpenAssembly functions to specify file properties.
          //! \code
          //! //...
          //! FileDescription sw::sww::Desc;
          //! Dtk_ErrorStatus dtkerror;
          //! dtkerror= sw::sww::OpenPart( inOutputFile, Desc);
          //! //...
          //! \endcode
          class FileDescription
          {
          public:
 
          protected:
 
               Dtk_tab< Dtk_MetaDataPtr >    _AdditionalProperties;
 
          public:
 
               //! \BaseConstructor
               FileDescription()
               {
               }
 
               //! \BaseDestructor
               ~FileDescription()
               {
               }
 
               //! \BaseConstructor
               FileDescription( const Dtk_tab< Dtk_MetaDataPtr >& inArrayProperties ) :_AdditionalProperties( inArrayProperties )
               {
               };
 
               //! \brief Get Metadata Array - read only -
               inline const Dtk_tab< Dtk_MetaDataPtr >& GetAdditionalProperties() const
               {
                    return _AdditionalProperties;
               }
 
               //! \brief Add Metadata - read only -
               void AddMetadata( Dtk_MetaDataPtr& inMetadata );// {if (inMetadata.IsNotNULL()) {_AdditionalProperties.push_back(inMetadata);}}
 
               //! \brief Clear Array - read only -
               void Clear()
               {
                    return _AdditionalProperties.clear();
               }
 
          };
 
          //! \class Instance 
          //! \brief This class provides Instance about a Solidworks File.\n
          //! It can be used with sw::sww::OpenAssembly functions to Add Instance
          //! \code
          //! //...
          //! soldiworksw::Instance instance;
          //! Dtk_ErrorStatus dtkerror;
          //! dtkerror = sw::sww::AddInstance( instance);
          //! //...
          //! \endcode
          class Instance
          {
          public:
 
          protected:
 
               Dtk_string _Name;
               Dtk_string _InstanceName;
               Dtk_string _ConfigurationName; // configuration index is always 0 because we only write one config per file
               Dtk_transfo _Matrix;
               Dtk_RGB _Color;
               Dtk_Int32 _BlankedStatus;
               Dtk_tab<Dtk_MetaDataPtr> m_ArrayMetadata;
          public:
 
               //! \BaseConstructor
               Instance()
               {
                    _Color = Dtk_RGB( -1, -1, -1, -1 );
                    _BlankedStatus = DTK_FALSE;
               }
 
               //! \BaseDestructor
               ~Instance()
               {
               }
 
               //! \BaseConstructor
               Instance( const Dtk_string& inSolidfileName, const Dtk_string& inInstanceName, const Dtk_transfo& inTransfo, const Dtk_RGB& inColorInstance = Dtk_RGB( -1, -1, -1, -1 ), const Dtk_Int32& inBlankedStatus = DTK_FALSE, const Dtk_string& inConfigurationName = Dtk_string() ) :
                    _Name( inSolidfileName ), _InstanceName( inInstanceName ), _Matrix( inTransfo ), _Color( inColorInstance ), _BlankedStatus( inBlankedStatus ), _ConfigurationName( inConfigurationName )
               {
 
               };
 
               const Dtk_string& GetName()
               {
                    return _Name;
               };
 
               const Dtk_string& GetInstanceName()
               {
                    return _InstanceName;
               };
 
               const Dtk_string& GetConfigurationName()
               {
                    return _ConfigurationName;
               };
 
               const Dtk_transfo& GetMatrix()
               {
                    return _Matrix;
               };
 
               const Dtk_RGB& GetColor()
               {
                    return _Color;
               };
 
               const Dtk_Int32& GetBlankedStatus()
               {
                    return _BlankedStatus;
               };
 
               void AddMetadata( const Dtk_tab<Dtk_MetaDataPtr>& inArrayMetadata )
               {
                    m_ArrayMetadata = inArrayMetadata;
               };
 
               const Dtk_tab<Dtk_MetaDataPtr>& GetMetadata()
               {
                    return m_ArrayMetadata;
               };
          };
 
          //! \brief ONLY for PSKERNEL user
          //! \return dtkNoError if it is OK.
          //! \remark Informs that the session is started
          //! \param [in] inStop : set -1 after StartParasolid 
          void SetIsAlreadyStart( const Dtk_Int32& inStop );
 
          //! \brief Initialize the Solidworks Writer  
          //! \return dtkNoError if it is OK.
          //! \remark This is the first function called for the writer.
          //! \param [in] inLogFile : Log file
          //! \param [in] inLicFct : Licence fuction or Null
          //! \param [in] inLanguage : by default sw::sww::english
          Dtk_ErrorStatus InitWriter( const Dtk_string& inLogFile, Licence_dtk inLicFct, sw::sww::language inLanguage = sw::sww::english );
 
          //! \brief Free the Solidworks Writer  
          //! \return dtkNoError if it is OK.
          //! \remark used at the last function used for the writer.
          Dtk_ErrorStatus EndWriter();
 
          //! \brief option to store the body color
          //! \param [in] inStoreBodyColor : used DTK_TRUE for enabled
          //! \remark used after InitWriter
          void OptionStoreBodyColor( Dtk_Int32 inStoreBodyColor );
 
          //! \brief option to not store the comment
          //! \param [in] inRemoveComment : used DTK_TRUE for not removing comment
          //! \remark used after InitWriter
          void OptionRemoveComment( Dtk_Int32 inRemoveComment );
 
          //! \brief Initialize the part  
          //! \remark used at the beginning of conversion.
          //! \param [in] inOutputFile : Name of the Solidworks Part (sldprt) file to be Written.
          //! \param [in] inFileDescription : Description File 
          //! \param [in] inConfigurationName : Name of the Configuration of the Solidworks Part (sldprt) file to be Written.
          //! \remarks The given path into inOutputFile must exist and you must have write permission in this folder.
          Dtk_ErrorStatus OpenPart(
               const Dtk_string& inSolidworksFile,
               const sw::sww::FileDescription& inFileDescription = sw::sww::FileDescription(),
               Dtk_Unit inUnit = DTK_UNIT_MM,
               const Dtk_string& inConfigurationName = Dtk_string() );
 
          //! \brief Add parasolid file
          //! \param [in] inParasolidFile : Name of the Parasolid File to be added.
          //! \remarks only work with pskernel writer.
          Dtk_ErrorStatus AddParasolidFile( const Dtk_string& inParasolidFile );
 
          //! \brief Add parasolid stream with only one body without header
          //! \param [in] inFlux : parasolid flux from one body
          //! \param [in] inSize : size of inFlux 
          //! \param [in] inInfo : info for body
          Dtk_ErrorStatus AddParasolidBodyStream( const char* inFlux, size_t inSize, const Dtk_InfoPtr& inInfo );
 
          //! \brief Add parasolid Id body
          //! \param [in] inParasolidId : Id of the Parasolid body to be added.
          //! \remarks only work with pskernel writer.
          Dtk_ErrorStatus AddParasolidId( const Dtk_Int32& inParasolidId );
 
          //! \brief Write the entity provided in parameter. 
          //! \param [in] inEntity : The Entity to be written
          //! \return dtkNoError if it is OK.
          //! \remark This function is used to write entities .
          Dtk_ErrorStatus AddEntity( const Dtk_EntityPtr& inEntity );
 
          Dtk_ErrorStatus AddMetaData( const Dtk_MetaDataPtr& inEntity );
 
          //! \brief Free data allocated by sw::sww::OpenPart  
          //! \return dtkNoError if it is OK.
          //! \remark used at the end of conversion.
          Dtk_ErrorStatus ClosePart();
 
          //! \brief Initialize a Assembly . 
          //! \param [in] inFileName : Name of the Solidworks Assembly (sldasm) file to be written.
          //! \param [in] inConfigurationName : Name of the configuration of the Solidworks Assembly (sldasm) file to be written.
          //! \param [in] inFileDescription : Description File 
          //! \return dtkNoError if it is OK.
          //! \remarks The given path into inFileName must exist and you must have write permission in this folder.
          Dtk_ErrorStatus OpenAssembly(
               const Dtk_string& inFileName,
               const sw::sww::FileDescription& inFileDescription = sw::sww::FileDescription(),
               Dtk_Unit inUnit = DTK_UNIT_MM,
               const Dtk_string& inConfigurationName = Dtk_string() );
 
          //! \brief Add an instance  into the Current Assembly (sldasm).
          //! \param [in] inInstance : Instance definitionwith (Full path name , instance name and position.    
          //! \return dtkNoError if it is OK.
          Dtk_ErrorStatus AddInstanceComponent( Instance& inInstance );
 
 
          //! \brief Write effectively the Assembly initialized by OpenAssembly. 
          //! \return dtkNoError if it is OK.
          Dtk_ErrorStatus CloseAssembly();
     };
}
 
#endif