#ifndef VISU_APPENDFILTER_H
#define VISU_APPENDFILTER_H
+#include "VISUConvertor.hxx"
#include "VISU_AppendFilterUtilities.hxx"
#include <vtkAppendFilter.h>
/*! \brief This class used same as vtkAppendFilter. See documentation on VTK for more information.
*/
-class VISU_AppendFilter : public vtkAppendFilter,
- public VISU::TAppendFilterHelper
+class VISU_CONVERTOR_EXPORT VISU_AppendFilter : public vtkAppendFilter,
+ public VISU::TAppendFilterHelper
{
public:
/*! \fn static VISU_AppendFilter *New()
for(vtkIdType aCellId = 0; anIter != anEndIter; anIter++, aCellId++){
const TInputCellId& anInputCellId = anIter->second;
TInputId anInputId = anInputCellId.first;
- TCellId aCellId = anInputCellId.second;
+ /*TCellId*/ aCellId = anInputCellId.second;
aDataArray->SetValue(aTupleId++, anInputId);
aDataArray->SetValue(aTupleId++, aCellId);
}
class vtkPointSet;
class vtkObject;
+#include <VISU_Convertor.hxx>
#include <vtkSmartPointer.h>
namespace VISU
{
//---------------------------------------------------------------
- class TAppendFilterHelper
+ class VISU_CONVERTOR_EXPORT TAppendFilterHelper
{
TAppendFilterHelper(TAppendFilterHelper&);
public:
- void
+ void
SetSharedPointSet(vtkPointSet* thePointSet);
vtkPointSet*
{
//---------------------------------------------------------------
//! Get number of nodes for defined geometrical type
- vtkIdType
+ vtkIdType VISU_CONVERTOR_EXPORT
VISUGeom2NbNodes(EGeometry theGeom);
//---------------------------------------------------------------
- struct TUnstructuredGridIDMapper: virtual TIDMapper
+ struct VISU_CONVERTOR_EXPORT TUnstructuredGridIDMapper: virtual TIDMapper
{
//! Get VTK representation of mesh for corresponding MED entity
virtual
#ifndef VISU_MedConvertor_HeaderFile
#define VISU_MedConvertor_HeaderFile
+#include "VISUConvertor.hxx"
#include "VISU_Convertor_impl.hxx"
#include "VISU_Structures_impl.hxx"
#include "VISU_PointCoords.hxx"
namespace VISU
{
//---------------------------------------------------------------
- struct TMEDCoordHolder: TCoordHolder<MED::PNodeCoord>
+ struct VISU_CONVERTOR_EXPORT TMEDCoordHolder: TCoordHolder<MED::PNodeCoord>
{
virtual
const TCoord*
//---------------------------------------------------------------
- struct TMEDGaussCoordHolder: TCoordHolderBase
+ struct VISU_CONVERTOR_EXPORT TMEDGaussCoordHolder: TCoordHolderBase
{
MED::PGaussCoord myGaussCoord;
//---------------------------------------------------------------
template<class TValueType>
- struct TTMEDMeshValue: TTMeshValueHolder<TValueType,
+ struct VISU_CONVERTOR_EXPORT TTMEDMeshValue: TTMeshValueHolder<TValueType,
MED::SharedPtr<MED::TTMeshValue<MED::TVector<TValueType> > > >
{
virtual
//---------------------------------------------------------------
- struct TMEDMesh: virtual TMeshImpl
+ struct VISU_CONVERTOR_EXPORT TMEDMesh: virtual TMeshImpl
{
MED::PMeshInfo myMeshInfo;
MED::TEntityInfo myEntityInfo;
//---------------------------------------------------------------
- struct TMEDSubProfile: virtual TSubProfileImpl
+ struct VISU_CONVERTOR_EXPORT TMEDSubProfile: virtual TSubProfileImpl
{
MED::EGeometrieElement myMGeom;
//---------------------------------------------------------------
- struct TMEDProfile: virtual TProfileImpl
+ struct VISU_CONVERTOR_EXPORT TMEDProfile: virtual TProfileImpl
{};
typedef MED::SharedPtr<TMEDProfile> PMEDProfile;
//---------------------------------------------------------------
- struct TMEDGauss: virtual TGaussImpl
+ struct VISU_CONVERTOR_EXPORT TMEDGauss: virtual TGaussImpl
{
MED::PGaussInfo myGaussInfo;
//---------------------------------------------------------------
- struct TMEDGaussSubMesh: virtual TGaussSubMeshImpl
+ struct VISU_CONVERTOR_EXPORT TMEDGaussSubMesh: virtual TGaussSubMeshImpl
{
TMEDGaussSubMesh():
myIsElemNum(MED::eFAUX)
//---------------------------------------------------------------
- struct TMEDGaussMesh: virtual TGaussMeshImpl
+ struct VISU_CONVERTOR_EXPORT TMEDGaussMesh: virtual TGaussMeshImpl
{};
typedef MED::SharedPtr<TMEDGaussMesh> PMEDGaussMesh;
//---------------------------------------------------------------
- struct TMEDSubMesh: virtual TSubMeshImpl
+ struct VISU_CONVERTOR_EXPORT TMEDSubMesh: virtual TSubMeshImpl
{
TMEDSubMesh():
myIsElemNum(MED::eFAUX),
//---------------------------------------------------------------
typedef std::map<vtkIdType,vtkIdType> TFamilyID2CellsSize;
- struct TMEDMeshOnEntity: virtual TMeshOnEntityImpl
+ struct VISU_CONVERTOR_EXPORT TMEDMeshOnEntity: virtual TMeshOnEntityImpl
{
TFamilyID2CellsSize myFamilyID2CellsSize;
MED::TGeom2Size myGeom2Size;
//---------------------------------------------------------------
- struct TMEDFamily: virtual TFamilyImpl
+ struct VISU_CONVERTOR_EXPORT TMEDFamily: virtual TFamilyImpl
{};
typedef MED::SharedPtr<TMEDFamily> PMEDFamily;
//---------------------------------------------------------------
- struct TMEDGroup: virtual TGroupImpl
+ struct VISU_CONVERTOR_EXPORT TMEDGroup: virtual TGroupImpl
{};
typedef MED::SharedPtr<TMEDGroup> PMEDGroup;
//---------------------------------------------------------------
- struct TMEDField: virtual TFieldImpl
+ struct VISU_CONVERTOR_EXPORT TMEDField: virtual TFieldImpl
{};
typedef MED::SharedPtr<TMEDField> PMEDField;
//---------------------------------------------------------------
- struct TMEDValForTime: virtual TValForTimeImpl
+ struct VISU_CONVERTOR_EXPORT TMEDValForTime: virtual TValForTimeImpl
{};
typedef MED::SharedPtr<TMEDValForTime> PMEDValForTime;
{
//---------------------------------------------------------------
//! Define a base class for the container to get access to data assigned to mesh
- class TMeshValueBase
+ class VISU_CONVERTOR_EXPORT TMeshValueBase
{
public:
//! To intitilize the data strucutre
//---------------------------------------------------------------
//! Define a container to get access to data assigned to mesh
template<class TValueType>
- class TTMeshValue: public virtual TMeshValueBase
+ class VISU_CONVERTOR_EXPORT TTMeshValue: public virtual TMeshValueBase
{
public:
typedef MED::TSlice<TValueType> TValueSlice;
\brief The file contains declarations for basic interfaces that defines point coords of mesh elements
*/
+#include "VISUConvertor.hxx"
#include "VISU_Convertor.hxx"
#include "VISU_ConvertorDef_impl.hxx"
//---------------------------------------------------------------
//! This class is responsible for keeping the mesh node coordinates
- class TCoordHolderBase: public virtual TBaseStructure
+ class VISU_CONVERTOR_EXPORT TCoordHolderBase: public virtual TBaseStructure
{
public:
//! To initilize the instance
//---------------------------------------------------------------
//! This class is responsible for representation of mesh nodes
- class TPointCoords: public virtual TIsVTKDone
+ class VISU_CONVERTOR_EXPORT TPointCoords: public virtual TIsVTKDone
{
public:
TPointCoords();
In additition to its base functionlity it support mapping of VTK to object numeration and
keeps names for each of nodes.
*/
- class TNamedPointCoords: public virtual TPointCoords
+ class VISU_CONVERTOR_EXPORT TNamedPointCoords: public virtual TPointCoords
{
public:
//! To initilize the class (numeration of the nodes can be missed)
\brief The file contains definitions for basic classes of the VISU CONVERTER package
*/
+#include "VISUConvertor.hxx"
#include "VISU_IDMapper.hxx"
#include "VISU_ConvertorDef.hxx"
//---------------------------------------------------------------
//! Define a basic class for all MED entites which can be identified by its number
- struct TIntId: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TIntId: virtual TBaseStructure
{
vtkIdType myId;
//---------------------------------------------------------------
//! Define an utility base class which is repsonsible for preventing repetion
- struct TIsVTKDone: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TIsVTKDone: virtual TBaseStructure
{
mutable bool myIsDone; //!< Say, is the corresponding MED entity already loaded into intermediate data structure
mutable bool myIsVTKDone; //!< Say, is the corresponding intermediate data structure already mapped into VTK representation
This class in its turn contains map of TMeshOnEntity and TGroup substructures,
also it keeps name and dimention of corresponding MED MESH entity.
*/
- struct TMesh: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TMesh: virtual TBaseStructure
{
TMeshOnEntityMap myMeshOnEntityMap; //!< Contains corresponding meshes for MED ENTITIES
TGroupMap myGroupMap; //!< Contains map of bounded MED GROUPS
//---------------------------------------------------------------
//! Define a basic class which corresponds to MED PROFILE entity
- struct TSubProfile: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TSubProfile: virtual TBaseStructure
{};
//---------------------------------------------------------------
//! Define a containerfor MED PROFILE entities which belongs to the same MED ENTITY
- struct TProfile: virtual TNamedIDMapper
+ struct VISU_CONVERTOR_EXPORT TProfile: virtual TNamedIDMapper
{};
//---------------------------------------------------------------
- bool
+ bool VISU_CONVERTOR_EXPORT
operator<(const PSubProfile& theLeft, const PSubProfile& theRight);
typedef std::set<PSubProfile> TProfileKey;
//---------------------------------------------------------------
//! Define a basic class for MED GAUSS entity
- struct TGauss: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TGauss: virtual TBaseStructure
{};
//---------------------------------------------------------------
//! Define a container for mesh generated from MED GAUSS and corresponding MED PROFILE
- struct TGaussSubMesh: virtual TBaseStructure
+ struct VISU_CONVERTOR_EXPORT TGaussSubMesh: virtual TBaseStructure
{
PSubProfile mySubProfile; //!< Keeps reference on what submesh the Gauss Points are located
};
//---------------------------------------------------------------
//! Define a container for all TGaussSubMesh that belongs to the same MED ENTITY
- struct TGaussMesh: virtual TGaussPtsIDMapper
+ struct VISU_CONVERTOR_EXPORT TGaussMesh: virtual TGaussPtsIDMapper
{};
//---------------------------------------------------------------
- bool
+ bool VISU_CONVERTOR_EXPORT
operator<(const PGaussSubMesh& theLeft, const PGaussSubMesh& theRight);
typedef std::set<PGaussSubMesh> TGaussKey;
This class in its turn contains map of TGaussMesh and TProfile substructures,
also it keeps corresponding map of MED FAMILIES and FIELDS.
*/
- struct TMeshOnEntity: virtual TNamedIDMapper
+ struct VISU_CONVERTOR_EXPORT TMeshOnEntity: virtual TNamedIDMapper
{
TGaussMeshMap myGaussMeshMap; //!< Contains map of Gauss mesh which exist on it
TProfileMap myProfileMap; //!< Contains map of Profile mesh which exist on it
//---------------------------------------------------------------
//! Define a basic class for MED FAMILY entity
- struct TFamily: virtual TIntId,
+ struct VISU_CONVERTOR_EXPORT TFamily: virtual TIntId,
virtual TUnstructuredGridIDMapper
{
TEntity myEntity; //!< Referes to MED ENTITY where the TFamily belongs to.
typedef std::set<PFamily> TFamilySet;
//! Define a basic class for MED GROUP entity
- struct TGroup: virtual TUnstructuredGridIDMapper
+ struct VISU_CONVERTOR_EXPORT TGroup: virtual TUnstructuredGridIDMapper
{
TFamilySet myFamilySet;
};
typedef std::pair<vtkFloatingPointType, vtkFloatingPointType> TMinMax;
//! Define a basic class for MED FIELD entity
- struct TField: virtual TIntId
+ struct VISU_CONVERTOR_EXPORT TField: virtual TIntId
{
TEntity myEntity; //!< Referes to MED ENTITY where it belongs to.
TName myName; //!< Contains name of the corresponding MED FIELD
};
// MULTIPR
- struct TPart: virtual TIntId
+ struct VISU_CONVERTOR_EXPORT TPart: virtual TIntId
{
vtkIdType myCurrentRes; //!< Keeps current resolution fot this part
typedef std::pair<double, std::string> TTime;
//! Define a basic class for MED TIMESTAMP entity
- struct TValForTime: virtual TIntId
+ struct VISU_CONVERTOR_EXPORT TValForTime: virtual TIntId
{
TEntity myEntity; //!< Referes to MED ENTITY where it belongs to.
TName myMeshName; //!< Contains name of the MED MESH where it belongs to.
\brief The file contains definitions for basic classes of the implementation of VISU CONVERTER package
*/
+#include "VISUConvertor.hxx"
#include "VISU_Structures.hxx"
#include "VISU_ConvertorDef_impl.hxx"
{
//---------------------------------------------------------------
//! Define an utility base class which allow to keep calculated number of cells and their size
- struct TSizeCounter: virtual TIsVTKDone
+ struct VISU_CONVERTOR_EXPORT TSizeCounter: virtual TIsVTKDone
{
TSizeCounter();
vtkIdType myNbCells; //!< Number of cells contained into corresponding sublclass
//---------------------------------------------------------------
//! Define a container for VTK representation
- class TUnstructuredGridHolder: public virtual TSizeCounter
+ class VISU_CONVERTOR_EXPORT TUnstructuredGridHolder: public virtual TSizeCounter
{
public:
TUnstructuredGridHolder();
//---------------------------------------------------------------
//! Define an intermediate class which unifies memory size calculation
- struct TMemoryCheckIDMapper: public virtual TIsVTKDone,
+ struct VISU_CONVERTOR_EXPORT TMemoryCheckIDMapper: public virtual TIsVTKDone,
public virtual TIDMapper
{
//! Gets memory size used by the instance (bytes).
/*!
This container allow to combine other VTK representation into single one.
*/
- class TAppendFilterHolder: public virtual TMemoryCheckIDMapper
+ class VISU_CONVERTOR_EXPORT TAppendFilterHolder: public virtual TMemoryCheckIDMapper
{
protected:
mutable PAppendFilter myFilter;
//---------------------------------------------------------------
//! Specialize TMesh to provide VTK mapping for nodes
- struct TMeshImpl: virtual TMesh,
+ struct VISU_CONVERTOR_EXPORT TMeshImpl: virtual TMesh,
virtual TIsVTKDone
{
PNamedPointCoords myNamedPointCoords; //!< Keeps intermediate representation of the nodes
typedef enum {eRemoveAll, eAddAll, eAddPart, eNone} ESubMeshStatus;
//! Specialize TSubProfile to provide VTK mapping
- struct TSubProfileImpl: virtual TSubProfile,
+ struct VISU_CONVERTOR_EXPORT TSubProfileImpl: virtual TSubProfile,
virtual TUnstructuredGridHolder
{
TSubProfileImpl();
typedef std::map<EGeometry,PSubProfileImpl> TGeom2SubProfile;
//! Specialize TProfile to provide VTK mapping for MED TIMESTAMP mesh
- struct TProfileImpl: virtual TProfile,
+ struct VISU_CONVERTOR_EXPORT TProfileImpl: virtual TProfile,
virtual TAppendFilterHolder
{
TProfileImpl();
//---------------------------------------------------------------
//! Specialize TGauss to provide more detail information of the MED GAUSS entity for VTK mapping
- struct TGaussImpl: virtual TGauss
+ struct VISU_CONVERTOR_EXPORT TGaussImpl: virtual TGauss
{
EGeometry myGeom; //!< Define, to which geometrical type the MED GAUSS entity belongs
std::string myName; //!< Keeps name of the MED GAUSS entity
//---------------------------------------------------------------
//! Specialize TGaussSubMesh to provide VTK mapping for the entity
- struct TGaussSubMeshImpl: virtual TGaussSubMesh,
+ struct VISU_CONVERTOR_EXPORT TGaussSubMeshImpl: virtual TGaussSubMesh,
virtual TPolyDataHolder
{
TGaussSubMeshImpl();
typedef std::map<EGeometry, PGaussSubMeshImpl> TGeom2GaussSubMesh;
//! Specialize TGaussMesh to provide VTK mapping for the entity
- struct TGaussMeshImpl: virtual TGaussMesh,
+ struct VISU_CONVERTOR_EXPORT TGaussMeshImpl: virtual TGaussMesh,
virtual TAppendPolyDataHolder
{
TGaussMeshImpl();
//---------------------------------------------------------------
//! Specialize TGaussPtsIDMapper to provide VTK mapping for MED TIMESTAMP mesh
- struct TGaussPtsIDFilter: virtual TPolyDataIDMapperImpl,
+ struct VISU_CONVERTOR_EXPORT TGaussPtsIDFilter: virtual TPolyDataIDMapperImpl,
virtual TGaussPtsIDMapper
{
PGaussPtsIDMapper myGaussPtsIDMapper;
typedef TVector<TConnect> TCell2Connect;
//! The class is responsible for mapping of cells of defined geometrical type
- struct TSubMeshImpl: virtual TUnstructuredGridHolder
+ struct VISU_CONVERTOR_EXPORT TSubMeshImpl: virtual TUnstructuredGridHolder
{
TSubMeshImpl();
typedef TVector<PSubMeshImpl> TSubMeshArr;
//! Specialize TMeshOnEntity to provide VTK mapping for the entity
- struct TMeshOnEntityImpl: virtual TMeshOnEntity,
+ struct VISU_CONVERTOR_EXPORT TMeshOnEntityImpl: virtual TMeshOnEntity,
virtual TAppendFilterHolder,
virtual TSizeCounter
{
typedef std::map<EGeometry,TSubMeshID> TGeom2SubMeshID;
//! Specialize TFamily to provide VTK mapping for the entity
- struct TFamilyImpl: virtual TFamily,
+ struct VISU_CONVERTOR_EXPORT TFamilyImpl: virtual TFamily,
virtual TUnstructuredGridHolder
{
//! Reimplement the TIDMapper::GetNodeObjID
typedef TVector<PFamilyImpl> TFamilyArr;
//! Specialize TGroup to provide VTK mapping for the entity
- struct TGroupImpl: virtual TGroup,
+ struct VISU_CONVERTOR_EXPORT TGroupImpl: virtual TGroup,
virtual TAppendFilterHolder
{
//! Calculate pair of values - number of cells and its size
typedef TVector<TMinMax> TMinMaxArr;
//! Specialize TField to provide VTK mapping for the entity
- struct TFieldImpl: virtual TField
+ struct VISU_CONVERTOR_EXPORT TFieldImpl: virtual TField
{
TFieldImpl();
typedef std::map<EGeometry,vtkIdType> TGeom2NbGauss;
//! Specialize TValForTime to provide VTK mapping for the entity
- struct TValForTimeImpl: virtual TValForTime
+ struct VISU_CONVERTOR_EXPORT TValForTimeImpl: virtual TValForTime
{
PGaussPtsIDFilter myGaussPtsIDFilter; //!< Keep VTK representation for mesh and data on Gauss Points
PUnstructuredGridIDMapperImpl myUnstructuredGridIDMapper; //!< Keep VTK representation for ordinary mesh and data
protected:
//----------------------------------------------------------------------------
VISU_ColoredPL();
- VISU_ColoredPL(const VISU_ColoredPL&);
+ VISU_ColoredPL(const VISU_ColoredPL&) {};
virtual
~VISU_ColoredPL();
//----------------------------------------------------------------------------
//! Checks whether the float values are the same or not
- bool
+ bool VISU_PIPELINE_EXPORT
CheckIsSameValue(vtkFloatingPointType theTarget,
vtkFloatingPointType theSource);
bool theIsCopyInput);
//! Customizes vtkDataSetMapper::ShallowCopy
- void
+ void VISU_PIPELINE_EXPORT
CopyDataSetMapper(vtkDataSetMapper* theTarget,
vtkDataSetMapper* theSource,
bool theIsCopyInput);
#ifndef VISU_UnstructuredGridPL_HeaderFile
#define VISU_UnstructuredGridPL_HeaderFile
+#include "VISUPipeline.hxx"
#include "VISU_PipeLine.hxx"
class VISU_DataSetMapperHolder;
class vtkDataSetMapper;
//----------------------------------------------------------------------------
-class VISU_UnstructuredGridPL
+class VISU_PIPELINE_EXPORT VISU_UnstructuredGridPL
{
public:
//----------------------------------------------------------------------------
return getApp()->getViewManager(theType,theIsCreate);
}
-TViewToPrs3d&
+VISU::TViewToPrs3d&
VisuGUI
::getScalarBarsMap()
{
aDlg->exec();
}
-#ifdef ENABLE_MULTIPR
-
// MULTIPR
void VisuGUI::OnMultiprViewFullRes()
{
+#ifdef ENABLE_MULTIPR
OnMultiprChangeRes('F');
+#endif
}
// MULTIPR
void VisuGUI::OnMultiprViewMediumRes()
{
+#ifdef ENABLE_MULTIPR
OnMultiprChangeRes('M');
+#endif
}
// MULTIPR
void VisuGUI::OnMultiprViewLowRes()
{
+#ifdef ENABLE_MULTIPR
OnMultiprChangeRes('L');
+#endif
}
// MULTIPR
void VisuGUI::OnMultiprViewHide()
{
+#ifdef ENABLE_MULTIPR
OnMultiprChangeRes('H');
+#endif
}
// MULTIPR
void VisuGUI::OnMultiprChangeRes(char resolution)
{
+#ifdef ENABLE_MULTIPR
_PTR(Study) aCStudy = GetCStudy(GetAppStudy(this));
if (CheckLock(aCStudy,GetDesktop(this)))
return;
}
UpdateObjBrowser(this, false);
+#endif
}
-#endif // ENABLE_MULTIPR
#include "SalomeApp_Module.h"
#include "SALOME_ListIO.hxx"
+#include "VISU_Prs3d_i.hh"
+#include "SVTK_ViewWindow.h"
#include <map>
#include <set>
#include <qpushbutton.h>
#include <qradiobutton.h>
+using namespace std;
+
VisuGUI_CacheDlg::VisuGUI_CacheDlg( VISU::ColoredPrs3dCache_var theCache,
SalomeApp_Module* theModule )
: QDialog( VISU::GetDesktop( theModule ), "VisuGUI_CacheDlg", true,
double aLimitedMemory = myCache->GetLimitedMemory();
double aFreeMemory = (double)VISU_PipeLine::GetAvailableMemory( 2048 * aMb ) / (double)aMb;
double anUsedMemory = myCache->GetMemorySize();
- double aLimitedMemoryMax = std::max(anUsedMemory + aFreeMemory, aLimitedMemory);
+ double aLimitedMemoryMax =
+#ifdef WNT
+ max
+#else
+ std::max
+#endif
+ (anUsedMemory + aFreeMemory, aLimitedMemory);
// Settings
QButtonGroup* aMemoryGroup = new QButtonGroup( 2, Qt::Vertical, tr( "MEMORY_MODE" ), this );
#include <qtabwidget.h>
#include <qhgroupbox.h>
#include <qlineedit.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
#include <vtkRenderer.h>
#include <vtkPolyData.h>
#include <qvalidator.h>
#include <qlineedit.h>
#include <qtabwidget.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
#include <vtkRenderer.h>
#include <vtkPolyData.h>
void VisuGUI_GaussPointsDlg::accept()
{
- if( myPrsCopy && myPrimitiveBox->getPrimitiveType() == VISU_OpenGLPointSpriteMapper::GeomSphere )
+ if( (bool)myPrsCopy && myPrimitiveBox->getPrimitiveType() == VISU_OpenGLPointSpriteMapper::GeomSphere )
{
int aNumberOfFaces = myPrimitiveBox->getFaceNumber();
int aNumberOfPoints = ( (vtkPolyData*)myPrsCopy->GetSpecificPL()->GetInput() )->GetNumberOfCells();
#include <qradiobutton.h>
#include <qspinbox.h>
#include <qcheckbox.h>
+#include <qlabel.h>
+#include <qpushbutton.h>
#include <vtkUnstructuredGrid.h>
#include <vtkDataSetMapper.h>
VISU_Actor* FindActor(const SalomeApp_Study* theStudy,
SVTK_ViewWindow* theViewWindow,
const QString& theEntry);
- VISU_Actor* FindActor(SVTK_ViewWindow* theViewWindow,
- VISU::Prs3d_i* thePrs);
void RecreateActor(const SalomeApp_Module* theModule,
VISU::Prs3d_i* thePrs);
//---------------------------------------------------------------
+#ifndef WNT
inline
+#endif
VISU_Actor*
UpdateViewer(VisuGUI* theModule,
VISU::Prs3d_i* thePrs,
bool theDispOnly = false,
- const bool theIsHighlight = false);
+ const bool theIsHighlight = false);
//---------------------------------------------------------------
#include CORBA_SERVER_HEADER(VISU_Gen)
#include CORBA_SERVER_HEADER(SALOMEDS)
+#include "VISU_I.hxx"
#include "VISU_ScalarMapOnDeformedShape_i.hh"
#include "VISU_Plot3D_i.hh"
#include "VISU_GaussPoints_i.hh"
//----------------------------------------------------------------------------
- bool
+ bool VISU_I_EXPORT
CreatColoredPrs3d(ColoredPrs3d_i* theColoredPrs3d,
Result_i* theResult,
const std::string& theMeshName,
//----------------------------------------------------------------------------
//! Gets the memory required for cache
- VISU::ColoredPrs3dCache::EnlargeType
+ VISU_I_EXPORT VISU::ColoredPrs3dCache::EnlargeType
GetRequiredCacheMemory(VISU::VISUType theType,
VISU::Result_ptr theResult,
const std::string& theMeshName,
//----------------------------------------------------------------------------
//! Creates ColoredPrs3dHolder by enumeration value and gets its first device
- ColoredPrs3d_i*
+ VISU_I_EXPORT ColoredPrs3d_i*
CreateHolder2GetDeviceByEnum(VISU::VISUType theType,
VISU::Result_ptr theResult,
const std::string& theMeshName,
//----------------------------------------------------------------------------
//! Check is possible to create ColoredPrs3dHolder with the given input
- size_t
+ VISU_I_EXPORT size_t
CheckIsPossible(VISU::VISUType theType,
const VISU::ColoredPrs3dHolder::BasicInput& theInput,
bool theMemoryCheck);
/*!
The enumeration allow to define what mode should be used for the presentation building.
*/
- enum EPublishInStudyMode {EPublishUnderTimeStamp, EPublishIndependently, ERegisterInCache, EDoNotPublish};
+ VISU_I_EXPORT enum EPublishInStudyMode {EPublishUnderTimeStamp, EPublishIndependently, ERegisterInCache, EDoNotPublish};
explicit
ColoredPrs3d_i(EPublishInStudyMode thePublishInStudyMode);
#ifndef VISU_CutLines_i_HeaderFile
#define VISU_CutLines_i_HeaderFile
+#include "VISU_I.hxx"
#include "VISU_ScalarMap_i.hh"
class VISU_CutLinesPL;
namespace VISU
{
//----------------------------------------------------------------------------
- class CutLines_i : public virtual POA_VISU::CutLines,
+ class VISU_I_EXPORT CutLines_i : public virtual POA_VISU::CutLines,
public virtual ScalarMap_i
{
static int myNbPresent;
- CutLines_i(const CutLines_i&);
+ CutLines_i(const CutLines_i&);
public:
//----------------------------------------------------------------------------
#ifndef VISU_DeformedShape_i_HeaderFile
#define VISU_DeformedShape_i_HeaderFile
+#include <VISU_I.hxx>
#include "VISU_ScalarMap_i.hh"
class VISU_DeformedShapePL;
namespace VISU
{
//----------------------------------------------------------------------------
- class DeformedShape_i : public virtual POA_VISU::DeformedShape,
+ class VISU_I_EXPORT DeformedShape_i : public virtual POA_VISU::DeformedShape,
public virtual ScalarMap_i
{
static int myNbPresent;
#endif
extern "C"
-VISU::VISU_Gen_ptr
+VISU_I_EXPORT VISU::VISU_Gen_ptr
GetImpl(CORBA::ORB_ptr theORB,
PortableServer::POA_ptr thePOA,
SALOME_NamingService* theNamingService,
#include "VISUConfig.hh"
+#include "VISU_I.hxx"
#include "SALOME_Component_i.hxx"
#include "SALOME_NamingService.hxx"
#include "VISU_ColoredPrs3d_i.hh"
# else
# define VISU_I_EXPORT __declspec( dllimport )
# endif
+
# define COPY_COMMAND "copy /Y"
# define MOVE_COMMAND "move /Y"
# define DELETE_COMMAND "del /F"
#endif
-
-#endif
#ifndef VISU_IsoSurfaces_i_HeaderFile
#define VISU_IsoSurfaces_i_HeaderFile
+#include "VISU_I.hxx"
#include "VISU_ScalarMap_i.hh"
class VISU_IsoSurfacesPL;
namespace VISU
{
//----------------------------------------------------------------------------
- class IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
+ class VISU_I_EXPORT IsoSurfaces_i : public virtual POA_VISU::IsoSurfaces,
public virtual ScalarMap_i
{
static int myNbPresent;
namespace VISU
{
//----------------------------------------------------------------------------
- class VISU_I_EXPORT MinMaxCunsomer: public virtual
-#ifdef WNT
- boost::bsignals::trackable
-#else
- boost::signalslib::trackable
-#endif
+ class VISU_I_EXPORT MinMaxCunsomer: public virtual boost::signalslib::trackable
{
protected:
bool myMinMaxIsInitilized;
};
//! To find Result object as published on father of the given SObject
- Result_var
+ VISU_I_EXPORT Result_var
FindResult(SALOMEDS::SObject_ptr theSObject);
//! To get VISU::Result object published on the given SALOMEDS::SObject
void RepaintView (SUIT_ViewWindow* theViewWindow);
enum Displaing {eDisplayAll, eDisplay, eDisplayOnly, eErase, eEraseAll};
- VISU_Actor* UpdateViewer (SUIT_ViewWindow* theViewWindow, int theDisplaing, Prs3d_i* thePrs = NULL);
+ VISU_I_EXPORT VISU_Actor* UpdateViewer (SUIT_ViewWindow* theViewWindow, int theDisplaing, Prs3d_i* thePrs = NULL);
void UpdatePlot2d (Plot2d_ViewFrame *theView, int theDisplaying, Curve_i* theCurve);
- VISU_Actor* VISU_I_EXPORT FindActor(SVTK_ViewWindow* theViewWindow, VISU::Prs3d_i* thePrs3d);
+ VISU_I_EXPORT VISU_Actor* FindActor(SVTK_ViewWindow* theViewWindow, VISU::Prs3d_i* thePrs3d);
void DeleteActors (VISU::Prs3d_i* thePrs);
void DeleteActors (VISU::Curve_i* thePrs);
