#include "SMESH_Controls.hxx"
+#ifdef WNT
+ #if defined SMESHCONTROLS_EXPORTS
+ #define SMESHCONTROLS_EXPORT __declspec( dllexport )
+ #else
+ #define SMESHCONTROLS_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESHCONTROLS_EXPORT
+#endif
+
class SMDS_MeshElement;
class SMDS_MeshFace;
class SMDS_MeshNode;
class gp_Pnt;
class TopoDS_Shape;
-
namespace SMESH{
namespace Controls{
- class TSequenceOfXYZ: public std::vector<gp_XYZ>
+ class SMESHCONTROLS_EXPORT TSequenceOfXYZ: public std::vector<gp_XYZ>
{
public:
typedef std::vector<gp_XYZ> TSuperClass;
Class : Functor
Description : Root of all Functors
*/
- class Functor
+ class SMESHCONTROLS_EXPORT Functor
{
public:
~Functor(){}
Class : NumericalFunctor
Description : Root of all Functors returning numeric value
*/
- class NumericalFunctor: public virtual Functor{
+ class SMESHCONTROLS_EXPORT NumericalFunctor: public virtual Functor{
public:
NumericalFunctor();
virtual void SetMesh( const SMDS_Mesh* theMesh );
Class : Volume
Description : Functor calculating volume of 3D mesh element
*/
- class Volume: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Volume: public virtual NumericalFunctor{
public:
virtual double GetValue( long theElementId );
//virtual double GetValue( const TSequenceOfXYZ& thePoints );
Class : SMESH_MinimumAngle
Description : Functor for calculation of minimum angle
*/
- class MinimumAngle: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT MinimumAngle: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : AspectRatio
Description : Functor for calculating aspect ratio
*/
- class AspectRatio: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT AspectRatio: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : AspectRatio3D
Description : Functor for calculating aspect ratio of 3D elems.
*/
- class AspectRatio3D: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT AspectRatio3D: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Warping
Description : Functor for calculating warping
*/
- class Warping: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Warping: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Taper
Description : Functor for calculating taper
*/
- class Taper: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Taper: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Skew
Description : Functor for calculating skew in degrees
*/
- class Skew: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Skew: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Area
Description : Functor for calculating area
*/
- class Area: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Area: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Length
Description : Functor for calculating length of edge
*/
- class Length: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Length: public virtual NumericalFunctor{
public:
virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : Length2D
Description : Functor for calculating length of edge
*/
- class Length2D: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT Length2D: public virtual NumericalFunctor{
public:
virtual double GetValue( long theElementId );
virtual double GetBadRate( double Value, int nbNodes ) const;
Class : MultiConnection
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT MultiConnection: public virtual NumericalFunctor{
public:
virtual double GetValue( long theElementId );
virtual double GetValue( const TSequenceOfXYZ& thePoints );
Class : MultiConnection2D
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection2D: public virtual NumericalFunctor{
+ class SMESHCONTROLS_EXPORT MultiConnection2D: public virtual NumericalFunctor{
public:
virtual double GetValue( long theElementId );
virtual double GetValue( const TSequenceOfXYZ& thePoints );
Class : Predicate
Description : Base class for all predicates
*/
- class Predicate: public virtual Functor{
+ class SMESHCONTROLS_EXPORT Predicate: public virtual Functor{
public:
virtual bool IsSatisfy( long theElementId ) = 0;
virtual SMDSAbs_ElementType GetType() const = 0;
Class : FreeBorders
Description : Predicate for free borders
*/
- class FreeBorders: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT FreeBorders: public virtual Predicate{
public:
FreeBorders();
virtual void SetMesh( const SMDS_Mesh* theMesh );
Class : BadOrientedVolume
Description : Predicate bad oriented volumes
*/
- class BadOrientedVolume: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT BadOrientedVolume: public virtual Predicate{
public:
BadOrientedVolume();
virtual void SetMesh( const SMDS_Mesh* theMesh );
Class : FreeEdges
Description : Predicate for free Edges
*/
- class FreeEdges: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT FreeEdges: public virtual Predicate{
public:
FreeEdges();
virtual void SetMesh( const SMDS_Mesh* theMesh );
2. With SetRangeStr method. Parameter of this method is a string
like as "1,2,3,50-60,63,67,70-"
*/
- class RangeOfIds: public virtual Predicate
+ class SMESHCONTROLS_EXPORT RangeOfIds: public virtual Predicate
{
public:
RangeOfIds();
Class : Comparator
Description : Base class for comparators
*/
- class Comparator: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT Comparator: public virtual Predicate{
public:
Comparator();
virtual ~Comparator();
Class : LessThan
Description : Comparator "<"
*/
- class LessThan: public virtual Comparator{
+ class SMESHCONTROLS_EXPORT LessThan: public virtual Comparator{
public:
virtual bool IsSatisfy( long theElementId );
};
Class : MoreThan
Description : Comparator ">"
*/
- class MoreThan: public virtual Comparator{
+ class SMESHCONTROLS_EXPORT MoreThan: public virtual Comparator{
public:
virtual bool IsSatisfy( long theElementId );
};
Class : EqualTo
Description : Comparator "="
*/
- class EqualTo: public virtual Comparator{
+ class SMESHCONTROLS_EXPORT EqualTo: public virtual Comparator{
public:
EqualTo();
virtual bool IsSatisfy( long theElementId );
Class : LogicalNOT
Description : Logical NOT predicate
*/
- class LogicalNOT: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT LogicalNOT: public virtual Predicate{
public:
LogicalNOT();
virtual ~LogicalNOT();
Class : LogicalBinary
Description : Base class for binary logical predicate
*/
- class LogicalBinary: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT LogicalBinary: public virtual Predicate{
public:
LogicalBinary();
virtual ~LogicalBinary();
Class : LogicalAND
Description : Logical AND
*/
- class LogicalAND: public virtual LogicalBinary{
+ class SMESHCONTROLS_EXPORT LogicalAND: public virtual LogicalBinary{
public:
virtual bool IsSatisfy( long theElementId );
};
Class : LogicalOR
Description : Logical OR
*/
- class LogicalOR: public virtual LogicalBinary{
+ class SMESHCONTROLS_EXPORT LogicalOR: public virtual LogicalBinary{
public:
virtual bool IsSatisfy( long theElementId );
};
Class : ManifoldPart
Description : Predicate for manifold part of mesh
*/
- class ManifoldPart: public virtual Predicate{
+ class SMESHCONTROLS_EXPORT ManifoldPart: public virtual Predicate{
public:
/* internal class for algorithm uses */
Description : Predicate elements that lying on indicated surface
(plane or cylinder)
*/
- class ElementsOnSurface : public virtual Predicate {
+ class SMESHCONTROLS_EXPORT ElementsOnSurface : public virtual Predicate {
public:
ElementsOnSurface();
~ElementsOnSurface();
/*
FILTER
*/
- class Filter{
+ class SMESHCONTROLS_EXPORT Filter{
public:
Filter();
virtual ~Filter();
#ifndef _INCLUDE_DRIVER_DOCUMENT
#define _INCLUDE_DRIVER_DOCUMENT
+#include "Driver_Mesh.h"
+
#include <string>
class SMESHDS_Document;
-class Driver_Document
+class MESHDRIVER_EXPORT Driver_Document
{
public:
Driver_Document();
#include <string>
-#if defined WNT && defined WIN32 && defined DRIVER_EXPORTS
-#define DRIVER_WNT_EXPORT __declspec( dllexport )
+#ifdef WNT
+ #if defined MESHDRIVER_EXPORTS
+ #define MESHDRIVER_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDRIVER_EXPORT __declspec( dllimport )
+ #endif
#else
-#define DRIVER_WNT_EXPORT
+ #define MESHDRIVER_EXPORT
#endif
-class DRIVER_WNT_EXPORT Driver_Mesh
+class MESHDRIVER_EXPORT Driver_Mesh
{
public:
Driver_Mesh();
class SMDS_Mesh;
-class Driver_SMDS_Mesh: public Driver_Mesh
+class MESHDRIVER_EXPORT Driver_SMDS_Mesh: public Driver_Mesh
{
public:
Driver_SMDS_Mesh();
class SMESHDS_Mesh;
-#if defined WNT && defined WIN32 && defined DRIVER_EXPORTS
-#define DRIVER_WNT_EXPORT __declspec( dllexport )
-#else
-#define DRIVER_WNT_EXPORT
-#endif
-
-class DRIVER_WNT_EXPORT Driver_SMESHDS_Mesh: public Driver_Mesh
+class MESHDRIVER_EXPORT Driver_SMESHDS_Mesh: public Driver_Mesh
{
public:
Driver_SMESHDS_Mesh();
protected:
SMESHDS_Mesh *myMesh;
-
};
#endif
#ifndef _INCLUDE_DRIVERDAT_R_SMDS_MESH
#define _INCLUDE_DRIVERDAT_R_SMDS_MESH
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_SMDS_Mesh.h"
-class DriverDAT_R_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERDAT_EXPORT DriverDAT_R_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
virtual Status Perform();
#ifndef _INCLUDE_DRIVERDAT_R_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERDAT_R_SMESHDS_DOCUMENT
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_Document.h"
-class DriverDAT_R_SMESHDS_Document : public Driver_Document
+class MESHDRIVERDAT_EXPORT DriverDAT_R_SMESHDS_Document : public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERDAT_R_SMESHDS_MESH
#define _INCLUDE_DRIVERDAT_R_SMESHDS_MESH
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
-class DriverDAT_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERDAT_EXPORT DriverDAT_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{};
#endif
#ifndef _INCLUDE_DRIVERDAT_W_SMDS_MESH
#define _INCLUDE_DRIVERDAT_W_SMDS_MESH
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_SMDS_Mesh.h"
-class DriverDAT_W_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERDAT_EXPORT DriverDAT_W_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
virtual Status Perform();
#ifndef _INCLUDE_DRIVERDAT_W_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERDAT_W_SMESHDS_DOCUMENT
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_Document.h"
-class DriverDAT_W_SMESHDS_Document: public Driver_Document
+class MESHDRIVERDAT_EXPORT DriverDAT_W_SMESHDS_Document: public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERDAT_W_SMESHDS_MESH
#define _INCLUDE_DRIVERDAT_W_SMESHDS_MESH
+#include "SMESH_DriverDAT.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
-class DriverDAT_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERDAT_EXPORT DriverDAT_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{};
#endif
@COMMENCE@
# header files
-EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h
+EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h SMESH_DriverDAT.hxx
# Libraries targets
LIB = libMeshDriverDAT.la
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_DriverDAT.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_DriverDAT_HXX_
+#define _SMESH_DriverDAT_HXX_
+
+#ifdef WNT
+ #if defined MESHDRIVERDAT_EXPORTS
+ #define MESHDRIVERDAT_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDRIVERDAT_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MESHDRIVERDAT_EXPORT
+#endif
+
+#endif
#ifndef _INCLUDE_DRIVERMED_FAMILY
#define _INCLUDE_DRIVERMED_FAMILY
+#include "SMESH_DriverMED.hxx"
+
#include "SMDS_Mesh.hxx"
#include "SMESHDS_GroupBase.hxx"
#include "SMESHDS_SubMesh.hxx"
class DriverMED_Family;
typedef boost::shared_ptr<DriverMED_Family> DriverMED_FamilyPtr;
-class DriverMED_Family
+class MESHDRIVERMED_EXPORT DriverMED_Family
{
public:
#ifndef _INCLUDE_DRIVERMED_R_SMDS_MESH
#define _INCLUDE_DRIVERMED_R_SMDS_MESH
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_SMDS_Mesh.h"
-class DriverMED_R_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERMED_EXPORT DriverMED_R_SMDS_Mesh: public Driver_SMDS_Mesh
{};
#endif
#ifndef _INCLUDE_DRIVERMED_R_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERMED_R_SMESHDS_DOCUMENT
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_Document.h"
-class DriverMED_R_SMESHDS_Document : public Driver_Document
+class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Document : public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERMED_R_SMESHDS_MESH
#define _INCLUDE_DRIVERMED_R_SMESHDS_MESH
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
#include "DriverMED_Family.h"
typedef std::pair< std::string, SMDSAbs_ElementType > TNameAndType;
-class DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{
public:
virtual Status Perform();
#ifndef _INCLUDE_DRIVERMED_W_SMDS_MESH
#define _INCLUDE_DRIVERMED_W_SMDS_MESH
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_SMDS_Mesh.h"
-class DriverMED_W_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERMED_EXPORT DriverMED_W_SMDS_Mesh: public Driver_SMDS_Mesh
{};
#endif
#ifndef _INCLUDE_DRIVERMED_W_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERMED_W_SMESHDS_DOCUMENT
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_Document.h"
-class DriverMED_W_SMESHDS_Document : public Driver_Document
+class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Document : public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERMED_W_SMESHDS_MESH
#define _INCLUDE_DRIVERMED_W_SMESHDS_MESH
+#include "SMESH_DriverMED.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
#include "MED_Factory.hxx"
class SMESHDS_GroupBase;
class SMESHDS_SubMesh;
-class DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{
public:
EXPORT_HEADERS = \
DriverMED_R_SMDS_Mesh.h DriverMED_R_SMESHDS_Mesh.h DriverMED_R_SMESHDS_Document.h \
DriverMED_W_SMDS_Mesh.h DriverMED_W_SMESHDS_Mesh.h DriverMED_W_SMESHDS_Document.h \
- DriverMED_Family.h
+ DriverMED_Family.h SMESH_DriverMED.hxx
# Libraries targets
LIB = libMeshDriverMED.la
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_DriverMED.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_DriverMED_HXX_
+#define _SMESH_DriverMED_HXX_
+
+#ifdef WNT
+ #if defined MESHDRIVERMED_EXPORTS
+ #define MESHDRIVERMED_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDRIVERMED_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MESHDRIVERMED_EXPORT
+#endif
+
+#endif
#ifndef _INCLUDE_DRIVERSTL_R_SMDS_MESH
#define _INCLUDE_DRIVERSTL_R_SMDS_MESH
+#include "SMESH_DriverSTL.hxx"
+
#include "Driver_SMDS_Mesh.h"
#include <Standard_TypeDef.hxx>
-class DriverSTL_R_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERSTL_EXPORT DriverSTL_R_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
DriverSTL_R_SMDS_Mesh();
#ifndef _INCLUDE_DRIVERSTL_W_SMDS_MESH
#define _INCLUDE_DRIVERSTL_W_SMDS_MESH
+#include "SMESH_DriverSTL.hxx"
+
#include "Driver_SMDS_Mesh.h"
#include <Standard_TypeDef.hxx>
-class DriverSTL_W_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERSTL_EXPORT DriverSTL_W_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
@COMMENCE@
# header files
-EXPORT_HEADERS= DriverSTL_R_SMDS_Mesh.h DriverSTL_W_SMDS_Mesh.h
+EXPORT_HEADERS= DriverSTL_R_SMDS_Mesh.h DriverSTL_W_SMDS_Mesh.h SMESH_DriverSTL.hxx
# Libraries targets
LIB = libMeshDriverSTL.la
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_DriverSTL.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_DriverSTL_HXX_
+#define _SMESH_DriverSTL_HXX_
+
+#ifdef WNT
+ #if defined MESHDRIVERSTL_EXPORTS
+ #define MESHDRIVERSTL_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDRIVERSTL_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MESHDRIVERSTL_EXPORT
+#endif
+
+#endif
#ifndef _INCLUDE_DRIVERUNV_R_SMDS_MESH
#define _INCLUDE_DRIVERUNV_R_SMDS_MESH
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_SMDS_Mesh.h"
class SMDS_Mesh;
-class DriverUNV_R_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERUNV_EXPORT DriverUNV_R_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
virtual Status Perform();
#ifndef _INCLUDE_DRIVERUNV_R_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERUNV_R_SMESHDS_DOCUMENT
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_Document.h"
-class DriverUNV_R_SMESHDS_Document: public Driver_Document
+class MESHDRIVERUNV_EXPORT DriverUNV_R_SMESHDS_Document: public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERUNV_R_SMESHDS_MESH
#define _INCLUDE_DRIVERUNV_R_SMESHDS_MESH
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
-class DriverUNV_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERUNV_EXPORT DriverUNV_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{};
#endif
#ifndef _INCLUDE_DRIVERUNV_W_SMDS_MESH
#define _INCLUDE_DRIVERUNV_W_SMDS_MESH
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_SMDS_Mesh.h"
-class DriverUNV_W_SMDS_Mesh: public Driver_SMDS_Mesh
+class MESHDRIVERUNV_EXPORT DriverUNV_W_SMDS_Mesh: public Driver_SMDS_Mesh
{
public:
virtual Status Perform();
#ifndef _INCLUDE_DRIVERUNV_W_SMESHDS_DOCUMENT
#define _INCLUDE_DRIVERUNV_W_SMESHDS_DOCUMENT
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_Document.h"
-class DriverUNV_W_SMESHDS_Document : public Driver_Document
+class MESHDRIVERUNV_EXPORT DriverUNV_W_SMESHDS_Document : public Driver_Document
{};
#endif
#ifndef _INCLUDE_DRIVERUNV_W_SMESHDS_MESH
#define _INCLUDE_DRIVERUNV_W_SMESHDS_MESH
+#include "SMESH_DriverUNV.hxx"
+
#include "Driver_SMESHDS_Mesh.h"
-class DriverUNV_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
+class MESHDRIVERUNV_EXPORT DriverUNV_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{};
#endif
DriverUNV_W_SMESHDS_Document.cxx \
DriverUNV_W_SMDS_Mesh.cxx \
DriverUNV_W_SMESHDS_Mesh.cxx \
- UNV_Utilities.cxx UNV2411_Structure.cxx UNV2412_Structure.cxx
+ UNV_Utilities.cxx UNV2411_Structure.cxx UNV2412_Structure.cxx SMESH_DriverUNV.hxx
# Executables targets
BIN = UNV_Test
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_DriverUNV.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_DriverUNV_HXX_
+#define _SMESH_DriverUNV_HXX_
+
+#ifdef WNT
+ #if defined MESHDRIVERUNV_EXPORTS
+ #define MESHDRIVERUNV_EXPORT __declspec( dllexport )
+ #else
+ #define MESHDRIVERUNV_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MESHDRIVERUNV_EXPORT
+#endif
+
+#endif
#ifndef UNV2411_Structure_HeaderFile
#define UNV2411_Structure_HeaderFile
+#include "SMESH_DriverUNV.hxx"
+
#include <map>
#include <fstream>
namespace UNV2411{
- struct TRecord{
+ struct MESHDRIVERUNV_EXPORT TRecord{
TRecord();
int exp_coord_sys_num; // export coordinate system number
int disp_coord_sys_num; // displacement coordinate system number
typedef int TNodeLab; // type of node label
typedef std::map<TNodeLab,TRecord> TDataSet;
- void Read(std::ifstream& in_stream, TDataSet& theDataSet);
+ MESHDRIVERUNV_EXPORT void
+ Read(std::ifstream& in_stream, TDataSet& theDataSet);
- void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
+ MESHDRIVERUNV_EXPORT void
+ Write(std::ofstream& out_stream, const TDataSet& theDataSet);
};
#ifndef UNV2412_Structure_HeaderFile
#define UNV2412_Structure_HeaderFile
+#include "SMESH_DriverUNV.hxx"
+
#include <map>
#include <vector>
#include <fstream>
typedef std::vector<int> TNodeLabels; // Nodal connectivities
- struct TRecord{
+ struct MESHDRIVERUNV_EXPORT TRecord{
TRecord();
int fe_descriptor_id; // FE descriptor id
typedef int TElementLab; // type of element label
typedef std::map<TElementLab,TRecord> TDataSet;
- void Read(std::ifstream& in_stream, TDataSet& theDataSet);
+ MESHDRIVERUNV_EXPORT void
+ Read(std::ifstream& in_stream, TDataSet& theDataSet);
- void Write(std::ofstream& out_stream, const TDataSet& theDataSet);
+ MESHDRIVERUNV_EXPORT void
+ Write(std::ofstream& out_stream, const TDataSet& theDataSet);
- bool IsBeam(int theFeDescriptorId);
- bool IsFace(int theFeDescriptorId);
- bool IsVolume(int theFeDescriptorId);
+ MESHDRIVERUNV_EXPORT bool
+ IsBeam(int theFeDescriptorId);
+ MESHDRIVERUNV_EXPORT bool
+ IsFace(int theFeDescriptorId);
+ MESHDRIVERUNV_EXPORT bool
+ IsVolume(int theFeDescriptorId);
};
#ifndef MED_Utilities_HeaderFile
#define MED_Utilities_HeaderFile
+#include "SMESH_DriverUNV.hxx"
+
#include <iostream>
#include <sstream>
#include <string>
namespace UNV{
using namespace std;
- class PrefixPrinter{
+ class MESHDRIVERUNV_EXPORT PrefixPrinter{
static int myCounter;
public:
PrefixPrinter();
#include "Rn.h"
#include "aptrte.h"
+#ifndef WIN32
#include "utilities.h"
using namespace std;
+#endif
extern "C"
{
//Retourne le temps CPU utilise en secondes
{
tempsec = ( (double) clock() ) / CLOCKS_PER_SEC;
- //MESSAGE( "temps cpu=" << tempsec );
+ // MESSAGEE( "temps cpu=" << tempsec );
}
tempscpu_( cpunew );
dtcpu = R( cpunew - cpuold );
cpuold = cpunew;
- //MESSAGE( "delta temps cpu=" << dtcpu );
+ // MESSAGEE( "delta temps cpu=" << dtcpu );
return;
}
// majoration empirique du nombre de sommets de la triangulation
i = 4*nbarfr/10;
mxsomm = Max( 20000, 64*nbpti+i*i );
- MESSAGE( "APTRTE: Depart de la triangulation avec " );
- MESSAGE( "nutysu=" << nutysu << " aretmx=" << aretmx << " mxsomm=" << mxsomm );
+ // MESSAGEE( "APTRTE: Depart de la triangulation avec " );
+ // MESSAGEE( "nutysu=" << nutysu << " aretmx=" << aretmx << " mxsomm=" << mxsomm );
NEWDEPART:
//mnpxyd( 3, mxsomm ) les coordonnees UV des sommets et la taille d'arete aux sommets
aremax = sqrt( aremax ); //longueur maximale d'une arete
aretmx = Min( aretmx, aremax ); //pour homogeneiser
- MESSAGE("nutysu=" << nutysu << " aretmx=" << aretmx
- << " arete min=" << aremin << " arete max=" << aremax);
+ // MESSAGEE("nutysu=" << nutysu << " aretmx=" << aretmx
+ // << " arete min=" << aremin << " arete max=" << aremax);
//chainage des aretes frontalieres : la derniere arete frontaliere
mnsoar[ mosoar * noar - mosoar + 5 ] = 0;
mxtree = 2 * mxsomm;
NEWTREE: //en cas de saturation de l'un des tableaux, on boucle
- MESSAGE( "Debut triangulation avec mxsomm=" << mxsomm );
+ // MESSAGEE( "Debut triangulation avec mxsomm=" << mxsomm );
if( mntree != NULL ) delete [] mntree;
nbsomm = nbarpi;
mntree = new Z[motree*(1+mxtree)];
//saturation de letree => sa taille est augmentee et relance
mxtree = mxtree * 2;
ierr = 0;
- MESSAGE( "Nouvelle valeur de mxtree=" << mxtree );
+ // MESSAGEE( "Nouvelle valeur de mxtree=" << mxtree );
goto NEWTREE;
}
deltacpu_( d );
tcpu += d;
- MESSAGE( "Temps de l'ajout arbre-4 des Triangles Equilateraux=" << d << " secondes" );
+ // MESSAGEE( "Temps de l'ajout arbre-4 des Triangles Equilateraux=" << d << " secondes" );
if( ierr != 0 ) goto ERREUR;
//ici le tableau mnpxyd contient les sommets des te et les points frontaliers et internes
deltacpu_( d );
tcpu += d;
- MESSAGE("Temps de l'adaptation et l'homogeneisation de l'arbre-4 des TE="
- << d << " secondes");
+ // MESSAGEE("Temps de l'adaptation et l'homogeneisation de l'arbre-4 des TE="
+ // << d << " secondes");
if( ierr != 0 )
{
//destruction du tableau auxiliaire et de l'arbre
{
//letree sature
mxtree = mxtree * 2;
- MESSAGE( "Redemarrage avec la valeur de mxtree=" << mxtree );
+ // MESSAGEE( "Redemarrage avec la valeur de mxtree=" << mxtree );
ierr = 0;
goto NEWTREE;
}
//Temps calcul
deltacpu_( d );
tcpu += d;
- MESSAGE( "Temps de la triangulation des TE=" << d << " secondes" );
+ // MESSAGEE( "Temps de la triangulation des TE=" << d << " secondes" );
// ierr =0 si pas d'erreur
// =1 si le tableau mnsoar est sature
mosoar, mxsoar, n1soar, mnsoar, na,
moartr, mxartr, n1artr, mnartr, n );
- MESSAGE( "Nombre d'echanges des diagonales de 2 triangles=" << n );
+ // MESSAGEE( "Nombre d'echanges des diagonales de 2 triangles=" << n );
deltacpu_( d );
tcpu += d;
- MESSAGE("Temps de la triangulation Delaunay par echange des diagonales="
- << d << " secondes");
+ // MESSAGEE("Temps de la triangulation Delaunay par echange des diagonales="
+ // << d << " secondes");
//qualites de la triangulation actuelle
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
mxarcf, mn1arcf, mnarcf, mnarcf1, mnarcf2,
n, ierr );
- MESSAGE( "Restauration de " << n << " aretes perdues de la frontiere" );
+ // MESSAGEE( "Restauration de " << n << " aretes perdues de la frontiere" );
deltacpu_( d );
tcpu += d;
- MESSAGE("Temps de la recuperation des aretes perdues de la frontiere="
- << d << " secondes");
+ // MESSAGEE("Temps de la recuperation des aretes perdues de la frontiere="
+ // << d << " secondes");
if( ierr != 0 ) goto ERREUR;
deltacpu_( d );
tcpu += d;
- MESSAGE( "Temps de la suppression des triangles externes=" << d );
+ // MESSAGEE( "Temps de la suppression des triangles externes=" << d );
if( ierr != 0 ) goto ERREUR;
//qualites de la triangulation actuelle
deltacpu_( d );
tcpu += d;
- MESSAGE( "Temps de l'amelioration de la qualite de la triangulation=" << d );
+ // MESSAGEE( "Temps de l'amelioration de la qualite de la triangulation=" << d );
if( ierr != 0 ) goto ERREUR;
//qualites de la triangulation finale
}
}
nbt /= 4; //le nombre final de triangles de la surface
- MESSAGE("Nombre de sommets=" << nbst
- << " Nombre de triangles=" << nbt);
+ // MESSAGEE("Nombre de sommets=" << nbst
+ // << " Nombre de triangles=" << nbt);
deltacpu_( d );
tcpu += d;
- MESSAGE( "Temps total de la triangulation=" << tcpu << " secondes" );
+ // MESSAGEE( "Temps total de la triangulation=" << tcpu << " secondes" );
// destruction des tableaux auxiliaires
// ------------------------------------
}
else
{
- MESSAGE( "Triangulation non realisee " << ierr );
+ // MESSAGEE( "Triangulation non realisee " << ierr );
if( ierr == 0 ) ierr=1;
goto NETTOYAGE;
}
{
//un triangle d'aire negative de plus
nbtrianeg++;
- MESSAGE("ATTENTION: le triangle " << nt << " de sommets:"
- << nosotr[0] << " " << nosotr[1] << " " << nosotr[2]
- << " a une aire " << d <<"<=0");
+ // MESSAGEE("ATTENTION: le triangle " << nt << " de sommets:"
+ // << nosotr[0] << " " << nosotr[1] << " " << nosotr[2]
+ // << " a une aire " << d <<"<=0");
}
//aire des triangles actuels
//les affichages
quamoy /= nbtria;
- MESSAGE("Qualite moyenne=" << quamoy
- << " Qualite minimale=" << quamin
- << " des " << nbtria << " triangles de surface totale="
- << aire);
+ // MESSAGEE("Qualite moyenne=" << quamoy
+ // << " Qualite minimale=" << quamin
+ // << " des " << nbtria << " triangles de surface totale="
+ // << aire);
- if( nbtrianeg>0 )
- MESSAGE( "ATTENTION: nombre de triangles d'aire negative=" << nbtrianeg );
+ //if( nbtrianeg>0 )
+ // MESSAGE( "ATTENTION: nombre de triangles d'aire negative=" << nbtrianeg );
return;
}
#define aptrte__h
#include <limits.h> // limites min max int long real ...
+#ifndef WIN32
#include <unistd.h> // gethostname, ...
+#endif
#include <stdio.h>
+#ifndef WIN32
#include <iostream.h> // pour cout cin ...
#include <iomanip.h> // pour le format des io setw, stx, setfill, ...
+#endif
#include <string.h> // pour les fonctions sur les chaines de caracteres
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
+#ifndef WIN32
#include <sys/time.h>
+#endif
+
+#ifdef WNT
+ #if defined MEFISTO2D_EXPORTS
+ #define MEFISTO2D_EXPORT __declspec( dllexport )
+ #else
+ #define MEFISTO2D_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define MEFISTO2D_EXPORT
+#endif
-void qualitetrte( R3 *mnpxyd,
+ void qualitetrte( R3 *mnpxyd,
Z & mosoar, Z & mxsoar, Z *mnsoar,
Z & moartr, Z & mxartr, Z *mnartr,
Z & nbtria, R & quamoy, R & quamin );
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void aptrte( Z nutysu, R aretmx,
+MEFISTO2D_EXPORT
+ void aptrte( Z nutysu, R aretmx,
Z nblf, Z *nudslf, R2 *uvslf,
Z nbpti, R2 *uvpti,
Z & nbst, R2 * & uvst, Z & nbt, Z * & nust,
class vtkPlane;
class vtkImplicitBoolean;
-class SMESH_Actor: public SALOME_Actor
+class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
{
static SMESH_Actor* New() { return NULL;}
class SMESH_DeviceActor;
-class SMESH_ActorDef : public SMESH_Actor{
+class SMESHOBJECT_EXPORT SMESH_ActorDef : public SMESH_Actor{
friend class SMESH_VisualObj;
friend class SMESH_Actor;
#ifndef SMESH_ACTORUTILS_H
#define SMESH_ACTORUTILS_H
+#include "SMESH_Object.h"
+
#include <qcolor.h>
#include <qstring.h>
namespace SMESH{
- float GetFloat( const QString& theValue, float theDefault = 0 );
- float GetFloat( const QString& theName, const QString& theSection, float theDefault = 0 );
+ float SMESHOBJECT_EXPORT GetFloat( const QString& theValue, float theDefault = 0 );
+ float SMESHOBJECT_EXPORT GetFloat( const QString& theName, const QString& theSection, float theDefault = 0 );
- QColor GetColor( const QString& theSect, const QString& theName, const QColor&t = QColor() );
- void GetColor( const QString& theSect, const QString& theName, int&, int&, int&, const QColor&t = QColor() );
- void GetColor( const QString& theSect, const QString& theName, float&, float&, float&, const QColor&t = QColor() );
+ QColor SMESHOBJECT_EXPORT GetColor( const QString& theSect, const QString& theName, const QColor&t = QColor() );
+ void SMESHOBJECT_EXPORT GetColor( const QString& theSect, const QString& theName, int&, int&, int&, const QColor&t = QColor() );
+ void SMESHOBJECT_EXPORT GetColor( const QString& theSect, const QString& theName, float&, float&, float&, const QColor&t = QColor() );
void WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, const char* theFileName);
class SMESH_ExtractGeometry;
-class SMESH_DeviceActor: public vtkLODActor{
+class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
friend class SMESH_ActorDef;
public:
#ifndef SALOME_ExtractGeometry_HeaderFile
#define SALOME_ExtractGeometry_HeaderFile
+#include "SMESH_Object.h"
+
#include <vtkExtractGeometry.h>
#include <vector>
-class SMESH_ExtractGeometry : public vtkExtractGeometry{
+class SMESHOBJECT_EXPORT SMESH_ExtractGeometry : public vtkExtractGeometry{
public:
vtkTypeMacro(SMESH_ExtractGeometry,vtkExtractGeometry);
if ( theEdgeNum < 0 || theEdgeNum > 3 || nbNodes != 3 && nbNodes != 4 || theEdgeNum > nbNodes )
return false;
- int anIds[ nbNodes ];
+ vector<int> anIds( nbNodes );
SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
int i = 0;
while( anIter->more() )
int nbNodes = anIndexes[i++];
// nodes
//ASSERT( nbNodes < 9 );
- const SMDS_MeshNode* aNodes[ nbNodes ];
+ const SMDS_MeshNode** aNodes = new const SMDS_MeshNode*[ nbNodes ];
for ( int iNode = 0; iNode < nbNodes; iNode++ )
aNodes[ iNode ] = FindNode( myMesh, anIndexes[i++] );
// change
#ifndef SMESH_OBJECT_H
#define SMESH_OBJECT_H
+#ifdef WNT
+ #if defined SMESHOBJECT_EXPORTS
+ #define SMESHOBJECT_EXPORT __declspec( dllexport )
+ #else
+ #define SMESHOBJECT_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESHOBJECT_EXPORT
+#endif
+
#include <boost/shared_ptr.hpp>
#include <vtkSystemIncludes.h>
Class : SMESH_VisualObj
Description : Base class for all mesh objects to be visuilised
*/
-class SMESH_VisualObj
+class SMESHOBJECT_EXPORT SMESH_VisualObj
{
public:
virtual void Update( int theIsClear = true ) = 0;
Class : SMESH_VisualObj
Description : Base class for all mesh objects to be visuilised
*/
-class SMESH_VisualObjDef: public SMESH_VisualObj
+class SMESHOBJECT_EXPORT SMESH_VisualObjDef: public SMESH_VisualObj
{
public:
typedef std::list<const SMDS_MeshElement*> TEntityList;
Description : Class for visualisation of mesh
*/
-class SMESH_MeshObj: public SMESH_VisualObjDef
+class SMESHOBJECT_EXPORT SMESH_MeshObj: public SMESH_VisualObjDef
{
public:
Description : Base class for visualisation of submeshes and groups
*/
-class SMESH_SubMeshObj: public SMESH_VisualObjDef
+class SMESHOBJECT_EXPORT SMESH_SubMeshObj: public SMESH_VisualObjDef
{
public:
Description : Class for visualisation of groups
*/
-class SMESH_GroupObj: public SMESH_SubMeshObj
+class SMESHOBJECT_EXPORT SMESH_GroupObj: public SMESH_SubMeshObj
{
public:
SMESH_GroupObj( SMESH::SMESH_GroupBase_ptr, SMESH_MeshObj* );
Description : Class for visualisation of submeshes
*/
-class SMESH_subMeshObj : public SMESH_SubMeshObj
+class SMESHOBJECT_EXPORT SMESH_subMeshObj : public SMESH_SubMeshObj
{
public:
SMDS_FaceOfEdges.hxx \
SMDS_FaceOfNodes.hxx \
SMDS_PolygonalFaceOfNodes.hxx \
- SMDS_VolumeTool.hxx
+ SMDS_VolumeTool.hxx \
+ SMESH_SMDS.hxx
# SMDS_Tria3OfNodes.hxx \
# SMDS_HexahedronOfNodes.hxx
#ifndef _SMDS_EdgePosition_HeaderFile
#define _SMDS_EdgePosition_HeaderFile
-#include "SMDS_Position.hxx"
-
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
+#include "SMESH_SMDS.hxx"
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
+#include "SMDS_Position.hxx"
-class SMDS_WNT_EXPORT SMDS_EdgePosition:public SMDS_Position
+class SMDS_EXPORT SMDS_EdgePosition:public SMDS_Position
{
public:
#ifndef _SMDS_FaceOfEdges_HeaderFile
#define _SMDS_FaceOfEdges_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshEdge.hxx"
#include "SMDS_Iterator.hxx"
#include <iostream>
-class SMDS_FaceOfEdges:public SMDS_MeshFace
+class SMDS_EXPORT SMDS_FaceOfEdges:public SMDS_MeshFace
{
public:
void Print(std::ostream & OS) const;
#ifndef _SMDS_FaceOfNodes_HeaderFile
#define _SMDS_FaceOfNodes_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshFace.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_Iterator.hxx"
#include <iostream>
-class SMDS_FaceOfNodes:public SMDS_MeshFace
+class SMDS_EXPORT SMDS_FaceOfNodes:public SMDS_MeshFace
{
public:
void Print(std::ostream & OS) const;
#ifndef _SMDS_FacePosition_HeaderFile
#define _SMDS_FacePosition_HeaderFile
-#include "SMDS_Position.hxx"
-
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
+#include "SMESH_SMDS.hxx"
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
+#include "SMDS_Position.hxx"
-class SMDS_WNT_EXPORT SMDS_FacePosition:public SMDS_Position
+class SMDS_EXPORT SMDS_FacePosition:public SMDS_Position
{
public:
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_Iterator.hxx"
#include "SMDS_MeshElement.hxx"
#include <set>
-class SMDS_IteratorOfElements:public SMDS_ElemIterator
+class SMDS_EXPORT SMDS_IteratorOfElements:public SMDS_ElemIterator
{
public:
/////////////////////////////////////////////////////////////////////////////
#ifndef _SMDS_Mesh_HeaderFile
#define _SMDS_Mesh_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshNode.hxx"
#include "SMDS_MeshEdge.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_ElemIterator.hxx"
#include <NCollection_Map.hxx>
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
#include <boost/shared_ptr.hpp>
#include <set>
#include <list>
typedef SMDS_Iterator<const SMDS_MeshVolume *> SMDS_VolumeIterator;
typedef boost::shared_ptr<SMDS_Iterator<const SMDS_MeshVolume *> > SMDS_VolumeIteratorPtr;
-class SMDS_WNT_EXPORT SMDS_Mesh:public SMDS_MeshObject{
+class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
public:
SMDS_Mesh();
#ifndef _SMDS_MeshEdge_HeaderFile
#define _SMDS_MeshEdge_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshElement.hxx"
#include <iostream>
-class SMDS_MeshEdge:public SMDS_MeshElement
+class SMDS_EXPORT SMDS_MeshEdge:public SMDS_MeshElement
{
public:
#ifndef _SMDS_MeshElement_HeaderFile
#define _SMDS_MeshElement_HeaderFile
+
+#include "SMESH_SMDS.hxx"
#include "SMDSAbs_ElementType.hxx"
#include "SMDS_MeshObject.hxx"
#include "SMDS_ElemIterator.hxx"
#include "SMDS_MeshElementIDFactory.hxx"
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
#include <vector>
#include <iostream>
///////////////////////////////////////////////////////////////////////////////
/// Base class for elements
///////////////////////////////////////////////////////////////////////////////
-class SMDS_WNT_EXPORT SMDS_MeshElement:public SMDS_MeshObject
+class SMDS_EXPORT SMDS_MeshElement:public SMDS_MeshObject
{
public:
#ifndef _SMDS_MeshElementIDFactory_HeaderFile
#define _SMDS_MeshElementIDFactory_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshIDFactory.hxx"
#include "SMDS_ElemIterator.hxx"
typedef NCollection_DataMap<int, SMDS_MeshElement *> SMDS_IdElementMap;
-class SMDS_MeshElementIDFactory:public SMDS_MeshIDFactory
+class SMDS_EXPORT SMDS_MeshElementIDFactory:public SMDS_MeshIDFactory
{
public:
SMDS_MeshElementIDFactory();
#ifndef _SMDS_MeshFace_HeaderFile
#define _SMDS_MeshFace_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshElement.hxx"
-class SMDS_MeshFace:public SMDS_MeshElement
+class SMDS_EXPORT SMDS_MeshFace:public SMDS_MeshElement
{
public:
SMDSAbs_ElementType GetType() const;
#ifndef _SMDS_MeshGroup_HeaderFile
#define _SMDS_MeshGroup_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_Mesh.hxx"
#include <set>
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
-class SMDS_WNT_EXPORT SMDS_MeshGroup:public SMDS_MeshObject
+class SMDS_EXPORT SMDS_MeshGroup:public SMDS_MeshObject
{
public:
SMDS_MeshGroup(const SMDS_Mesh * theMesh,
#ifndef _SMDS_MeshIDFactory_HeaderFile
#define _SMDS_MeshIDFactory_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshObject.hxx"
#include <set>
-class SMDS_MeshIDFactory:public SMDS_MeshObject
+class SMDS_EXPORT SMDS_MeshIDFactory:public SMDS_MeshObject
{
public:
virtual int GetFreeID();
#ifndef _SMDS_MeshNode_HeaderFile
#define _SMDS_MeshNode_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshElement.hxx"
#include "SMDS_Position.hxx"
#include <NCollection_List.hxx>
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
-class SMDS_WNT_EXPORT SMDS_MeshNode:public SMDS_MeshElement
+class SMDS_EXPORT SMDS_MeshNode:public SMDS_MeshElement
{
public:
#ifndef _SMDS_MeshObject_HeaderFile
#define _SMDS_MeshObject_HeaderFile
+#include "SMESH_SMDS.hxx"
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
-class SMDS_WNT_EXPORT SMDS_MeshObject
+class SMDS_EXPORT SMDS_MeshObject
{
public:
virtual ~SMDS_MeshObject() {}
#ifndef _SMDS_MeshVolume_HeaderFile
#define _SMDS_MeshVolume_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshElement.hxx"
-class SMDS_MeshVolume:public SMDS_MeshElement
+class SMDS_EXPORT SMDS_MeshVolume:public SMDS_MeshElement
{
public:
#ifndef _SMDS_PolygonalFaceOfNodes_HeaderFile
#define _SMDS_PolygonalFaceOfNodes_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshFace.hxx"
//#include "SMDS_FaceOfNodes.hxx"
#include "SMDS_MeshNode.hxx"
#include <iostream>
//class SMDS_PolygonalFaceOfNodes:public SMDS_FaceOfNodes
-class SMDS_PolygonalFaceOfNodes:public SMDS_MeshFace
+class SMDS_EXPORT SMDS_PolygonalFaceOfNodes:public SMDS_MeshFace
{
public:
SMDS_PolygonalFaceOfNodes (std::vector<const SMDS_MeshNode *> nodes);
#ifndef _SMDS_PolyhedralVolumeOfNodes_HeaderFile
#define _SMDS_PolyhedralVolumeOfNodes_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_VolumeOfNodes.hxx"
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-class SMDS_WNT_EXPORT SMDS_PolyhedralVolumeOfNodes:public SMDS_VolumeOfNodes
+class SMDS_EXPORT SMDS_PolyhedralVolumeOfNodes:public SMDS_VolumeOfNodes
{
public:
SMDS_PolyhedralVolumeOfNodes (std::vector<const SMDS_MeshNode *> nodes,
#ifndef _SMDS_Position_HeaderFile
#define _SMDS_Position_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_TypeOfPosition.hxx"
#include <boost/shared_ptr.hpp>
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
class SMDS_Position;
typedef boost::shared_ptr<SMDS_Position> SMDS_PositionPtr;
-
-class SMDS_WNT_EXPORT SMDS_Position
+class SMDS_EXPORT SMDS_Position
{
public:
#ifndef _SMDS_SpacePosition_HeaderFile
#define _SMDS_SpacePosition_HeaderFile
-#include "SMDS_Position.hxx"
-
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
+#include "SMESH_SMDS.hxx"
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
+#include "SMDS_Position.hxx"
-class SMDS_WNT_EXPORT SMDS_SpacePosition:public SMDS_Position
+class SMDS_EXPORT SMDS_SpacePosition:public SMDS_Position
{
public:
#ifndef _SMDS_VertexPosition_HeaderFile
#define _SMDS_VertexPosition_HeaderFile
-#include "SMDS_Position.hxx"
-
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
+#include "SMESH_SMDS.hxx"
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
+#include "SMDS_Position.hxx"
-class SMDS_WNT_EXPORT SMDS_VertexPosition:public SMDS_Position
+class SMDS_EXPORT SMDS_VertexPosition:public SMDS_Position
{
public:
#ifndef _SMDS_VolumeOfFaces_HeaderFile
#define _SMDS_VolumeOfFaces_HeaderFile
+#include "SMESH_SMDS.hxx"
+
#include "SMDS_MeshVolume.hxx"
#include "SMDS_MeshFace.hxx"
#include "SMDS_Iterator.hxx"
#include <iostream>
-class SMDS_VolumeOfFaces:public SMDS_MeshVolume
+class SMDS_EXPORT SMDS_VolumeOfFaces:public SMDS_MeshVolume
{
public:
#ifndef _SMDS_VolumeOfNodes_HeaderFile
#define _SMDS_VolumeOfNodes_HeaderFile
-#include "SMDS_MeshVolume.hxx"
+#include "SMESH_SMDS.hxx"
+#include "SMDS_MeshVolume.hxx"
-class SMDS_VolumeOfNodes:public SMDS_MeshVolume
+class SMDS_EXPORT SMDS_VolumeOfNodes:public SMDS_MeshVolume
{
public:
#ifndef SMDS_VolumeTool_HeaderFile
#define SMDS_VolumeTool_HeaderFile
+#include "SMESH_SMDS.hxx"
+
class SMDS_MeshElement;
class SMDS_MeshNode;
class SMDS_PolyhedralVolumeOfNodes;
#include <vector>
#include <set>
-//#ifdef WNT
-//#include <SALOME_WNT.hxx>
-//#else
-//#define SALOME_WNT_EXPORT
-//#endif
-
-#if defined WNT && defined WIN32 && defined SMDS_EXPORTS
-#define SMDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMDS_WNT_EXPORT
-#endif
-
// =========================================================================
//
// Class providing topological and other information about SMDS_MeshVolume:
//
// =========================================================================
-class SMDS_WNT_EXPORT SMDS_VolumeTool
+class SMDS_EXPORT SMDS_VolumeTool
{
public:
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_SMDS.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_SMDS_HXX_
+#define _SMESH_SMDS_HXX_
+
+#ifdef WNT
+ #if defined SMDS_EXPORTS
+ #define SMDS_EXPORT __declspec( dllexport )
+ #else
+ #define SMDS_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMDS_EXPORT
+#endif
+
+#endif
\ No newline at end of file
SMESH_IndexedDataMapOfShapeIndexedMapOfShape.hxx \
SMESH_DataMapOfElemPtrSequenceOfElemPtr.hxx \
SMESH_SequenceOfElemPtr.hxx \
- SMESH_SequenceOfNode.hxx
+ SMESH_SequenceOfNode.hxx \
+ SMESH_SMESH.hxx
EXPORT_PYSCRIPTS =
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_1D_Algo.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_1D_ALGO_HXX_
#define _SMESH_1D_ALGO_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Algo.hxx"
-class SMESH_1D_Algo:
+class SMESH_EXPORT SMESH_1D_Algo:
public SMESH_Algo
{
public:
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_2D_Algo.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_2D_ALGO_HXX_
#define _SMESH_2D_ALGO_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Algo.hxx"
#include <TopoDS_Wire.hxx>
-class SMESH_2D_Algo:
+class SMESH_EXPORT SMESH_2D_Algo:
public SMESH_Algo
{
public:
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_3D_Algo.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_3D_ALGO_HXX_
#define _SMESH_3D_ALGO_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Algo.hxx"
-class SMESH_3D_Algo:
+class SMESH_EXPORT SMESH_3D_Algo:
public SMESH_Algo
{
public:
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_Algo.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
#include <algorithm>
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_ALGO_HXX_
#define _SMESH_ALGO_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Hypothesis.hxx"
#include <TopoDS_Shape.hxx>
class TopoDS_Shape;
class SMESHDS_Mesh;
-class SMESH_Algo:public SMESH_Hypothesis
+class SMESH_EXPORT SMESH_Algo:public SMESH_Hypothesis
{
public:
SMESH_Algo(int hypId, int studyId, SMESH_Gen * gen);
#ifndef SMESH_Block_HeaderFile
#define SMESH_Block_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
// parameters inside the block and vice versa
// =========================================================
-class SMESH_Block: public math_FunctionSetWithDerivatives
+class SMESH_EXPORT SMESH_Block: public math_FunctionSetWithDerivatives
{
public:
enum TShapeID { // ids of the block sub-shapes
#ifndef SMESH_DataMapOfElemPtrSequenceOfElemPtr_HeaderFile
#define SMESH_DataMapOfElemPtrSequenceOfElemPtr_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <SMESH_SequenceOfElemPtr.hxx>
#include <NCollection_DefineDataMap.hxx>
+SMESH_EXPORT
inline Standard_Integer HashCode(SMDS_MeshElementPtr theElem,
const Standard_Integer theUpper)
{
return HashCode(anElem,theUpper);
}
+SMESH_EXPORT
inline Standard_Boolean IsEqual(SMDS_MeshElementPtr theOne,
SMDS_MeshElementPtr theTwo)
{
#ifndef _SMESH_GEN_HXX_
#define _SMESH_GEN_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "Utils_SALOME_Exception.hxx"
#include "SMESH_Hypothesis.hxx"
SMESHDS_Document * myDocument;
} StudyContextStruct;
-class SMESH_Gen
+class SMESH_EXPORT SMESH_Gen
{
public:
SMESH_Gen();
#ifndef _SMESH_Group_HeaderFile
#define _SMESH_Group_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <SMDSAbs_ElementType.hxx>
#include <string>
#include <TopoDS_Shape.hxx>
class SMESHDS_GroupBase;
class SMESH_Mesh;
-class SMESH_Group
+class SMESH_EXPORT SMESH_Group
{
public:
#ifndef SMESH_HypoFilter_HeaderFile
#define SMESH_HypoFilter_HeaderFile
+#include "SMESH_SMESH.hxx"
+
// ===========================
// Filter of SMESH_Hypothesis
// ===========================
class SMESH_HypoFilter;
class SMESH_Hypothesis;
-class SMESH_HypoPredicate {
+class SMESH_EXPORT SMESH_HypoPredicate {
public:
virtual bool IsOk(const SMESH_Hypothesis* aHyp,
const TopoDS_Shape& aShape) const = 0;
// Module : SMESH
// $Header$
-using namespace std;
-using namespace std;
#include "SMESH_Hypothesis.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_subMesh.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_HYPOTHESIS_HXX_
#define _SMESH_HYPOTHESIS_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESHDS_Hypothesis.hxx"
class SMESH_Gen;
class TopoDS_Shape;
class SMESH_Mesh;
-class SMESH_Hypothesis: public SMESHDS_Hypothesis
+class SMESH_EXPORT SMESH_Hypothesis: public SMESHDS_Hypothesis
{
public:
enum Hypothesis_Status // in the order of severity
#ifndef SMESH_IndexedMapOfShape_HeaderFile
#define SMESH_IndexedMapOfShape_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <NCollection_DefineIndexedMap.hxx>
#include <TopoDS_Shape.hxx>
+SMESH_EXPORT
inline Standard_Boolean IsEqual(const TopoDS_Shape& S1,
const TopoDS_Shape& S2)
{
#ifndef _SMESH_MESH_HXX_
#define _SMESH_MESH_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Hypothesis.hxx"
//#include "SMESH_subMesh.hxx"
//typedef NMTTools_IndexedDataMapOfShapeIndexedMapOfShape IndexedMapOfChain;
typedef SMESH_IndexedDataMapOfShapeIndexedMapOfShape IndexedMapOfChain;
-class SMESH_Mesh
+class SMESH_EXPORT SMESH_Mesh
{
SMESH_Mesh();
SMESH_Mesh(const SMESH_Mesh&);
// iNotSame is where prevNodes and nextNodes are different
//=======================================================================
-static bool isReverse(const SMDS_MeshNode* prevNodes[],
- const SMDS_MeshNode* nextNodes[],
+static bool isReverse(vector<const SMDS_MeshNode*> prevNodes,
+ vector<const SMDS_MeshNode*> nextNodes,
const int nbNodes,
const int iNotSame)
{
// Loop on elem nodes:
// find new nodes and detect same nodes indices
int nbNodes = elem->NbNodes();
- list<const SMDS_MeshNode*>::const_iterator itNN[ nbNodes ];
- const SMDS_MeshNode* prevNod[ nbNodes ], *nextNod[ nbNodes ];
+ //list<const SMDS_MeshNode*>::const_iterator itNN[ nbNodes ];
+ vector<list<const SMDS_MeshNode*>::const_iterator> itNN( nbNodes );
+ //const SMDS_MeshNode* prevNod[ nbNodes ], *nextNod[ nbNodes ];
+ vector<const SMDS_MeshNode*> prevNod( nbNodes );
+ vector<const SMDS_MeshNode*> nextNod( nbNodes );
+
int iNode, nbSame = 0, iNotSameNode = 0, iSameNode = 0;
for ( iNode = 0; iNode < nbNodes; iNode++ )
set<const SMDS_MeshNode*> nodeSet;
// get simple seq of nodes
- const SMDS_MeshNode* simpleNodes[ nbNodes ];
+ //const SMDS_MeshNode* simpleNodes[ nbNodes ];
+ vector<const SMDS_MeshNode*> simpleNodes( nbNodes );
int iSimple = 0, nbUnique = 0;
simpleNodes[iSimple++] = faceNodes[0];
int aShapeId = FindShape( elem );
set<const SMDS_MeshNode*> nodeSet;
- const SMDS_MeshNode* curNodes[ nbNodes ], *uniqueNodes[ nbNodes ];
- int iUnique = 0, iCur = 0, nbRepl = 0, iRepl [ nbNodes ];
+ //const SMDS_MeshNode* curNodes[ nbNodes ], *uniqueNodes[ nbNodes ];
+ const SMDS_MeshNode** curNodes = new const SMDS_MeshNode*[ nbNodes ];
+ const SMDS_MeshNode** uniqueNodes = new const SMDS_MeshNode*[ nbNodes ];
+
+ int iUnique = 0, iCur = 0, nbRepl = 0;
+ vector<int> iRepl( nbNodes );
// get new seq of nodes
SMDS_ElemIteratorPtr itN = elem->nodesIterator();
rmElemIds.push_back( elem->GetID() );
}
+ delete curNodes;
+ delete uniqueNodes;
} // loop on elements
// Remove equal nodes and bad elements
Remove( rmNodeIds, true );
Remove( rmElemIds, false );
-
}
//=======================================================================
continue;
// get face nodes and find index of n1
int i1, nbN = elem->NbNodes(), iNode = 0;
- const SMDS_MeshNode* faceNodes[ nbN ], *n;
+ //const SMDS_MeshNode* faceNodes[ nbN ], *n;
+ vector<const SMDS_MeshNode*> faceNodes( nbN );
+ const SMDS_MeshNode* n;
SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
while ( nIt->more() ) {
faceNodes[ iNode ] = static_cast<const SMDS_MeshNode*>( nIt->next() );
const SMDS_MeshElement* elem = invElemIt->next();
// prepare data for a loop on links, of a face or a volume
int iPrevNode, iNode = 0, nbNodes = elem->NbNodes();
- const SMDS_MeshNode* faceNodes[ nbNodes ];
+ //const SMDS_MeshNode* faceNodes[ nbNodes ];
+ const SMDS_MeshNode** faceNodes = new const SMDS_MeshNode*[ nbNodes ];
bool isVolume = volume.Set( elem );
const SMDS_MeshNode** nodes = isVolume ? volume.GetNodes() : faceNodes;
if ( isVolume ) // --volume
}
}
}
+ delete faceNodes;
} // loop on inverse elements of prevSideNode
if ( !sideNode ) {
// insert new nodes into the border and the side to get equal nb of segments
// get normalized parameters of nodes on the borders
- double param[ 2 ][ maxNbNodes ];
+ //double param[ 2 ][ maxNbNodes ];
+ double* param[ 2 ];
+ param[0] = new double [ maxNbNodes ];
+ param[1] = new double [ maxNbNodes ];
int iNode, iBord;
for ( iBord = 0; iBord < 2; iBord++ ) { // loop on 2 borders
list< const SMDS_MeshNode* >& nodes = nSide[ iBord ];
}
}
+ delete param[0];
+ delete param[1];
} // end: insert new nodes
MergeNodes ( nodeGroupsToMerge );
// find indices of 2 link nodes and of the rest nodes
int iNode = 0, il1, il2, i3, i4;
il1 = il2 = i3 = i4 = -1;
- const SMDS_MeshNode* nodes[ theFace->NbNodes() ];
+ //const SMDS_MeshNode* nodes[ theFace->NbNodes() ];
+ vector<const SMDS_MeshNode*> nodes( theFace->NbNodes() );
SMDS_ElemIteratorPtr nodeIt = theFace->nodesIterator();
while ( nodeIt->more() ) {
const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
// put aNodesToInsert between theBetweenNode1 and theBetweenNode2
int nbLinkNodes = 2 + aNodesToInsert.size();
- const SMDS_MeshNode* linkNodes[ nbLinkNodes ];
+ //const SMDS_MeshNode* linkNodes[ nbLinkNodes ];
+ vector<const SMDS_MeshNode*> linkNodes( nbLinkNodes );
linkNodes[ 0 ] = nodes[ il1 ];
linkNodes[ nbLinkNodes - 1 ] = nodes[ il2 ];
list<const SMDS_MeshNode*>::iterator nIt = aNodesToInsert.begin();
#ifndef SMESH_MeshEditor_HeaderFile
#define SMESH_MeshEditor_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include "SMESH_Mesh.hxx"
#include "SMESH_Controls.hxx"
#include "SMESH_SequenceOfNode.hxx"
class gp_Vec;
class gp_Pnt;
-class SMESH_MeshEditor {
+class SMESH_EXPORT SMESH_MeshEditor {
public:
SMESH_MeshEditor( SMESH_Mesh* theMesh );
#ifndef SMESH_Pattern_HeaderFile
#define SMESH_Pattern_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <vector>
#include <list>
#include <map>
// of 6 faces.
//
-class SMESH_Pattern {
+class SMESH_EXPORT SMESH_Pattern {
public:
SMESH_Pattern ();
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_SMESH.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_SMESH_HXX_
+#define _SMESH_SMESH_HXX_
+
+#ifdef WNT
+ #if defined SMESH_EXPORTS
+ #define SMESH_EXPORT __declspec( dllexport )
+ #else
+ #define SMESH_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESH_EXPORT
+#endif
+
+#endif
#ifndef SMESH_SequenceOfElemPtr_HeaderFile
#define SMESH_SequenceOfElemPtr_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <NCollection_DefineSequence.hxx>
//#include <Handle_SMDS_MeshElement.hxx>
#ifndef SMESH_SequenceOfNode_HeaderFile
#define SMESH_SequenceOfNode_HeaderFile
+#include "SMESH_SMESH.hxx"
+
#include <NCollection_DefineSequence.hxx>
typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_subMesh.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
#include <TopTools_IndexedMapOfShape.hxx>
#endif
+using namespace std;
+
//=============================================================================
/*!
* default constructor:
#ifndef _SMESH_SUBMESH_HXX_
#define _SMESH_SUBMESH_HXX_
+#include "SMESH_SMESH.hxx"
+
#include "SMESHDS_Mesh.hxx"
#include "SMESHDS_SubMesh.hxx"
#include "SMESH_Hypothesis.hxx"
class SMESH_Algo;
class SMESH_Gen;
-class SMESH_subMesh
+class SMESH_EXPORT SMESH_subMesh
{
public:
SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
SMESHDS_SubMesh.hxx \
SMESHDS_GroupBase.hxx \
SMESHDS_Group.hxx \
- SMESHDS_GroupOnGeom.hxx
+ SMESHDS_GroupOnGeom.hxx \
+ SMESH_SMESHDS.hxx
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome $(BOOST_CPPFLAGS)
#ifndef _SMESHDS_Command_HeaderFile
#define _SMESHDS_Command_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMESHDS_CommandType.hxx"
#include <list>
#include <vector>
-class SMESHDS_Command
+class SMESHDS_EXPORT SMESHDS_Command
{
public:
#ifndef _SMESHDS_Document_HeaderFile
#define _SMESHDS_Document_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMESHDS_Mesh.hxx"
#include "SMESHDS_Hypothesis.hxx"
#include <map>
-class SMESHDS_Document
+class SMESHDS_EXPORT SMESHDS_Document
{
public:
SMESHDS_Document(int UserID);
#ifndef _SMESHDS_Group_HeaderFile
#define _SMESHDS_Group_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include <string>
#include "SMESHDS_GroupBase.hxx"
#include "SMDS_MeshGroup.hxx"
class SMESHDS_Mesh;
-class SMESHDS_Group : public SMESHDS_GroupBase
+class SMESHDS_EXPORT SMESHDS_Group : public SMESHDS_GroupBase
{
public:
#ifndef _SMESHDS_GroupBase_HeaderFile
#define _SMESHDS_GroupBase_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include <string>
#include "SMDSAbs_ElementType.hxx"
#include "SMDS_MeshElement.hxx"
class SMESHDS_Mesh;
-class SMESHDS_GroupBase
+class SMESHDS_EXPORT SMESHDS_GroupBase
{
public:
#ifndef _SMESHDS_GroupOnGeom_HeaderFile
#define _SMESHDS_GroupOnGeom_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMESHDS_GroupBase.hxx"
#include <TopoDS_Shape.hxx>
class SMESHDS_SubMesh;
-class SMESHDS_GroupOnGeom: public SMESHDS_GroupBase
+class SMESHDS_EXPORT SMESHDS_GroupOnGeom: public SMESHDS_GroupBase
{
public:
#ifndef _SMESHDS_HYPOTHESIS_HXX_
#define _SMESHDS_HYPOTHESIS_HXX_
+#include "SMESH_SMESHDS.hxx"
+
#include <string>
#include <iostream>
-class SMESHDS_Hypothesis
+class SMESHDS_EXPORT SMESHDS_Hypothesis
{
public:
SMESHDS_Hypothesis(int hypId);
#ifndef _SMESHDS_Mesh_HeaderFile
#define _SMESHDS_Mesh_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_MeshEdge.hxx"
namespace gstd = std;
#endif
-#if defined WNT && defined WIN32 && defined SMESHDS_EXPORTS
-#define SMESHDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMESHDS_WNT_EXPORT
-#endif
-
class SMESHDS_GroupBase;
-class SMESHDS_WNT_EXPORT SMESHDS_Mesh:public SMDS_Mesh{
+class SMESHDS_EXPORT SMESHDS_Mesh:public SMDS_Mesh{
public:
SMESHDS_Mesh(int MeshID);
void ShapeToMesh(const TopoDS_Shape & S);
#ifndef _SMESHDS_Script_HeaderFile
#define _SMESHDS_Script_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMESHDS_Command.hxx"
#include <list>
#include <vector>
-class SMESHDS_Script
+class SMESHDS_EXPORT SMESHDS_Script
{
public:
void AddNode(int NewNodeID, double x, double y, double z);
#ifndef _SMESHDS_SubMesh_HeaderFile
#define _SMESHDS_SubMesh_HeaderFile
+#include "SMESH_SMESHDS.hxx"
+
#include "SMDS_Mesh.hxx"
#include <set>
-#if defined WNT && defined WIN32 && defined SMESHDS_EXPORTS
-#define SMESHDS_WNT_EXPORT __declspec( dllexport )
-#else
-#define SMESHDS_WNT_EXPORT
-#endif
-
-class SMESHDS_WNT_EXPORT SMESHDS_SubMesh
+class SMESHDS_EXPORT SMESHDS_SubMesh
{
public:
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_SMESHDS.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_SMESHDS_HXX_
+#define _SMESH_SMESHDS_HXX_
+
+#ifdef WNT
+ #if defined SMESHDS_EXPORTS
+ #define SMESHDS_EXPORT __declspec( dllexport )
+ #else
+ #define SMESHDS_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESHDS_EXPORT
+#endif
+
+#endif
\ No newline at end of file
#ifndef _SMESH_LogicalFilter_HeaderFile
#define _SMESH_LogicalFilter_HeaderFile
+#include "SMESH_Type.h"
+
#include <SUIT_SelectionFilter.h>
#include <qptrlist.h>
-class SMESH_LogicalFilter : public SUIT_SelectionFilter
+class SMESHFILTERSSELECTION_EXPORT SMESH_LogicalFilter : public SUIT_SelectionFilter
{
public:
enum { LO_OR, LO_AND, LO_NOT, LO_UNDEFINED };
#ifndef _SMESH_NumberFilter_HeaderFile
#define _SMESH_NumberFilter_HeaderFile
+#include "SMESH_Type.h"
+
#include "SUIT_SelectionFilter.h"
#include <TopAbs_ShapeEnum.hxx>
* * theMainObject - Sub-shapes of this object is selected only
* * theIsClosedOnly - Closed shapes is selected if this parameter is true
*/
-class SMESH_NumberFilter : public SUIT_SelectionFilter
+class SMESHFILTERSSELECTION_EXPORT SMESH_NumberFilter : public SUIT_SelectionFilter
{
public:
SMESH_NumberFilter (const char* theKind,
#ifndef SMESH_TYPE_HEADER
#define SMESH_TYPE_HEADER
+#ifdef WNT
+ #if defined SMESHFILTERSSELECTION_EXPORTS
+ #define SMESHFILTERSSELECTION_EXPORT __declspec( dllexport )
+ #else
+ #define SMESHFILTERSSELECTION_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESHFILTERSSELECTION_EXPORT
+#endif
+
enum MeshObjectType {
HYPOTHESIS,
ALGORITHM,
class SUIT_DataOwner;
-class SMESH_TypeFilter : public SUIT_SelectionFilter
+class SMESHFILTERSSELECTION_EXPORT SMESH_TypeFilter : public SUIT_SelectionFilter
{
public:
SMESH_TypeFilter (MeshObjectType theType);
SMESHGUI_Hypotheses.h \
SMESHGUI_HypothesesUtils.h \
SMESHGUI_SpinBox.h \
- SMESHGUI_Selection.h
+ SMESHGUI_Selection.h \
+ SMESH_SMESHGUI.hxx
# .po files to transform in .qm
PO_FILES = \
aFormat = aFilterMap[fd->selectedFilter()];
is_ok = true;
if( !aFilename.isEmpty()
- && (aMesh->NbPolygons()>0 or aMesh->NbPolyhedrons()>0)
+ && (aMesh->NbPolygons()>0 || aMesh->NbPolyhedrons()>0)
&& aFormat==SMESH::MED_V2_1){
int aRet = SUIT_MessageBox::warn2(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
return RefType;
}
-
-
- void SMESHGUI::OnEditDelete()
- {
- // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
- LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
- SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
-
- QString aParentComponent = QString::null;
- for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
- {
- QString cur = anIt.Value()->getComponentDataType();
- if( aParentComponent.isNull() )
- aParentComponent = cur;
- else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
- aParentComponent = "";
- }
-
- if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
- SUIT_MessageBox::warn1 ( SMESHGUI::desktop(),
- QObject::tr("ERR_ERROR"),
- QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ),
- QObject::tr("BUT_OK") );
- return;
- }
- // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
- if (SUIT_MessageBox::warn2
- (SMESHGUI::desktop(),
- QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_REALLY_DELETE"),
- QObject::tr("SMESH_BUT_YES"), QObject::tr("SMESH_BUT_NO"), 1, 0, 0) != 1)
- return;
-
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
- SUIT_ViewManager* vm = anApp->activeViewManager();
- int nbSf = vm->getViewsCount();
-
- _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
- _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
- _PTR(GenericAttribute) anAttr;
- _PTR(AttributeIOR) anIOR;
-
- SALOME_ListIteratorOfListIO It(selected);
-
- aStudyBuilder->NewCommand(); // There is a transaction
- for(; It.More(); It.Next()){
- Handle(SALOME_InteractiveObject) IObject = It.Value();
- if(IObject->hasEntry()){
- _PTR(SObject) SO = aStudy->FindObjectID(IObject->getEntry());
-
- // disable removal of "SMESH" component object
- if(SO->FindAttribute(anAttr, "AttributeIOR")){
- anIOR = anAttr;
- if ( !strcmp( (char*)anIOR->Value().c_str(), engineIOR().latin1() ) )
- continue;
- }
-
- /* Erase child graphical objects */
- _PTR(ChildIterator) it = aStudy->NewChildIterator(SO);
- for(it->InitEx(true); it->More(); it->Next()){
- _PTR(SObject) CSO = it->Value();
- if(CSO->FindAttribute(anAttr, "AttributeIOR")){
- anIOR = anAttr;
-
- QPtrVector<SUIT_ViewWindow> aViews = vm->getViews();
- for(int i = 0; i < nbSf; i++){
- SUIT_ViewWindow *sf = aViews[i];
- CORBA::String_var anEntry = CSO->GetID().c_str();
- if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.in())){
- SMESH::RemoveActor(sf,anActor);
- }
- }
- }
- }
-
- /* Erase main graphical object */
- QPtrVector<SUIT_ViewWindow> aViews = vm->getViews();
- for(int i = 0; i < nbSf; i++){
- SUIT_ViewWindow *sf = aViews[i];
- if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,IObject->getEntry())){
- SMESH::RemoveActor(sf,anActor);
- }
- }
-
- // Remove object(s) from data structures
- _PTR(SObject) obj = aStudy->FindObjectID(IObject->getEntry());
- if(obj){
- SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( obj ) );
- SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( obj ) );
- QString objType = CheckTypeObject(IObject);
- if ( !aGroup->_is_nil() ) { // DELETE GROUP
- SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
- aMesh->RemoveGroup( aGroup );
- }
- else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
- SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
- aMesh->RemoveSubMesh( aSubMesh );
- }
- else if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
- SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
- aStudyBuilder->RemoveObjectWithChildren( obj );
- }
- else {// default action: remove SObject from the study
- // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
- //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
- //op->start();
- aStudyBuilder->RemoveObjectWithChildren( obj );
- //op->finish();
- }
- }
-
- } /* IObject->hasEntry() */
- } /* more/next */
- aStudyBuilder->CommitCommand();
-
- /* Clear any previous selection */
- SALOME_ListIO l1;
- aSel->setSelectedObjects( l1 );
-
- SMESHGUI::GetSMESHGUI()->updateObjBrowser();
- }
}
extern "C" {
myDisplayer = new SMESHGUI_Displayer( getApp() );
return myDisplayer;
}
+
+void SMESHGUI::OnEditDelete()
+ {
+ // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
+ LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
+ SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
+
+ QString aParentComponent = QString::null;
+ for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
+ {
+ QString cur = anIt.Value()->getComponentDataType();
+ if( aParentComponent.isNull() )
+ aParentComponent = cur;
+ else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
+ aParentComponent = "";
+ }
+
+ if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
+ SUIT_MessageBox::warn1 ( SMESHGUI::desktop(),
+ QObject::tr("ERR_ERROR"),
+ QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ),
+ QObject::tr("BUT_OK") );
+ return;
+ }
+ // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
+ if (SUIT_MessageBox::warn2
+ (SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_REALLY_DELETE"),
+ QObject::tr("SMESH_BUT_YES"), QObject::tr("SMESH_BUT_NO"), 1, 0, 0) != 1)
+ return;
+
+ SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+ SUIT_ViewManager* vm = anApp->activeViewManager();
+ int nbSf = vm->getViewsCount();
+
+ _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
+ _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
+ _PTR(GenericAttribute) anAttr;
+ _PTR(AttributeIOR) anIOR;
+
+ SALOME_ListIteratorOfListIO It(selected);
+
+ aStudyBuilder->NewCommand(); // There is a transaction
+ for(; It.More(); It.Next()){
+ Handle(SALOME_InteractiveObject) IObject = It.Value();
+ if(IObject->hasEntry()){
+ _PTR(SObject) SO = aStudy->FindObjectID(IObject->getEntry());
+
+ // disable removal of "SMESH" component object
+ if(SO->FindAttribute(anAttr, "AttributeIOR")){
+ anIOR = anAttr;
+ if ( !strcmp( (char*)anIOR->Value().c_str(), engineIOR().latin1() ) )
+ continue;
+ }
+
+ /* Erase child graphical objects */
+ _PTR(ChildIterator) it = aStudy->NewChildIterator(SO);
+ for(it->InitEx(true); it->More(); it->Next()){
+ _PTR(SObject) CSO = it->Value();
+ if(CSO->FindAttribute(anAttr, "AttributeIOR")){
+ anIOR = anAttr;
+
+ QPtrVector<SUIT_ViewWindow> aViews = vm->getViews();
+ for(int i = 0; i < nbSf; i++){
+ SUIT_ViewWindow *sf = aViews[i];
+ CORBA::String_var anEntry = CSO->GetID().c_str();
+ if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.in())){
+ SMESH::RemoveActor(sf,anActor);
+ }
+ }
+ }
+ }
+
+ /* Erase main graphical object */
+ QPtrVector<SUIT_ViewWindow> aViews = vm->getViews();
+ for(int i = 0; i < nbSf; i++){
+ SUIT_ViewWindow *sf = aViews[i];
+ if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,IObject->getEntry())){
+ SMESH::RemoveActor(sf,anActor);
+ }
+ }
+
+ // Remove object(s) from data structures
+ _PTR(SObject) obj = aStudy->FindObjectID(IObject->getEntry());
+ if(obj){
+ SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( obj ) );
+ SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( obj ) );
+ QString objType = CheckTypeObject(IObject);
+ if ( !aGroup->_is_nil() ) { // DELETE GROUP
+ SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
+ aMesh->RemoveGroup( aGroup );
+ }
+ else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
+ SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
+ aMesh->RemoveSubMesh( aSubMesh );
+ }
+ else if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
+ SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
+ aStudyBuilder->RemoveObjectWithChildren( obj );
+ }
+ else {// default action: remove SObject from the study
+ // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
+ //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
+ //op->start();
+ aStudyBuilder->RemoveObjectWithChildren( obj );
+ //op->finish();
+ }
+ }
+
+ } /* IObject->hasEntry() */
+ } /* more/next */
+ aStudyBuilder->CommitCommand();
+
+ /* Clear any previous selection */
+ SALOME_ListIO l1;
+ aSel->setSelectedObjects( l1 );
+
+ SMESHGUI::GetSMESHGUI()->updateObjBrowser();
+ }
\ No newline at end of file
#ifndef SMESHGUI_HeaderFile
#define SMESHGUI_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
// SALOME Includes
#include <SalomeApp_Module.h>
#include <SALOME_InteractiveObject.hxx>
// class : SMESHGUI
// purpose :
//=================================================================================
-class SMESHGUI : public SalomeApp_Module
+class SMESHGUI_EXPORT SMESHGUI : public SalomeApp_Module
{
Q_OBJECT;
#ifndef DIALOGBOX_ADD_FACE_H
#define DIALOGBOX_ADD_FACE_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMDSAbs_ElementType.hxx"
// class : SMESHGUI_AddMeshElementDlg
// purpose :
//=================================================================================
-class SMESHGUI_AddMeshElementDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_AddMeshElementDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_CLIPPING_H
#define DIALOGBOX_CLIPPING_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <SMESHGUI_SpinBox.h>
#include <vtkSmartPointer.h>
// class : SMESHGUI_ClippingDlg
// purpose :
//=================================================================================
-class SMESHGUI_ClippingDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_ClippingDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_CREATE_HYPOTHESES_H
#define DIALOGBOX_CREATE_HYPOTHESES_H
+#include "SMESH_SMESHGUI.hxx"
+
// QT Includes
#include <qvariant.h>
#include <qdialog.h>
// class : SMESHGUI_CreateHypothesesDlg
// purpose :
//=================================================================================
-class SMESHGUI_CreateHypothesesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_CreateHypothesesDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_CreatePatternDlg_H
#define SMESHGUI_CreatePatternDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
// IDL Headers
* Description : Dialog to specify filters for VTK viewer
*/
-class SMESHGUI_CreatePatternDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_CreatePatternDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_CREATEPOLYHEDRAL_H
#define DIALOGBOX_CREATEPOLYHEDRAL_H
+#include "SMESH_SMESHGUI.hxx"
+
// QT Includes
#include <qdialog.h>
// class : SMESHGUI_CreatePolyhedralVolumeDlg
// purpose :
//=================================================================================
-class SMESHGUI_CreatePolyhedralVolumeDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_CreatePolyhedralVolumeDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_DELETEGROUPDLG_H
#define SMESHGUI_DELETEGROUPDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include <qlist.h>
* Description : Delete groups and their contents
*/
-class SMESHGUI_DeleteGroupDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_DeleteGroupDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_DIALOG_H
#define SMESHGUI_DIALOG_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <LightApp_Dialog.h>
class SUIT_Desktop;
// class : SMESHGUI_Dialog
// purpose : Base dialog for all SMESHGUI dialogs
//=================================================================================
-class SMESHGUI_Dialog : public LightApp_Dialog
+class SMESHGUI_EXPORT SMESHGUI_Dialog : public LightApp_Dialog
{
Q_OBJECT
#ifndef SMESHGUI_DISPLAYER_HEADER
#define SMESHGUI_DISPLAYER_HEADER
+#include "SMESH_SMESHGUI.hxx"
+
#include <LightApp_Displayer.h>
class SalomeApp_Application;
class SalomeApp_Study;
-class SMESHGUI_Displayer : public LightApp_Displayer
+class SMESHGUI_EXPORT SMESHGUI_Displayer : public LightApp_Displayer
{
public:
SMESHGUI_Displayer( SalomeApp_Application* );
#ifndef DIALOGBOX_EDIT_HYPOTHESES_H
#define DIALOGBOX_EDIT_HYPOTHESES_H
+#include "SMESH_SMESHGUI.hxx"
+
//#include "SMESH_TypeFilter.hxx"
#include "SUIT_SelectionFilter.h"
#include "LightApp_SelectionMgr.h"
// class : SMESHGUI_EditHypothesesDlg
// purpose :
//=================================================================================
-class SMESHGUI_EditHypothesesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_EditHypothesesDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_GETMESH_H
#define DIALOGBOX_GETMESH_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_EditMeshDlg
// purpose :
//=================================================================================
-class SMESHGUI_EditMeshDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_EditMeshDlg : public QDialog
{
Q_OBJECT;
#ifndef DIALOGBOX_EXTRUSION_PATH_H
#define DIALOGBOX_EXTRUSION_PATH_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_ExtrusionAlongPathDlg
// purpose :
//=================================================================================
-class SMESHGUI_ExtrusionAlongPathDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_ExtrusionAlongPathDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_EXTRUSION_H
#define DIALOGBOX_EXTRUSION_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_ExtrusionDlg
// purpose :
//=================================================================================
-class SMESHGUI_ExtrusionDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_ExtrusionDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_Filter_HeaderFile
#define SMESHGUI_Filter_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "VTKViewer_Filter.h"
#include <SALOMEconfig.h>
if (aTable->isRowSelected(i))
{
aRows.resize(aRows.size() + 1);
- aRows[ aRows.size() - 1 ] = i;
+ aRows[ (int)(aRows.size() - 1) ] = i;
removeAdditionalWidget(aTable, i);
}
}
#ifndef SMESHGUI_FilterDlg_H
#define SMESHGUI_FilterDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include <qframe.h>
#include <qmap.h>
* - Buttons for editing table
*/
-class SMESHGUI_FilterTable : public QFrame
+class SMESHGUI_EXPORT SMESHGUI_FilterTable : public QFrame
{
Q_OBJECT
#ifndef SMESHGUI_FilterLibraryDlg_H
#define SMESHGUI_FilterLibraryDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include <SMESHGUI_FilterDlg.h>
Description : Dialog to specify filters for VTK viewer
*/
-class SMESHGUI_FilterLibraryDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_FilterLibraryDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_FilterUtils_HeaderFile
#define SMESHGUI_FilterUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(SMESH_Filter)
namespace SMESH{
- SMESH::FilterManager_var& GetFilterManager();
+ SMESHGUI_EXPORT SMESH::FilterManager_var& GetFilterManager();
}
#ifndef SMESHGUI_GEOMGenUtils_HeaderFile
#define SMESHGUI_GEOMGenUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(GEOM_Gen)
namespace SMESH
{
- GEOM::GEOM_Gen_var GetGEOMGen();
+ SMESHGUI_EXPORT GEOM::GEOM_Gen_var GetGEOMGen();
- GEOM::GEOM_Object_var GetShapeOnMeshOrSubMesh (_PTR(SObject) theSObject);
+ SMESHGUI_EXPORT GEOM::GEOM_Object_var GetShapeOnMeshOrSubMesh (_PTR(SObject) theSObject);
- GEOM::GEOM_Object_ptr GetGeom (_PTR(SObject) theSO);
+ SMESHGUI_EXPORT GEOM::GEOM_Object_ptr GetGeom (_PTR(SObject) theSO);
}
#endif
#ifndef DIALOGBOX_GROUP_H
#define DIALOGBOX_GROUP_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
//#include "SMESH_TypeFilter.hxx"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_GroupDlg
// purpose :
//=================================================================================
-class SMESHGUI_GroupDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_GroupDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_GroupOpDlg_H
#define SMESHGUI_GroupOpDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include <SALOMEconfig.h>
Description : Perform boolean operations on groups
*/
-class SMESHGUI_GroupOpDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_GroupOpDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_GroupUtils_HeaderFile
#define SMESHGUI_GroupUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Group)
namespace SMESH{
+SMESHGUI_EXPORT
SMESH::SMESH_Group_var AddGroup(SMESH::SMESH_Mesh_ptr theMesh,
SMESH::ElementType theType,
const char* theGroupName);
#ifndef SMESHGUI_Hypotheses_HeaderFile
#define SMESHGUI_Hypotheses_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
/*!
* \brief Auxiliary class for creation of hypotheses
*/
-class SMESHGUI_GenericHypothesisCreator : public QObject
+class SMESHGUI_EXPORT SMESHGUI_GenericHypothesisCreator : public QObject
{
Q_OBJECT
#include <map>
#include <string>
-#include <dlfcn.h>
+#ifdef WNT
+ #include <windows.h>
+#else
+ #include <dlfcn.h>
+#endif
+
+#ifdef WNT
+ #define LibHandle HMODULE
+ #define LoadLib( name ) LoadLibrary( name )
+ #define GetProc GetProcAddress
+ #define UnLoadLib( handle ) FreeLibrary( handle );
+#else
+ #define LibHandle void*
+ #define LoadLib( name ) dlopen( name, RTLD_LAZY )
+ #define GetProc dlsym
+ #define UnLoadLib( handle ) dlclose( handle );
+#endif
#ifdef _DEBUG_
static int MYDEBUG = 0;
try {
// load plugin library
if(MYDEBUG) MESSAGE("Loading client meshers plugin library ...");
- void* libHandle = dlopen (aClientLibName, RTLD_LAZY);
+ LibHandle libHandle = LoadLib( aClientLibName );
if (!libHandle) {
// report any error, if occured
- const char* anError = dlerror();
- if(MYDEBUG) MESSAGE(anError);
+ if ( MYDEBUG )
+ {
+#ifdef WIN32
+ const char* anError = "Can't load client meshers plugin library";
+#else
+ const char* anError = dlerror();
+#endif
+ MESSAGE(anError);
+ }
}
else {
// get method, returning hypothesis creator
typedef SMESHGUI_GenericHypothesisCreator* (*GetHypothesisCreator) \
( const QString& );
GetHypothesisCreator procHandle =
- (GetHypothesisCreator)dlsym(libHandle, "GetHypothesisCreator");
+ (GetHypothesisCreator)GetProc(libHandle, "GetHypothesisCreator");
if (!procHandle) {
if(MYDEBUG) MESSAGE("bad hypothesis client plugin library");
- dlclose(libHandle);
+ UnLoadLib(libHandle);
}
else {
// get hypothesis creator
#ifndef SMESHGUI_HypothesesUtils_HeaderFile
#define SMESHGUI_HypothesesUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include <qstring.h>
#include <qstringlist.h>
namespace SMESH{
- void InitAvailableHypotheses();
+ SMESHGUI_EXPORT void InitAvailableHypotheses();
+ SMESHGUI_EXPORT
QStringList GetAvailableHypotheses( const bool isAlgo,
const int theDim = -1,
const bool isAux = false);
-
+ SMESHGUI_EXPORT
QStringList GetHypothesesSets();
+ SMESHGUI_EXPORT
HypothesesSet* GetHypothesesSet(const QString theSetName);
+ SMESHGUI_EXPORT
HypothesisData* GetHypothesisData(const char* aHypType);
+ SMESHGUI_EXPORT
SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator(const char* aHypType);
+ SMESHGUI_EXPORT
SMESH::SMESH_Hypothesis_ptr CreateHypothesis(const char* aHypType,
const char* aHypName,
const bool isAlgo = false);
+ SMESHGUI_EXPORT
bool AddHypothesisOnMesh(SMESH::SMESH_Mesh_ptr aMesh, SMESH::SMESH_Hypothesis_ptr aHyp);
+ SMESHGUI_EXPORT
bool AddHypothesisOnSubMesh(SMESH::SMESH_subMesh_ptr aSubMesh, SMESH::SMESH_Hypothesis_ptr aHyp);
+ SMESHGUI_EXPORT
bool RemoveHypothesisOrAlgorithmOnMesh(const Handle(SALOME_InteractiveObject)& IObject);
+ SMESHGUI_EXPORT
bool RemoveHypothesisOrAlgorithmOnMesh(_PTR(SObject) MorSM,
SMESH::SMESH_Hypothesis_ptr anHyp);
typedef std::vector<_PTR(SObject)> SObjectList;
SObjectList GetMeshesUsingAlgoOrHypothesis(SMESH::SMESH_Hypothesis_ptr AlgoOrHyp ) ;
+ SMESHGUI_EXPORT
QString GetMessageOnAlgoStateErrors(const algo_error_array& errors);
}
#ifndef SMESHGUI_IdValidator_HeaderFile
#define SMESHGUI_IdValidator_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include <qvalidator.h>
// validator for manual input of Ids
-class SMESHGUI_IdValidator: public QValidator
+class SMESHGUI_EXPORT SMESHGUI_IdValidator: public QValidator
{
public:
#ifndef DIALOGBOX_MERGENODES_H
#define DIALOGBOX_MERGENODES_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
//#include "SMESH_TypeFilter.hxx"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_MergeNodesDlg
// purpose :
//=================================================================================
-class SMESHGUI_MergeNodesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_MergeNodesDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_MeshDlg_H
#define SMESHGUI_MeshDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "SMESHGUI_Dialog.h"
#include <qframe.h>
#include <qstringlist.h>
*
* This dialog is used for mech creation or editing.
*/
-class SMESHGUI_MeshDlg : public SMESHGUI_Dialog
+class SMESHGUI_EXPORT SMESHGUI_MeshDlg : public SMESHGUI_Dialog
{
Q_OBJECT
* algorithms and hypotheses
*/
-class SMESHGUI_MeshTab : public QFrame
+class SMESHGUI_EXPORT SMESHGUI_MeshTab : public QFrame
{
Q_OBJECT
#ifndef SMESHGUI_MESHINFOSDLG_H
#define SMESHGUI_MESHINFOSDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
// QT Includes
#include <qdialog.h>
class LightApp_SelectionMgr;
class SMESHGUI;
-class SMESHGUI_MeshInfosDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_MeshInfosDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_MeshOp_H
#define SMESHGUI_MeshOp_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "SMESHGUI_SelectionOp.h"
#include <qstringlist.h>
*
* This operation is used for mech creation or editing.
*/
-class SMESHGUI_MeshOp : public SMESHGUI_SelectionOp
+class SMESHGUI_EXPORT SMESHGUI_MeshOp : public SMESHGUI_SelectionOp
{
Q_OBJECT
#ifndef SMESHGUI_MeshPatternDlg_H
#define SMESHGUI_MeshPatternDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
// IDL Headers
Description : Dialog to specify filters for VTK viewer
*/
-class SMESHGUI_MeshPatternDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_MeshPatternDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_MeshUtils_HeaderFile
#define SMESHGUI_MeshUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SALOME_InteractiveObject.hxx"
#include "SALOMEconfig.h"
namespace SMESH{
+SMESHGUI_EXPORT
SMESH_Mesh_var GetMeshByIO(const Handle(SALOME_InteractiveObject)& theIO);
}
#ifndef DIALOGBOX_MOVE_NODES_H
#define DIALOGBOX_MOVE_NODES_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include <qdialog.h>
// class : SMESHGUI_MoveNodesDlg
// purpose :
//=================================================================================
-class SMESHGUI_MoveNodesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_MoveNodesDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_MultiEditDlg_H
#define SMESHGUI_MultiEditDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include "SUIT_SelectionFilter.h"
* union of two neighboring triangles
*/
-class SMESHGUI_MultiEditDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_MultiEditDlg : public QDialog
{
Q_OBJECT
aCellLocationsArray->SetNumberOfTuples(1);
aCells->InitTraversal();
- vtkIdType npts;
+ vtkIdType npts = 0;
aCellLocationsArray->SetValue(0, aCells->GetTraversalLocation(npts));
aGrid->SetCells(aCellTypesArray, aCellLocationsArray, aCells);
#ifndef DIALOGBOX_NODES_H
#define DIALOGBOX_NODES_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qvariant.h>
#include <qdialog.h>
// class : SMESHGUI_NodesDlg
// purpose :
//=================================================================================
-class SMESHGUI_NodesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_NodesDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_Operation_H
#define SMESHGUI_Operation_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <LightApp_Operation.h>
#include <SALOMEDSClient.hxx>
Description : Base class for all SMESH operations
*/
-class SMESHGUI_Operation : public LightApp_Operation
+class SMESHGUI_EXPORT SMESHGUI_Operation : public LightApp_Operation
{
Q_OBJECT
#ifndef SMESHGUI_PatternUtils_HeaderFile
#define SMESHGUI_PatternUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(SMESH_Pattern)
namespace SMESH{
+SMESHGUI_EXPORT
SMESH::SMESH_Pattern_var GetPattern();
}
#ifndef WIDGET_PATTERN_H
#define WIDGET_PATTERN_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qframe.h>
#include <qvaluevector.h>
// class : SMESHGUI_PatternWidget
// purpose :
//=================================================================================
-class SMESHGUI_PatternWidget : public QFrame
+class SMESHGUI_EXPORT SMESHGUI_PatternWidget : public QFrame
{
Q_OBJECT
#ifndef SMESHGUI_PrecisionDlg_H
#define SMESHGUI_PrecisionDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
class QSpinBox;
Description : Dialog to specify precision of mesh quality controls
*/
-class SMESHGUI_PrecisionDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_PrecisionDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_PREFERENCES_COLORDLG_H
#define SMESHGUI_PREFERENCES_COLORDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
// SALOME Includes
//#include "SUIT_Config.h"
//#include "SUIT_Settings.h"
class QColor;
class SMESHGUI;
-class SMESHGUI_Preferences_ColorDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_Preferences_ColorDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_PREFERENCES_SCALARBARDLG_H
#define SMESHGUI_PREFERENCES_SCALARBARDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
class QButtonGroup;
class SMESH_Actor;
-class SMESHGUI_Preferences_ScalarBarDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_Preferences_ScalarBarDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_PREFERENCES_SELECTIONDLG_H
#define SMESHGUI_PREFERENCES_SELECTIONDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
// QT Includes
#include <qdialog.h>
class QColor;
class SMESHGUI;
-class SMESHGUI_LineEdit : public QLineEdit
+class SMESHGUI_EXPORT SMESHGUI_LineEdit : public QLineEdit
{
Q_OBJECT
void focusOutEvent(QFocusEvent* e);
};
-class SMESHGUI_DoubleValidator : public QDoubleValidator
+class SMESHGUI_EXPORT SMESHGUI_DoubleValidator : public QDoubleValidator
{
Q_OBJECT
void fixup(QString& text) const;
};
-class SMESHGUI_Preferences_SelectionDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_Preferences_SelectionDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_REMOVE_ELEMENTS_H
#define DIALOGBOX_REMOVE_ELEMENTS_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
// QT Includes
// class : SMESHGUI_RemoveElementsDlg
// purpose :
//=================================================================================
-class SMESHGUI_RemoveElementsDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_RemoveElementsDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_REMOVE_NODES_H
#define DIALOGBOX_REMOVE_NODES_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
// QT Includes
// class : SMESHGUI_RemoveNodesDlg
// purpose :
//=================================================================================
-class SMESHGUI_RemoveNodesDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_RemoveNodesDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_RENUMBERING_H
#define DIALOGBOX_RENUMBERING_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
//#include "SMESH_TypeFilter.hxx"
#include "SUIT_SelectionFilter.h"
// class : SMESHGUI_RenumberingDlg
// purpose : If the unit == 0 nodes will be renumbered, if the unit == 1 the elements will.
//=================================================================================
-class SMESHGUI_RenumberingDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_RenumberingDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_REVOLUTION_H
#define DIALOGBOX_REVOLUTION_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMESH_LogicalFilter.hxx"
// class : SMESHGUI_RevolutionDlg
// purpose :
//=================================================================================
-class SMESHGUI_RevolutionDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_RevolutionDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_ROTATION_H
#define DIALOGBOX_ROTATION_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMESH_LogicalFilter.hxx"
// class : SMESHGUI_RotationDlg
// purpose :
//=================================================================================
-class SMESHGUI_RotationDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_RotationDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_SELECTION_HeaderFile
#define SMESHGUI_SELECTION_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_Selection.h"
#include "SALOMEDSClient_definitions.hxx"
class LightApp_DataOwner;
class SMESH_Actor;
-class SMESHGUI_Selection : public LightApp_Selection
+class SMESHGUI_EXPORT SMESHGUI_Selection : public LightApp_Selection
{
public:
SMESHGUI_Selection();
#ifndef SMESHGUI_SelectionOp_H
#define SMESHGUI_SelectionOp_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <SMESHGUI_Operation.h>
#include <SMESHGUI_Dialog.h>
#include <SVTK_Selection.h>
Description : Base operation for all operations using object selection in viewer or objectbrowser
through common widgets created by LightApp_Dialog::createObject
*/
-class SMESHGUI_SelectionOp : public SMESHGUI_Operation
+class SMESHGUI_EXPORT SMESHGUI_SelectionOp : public SMESHGUI_Operation
{
Q_OBJECT
#ifndef DIALOGBOX_SEWING_H
#define DIALOGBOX_SEWING_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
// QT Includes
// class : SMESHGUI_SewingDlg
// purpose :
//=================================================================================
-class SMESHGUI_SewingDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_SewingDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_ShapeByMeshDlg_H
#define SMESHGUI_ShapeByMeshDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
// IDL Headers
* by selecting mesh elements
*/
-class SMESHGUI_ShapeByMeshDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_ShapeByMeshDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_SingleEditDlg_H
#define SMESHGUI_SingleEditDlg_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <qdialog.h>
#include <SALOMEconfig.h>
* Description : Base class for dialogs of diagonal inversion and
* union of two neighboring triangles
*/
-class SMESHGUI_SingleEditDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_SingleEditDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_SMOOTHING_H
#define DIALOGBOX_SMOOTHING_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMESH_LogicalFilter.hxx"
// class : SMESHGUI_SmoothingDlg
// purpose :
//=================================================================================
-class SMESHGUI_SmoothingDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_SmoothingDlg : public QDialog
{
Q_OBJECT
#ifndef SMESH_SPINBOX_H
#define SMESH_SPINBOX_H
+#include "SMESH_SMESHGUI.hxx"
+
#include <QtxDblSpinBox.h>
//=================================================================================
// class : SMESHGUI_SpinBox
// purpose : Derivated from QtxDblSpinBox class
//=================================================================================
-class SMESHGUI_SpinBox : public QtxDblSpinBox
+class SMESHGUI_EXPORT SMESHGUI_SpinBox : public QtxDblSpinBox
{
Q_OBJECT
#ifndef SMESHGUI_STANDARDMESHINFOSDLG_H
#define SMESHGUI_STANDARDMESHINFOSDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
//#include "SMESH_TypeFilter.hxx"
#include "SUIT_SelectionFilter.h"
class SMESHGUI;
-class SMESHGUI_StandardMeshInfosDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_StandardMeshInfosDlg : public QDialog
{
Q_OBJECT
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESHGUI_Swig.hxx"
#include "Utils_ORB_INIT.hxx"
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
+using namespace std;
+
static CORBA::ORB_var _orb;
static CORBA::Object_ptr StringToObject (const char* ior)
#ifndef _SMESHGUI_SWIG_HXX_
#define _SMESHGUI_SWIG_HXX_
+#include "SMESH_SMESHGUI.hxx"
+
// IDL Headers
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOMEDS)
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
-class SMESH_Swig
+class SMESHGUI_EXPORT SMESH_Swig
{
public:
SMESH_Swig();
#ifndef DIALOGBOX_SYMMETRY_H
#define DIALOGBOX_SYMMETRY_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMESH_LogicalFilter.hxx"
// class : SMESHGUI_SymmetryDlg
// purpose :
//=================================================================================
-class SMESHGUI_SymmetryDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_SymmetryDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_TRANSLATION_H
#define DIALOGBOX_TRANSLATION_H
+#include "SMESH_SMESHGUI.hxx"
+
#include "LightApp_SelectionMgr.h"
#include "SMESH_LogicalFilter.hxx"
// class : SMESHGUI_TranslationDlg
// purpose :
//=================================================================================
-class SMESHGUI_TranslationDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_TranslationDlg : public QDialog
{
Q_OBJECT
#ifndef DIALOGBOX_TRANSPARENCYDLG_H
#define DIALOGBOX_TRANSPARENCYDLG_H
+#include "SMESH_SMESHGUI.hxx"
+
// QT Includes
#include <qdialog.h>
// class : SMESHGUI_TransparencyDlg
// purpose :
//=================================================================================
-class SMESHGUI_TransparencyDlg : public QDialog
+class SMESHGUI_EXPORT SMESHGUI_TransparencyDlg : public QDialog
{
Q_OBJECT
#ifndef SMESHGUI_Utils_HeaderFile
#define SMESHGUI_Utils_HeaderFile
-#include <CORBA.h>
+#include "SMESH_SMESHGUI.hxx"
+
+#include <omniORB4/CORBA.h>
#include "SALOMEDSClient_definitions.hxx"
#include "SALOME_InteractiveObject.hxx"
namespace SMESH {
+SMESHGUI_EXPORT
SUIT_Desktop*
GetDesktop(const CAM_Module* theModule);
+SMESHGUI_EXPORT
LightApp_SelectionMgr*
GetSelectionMgr(const SalomeApp_Module* theModule);
+SMESHGUI_EXPORT
SalomeApp_Study*
GetAppStudy(const CAM_Module* theModule);
+SMESHGUI_EXPORT
SUIT_ResourceMgr*
GetResourceMgr( const SalomeApp_Module* );
+SMESHGUI_EXPORT
_PTR(Study)
GetCStudy(const SalomeApp_Study* theStudy);
+SMESHGUI_EXPORT
CORBA::Object_var DataOwnerToObject(const LightApp_DataOwnerPtr& theOwner);
template<class TInterface> typename TInterface::_var_type
}
+SMESHGUI_EXPORT
SUIT_Study* GetActiveStudy();
+SMESHGUI_EXPORT
SUIT_ViewWindow* GetActiveWindow();
+SMESHGUI_EXPORT
_PTR(Study) GetActiveStudyDocument();
+SMESHGUI_EXPORT
_PTR(SObject) FindSObject(CORBA::Object_ptr theObject);
+SMESHGUI_EXPORT
void SetName (_PTR(SObject) theSObject, const char* theName);
+
+SMESHGUI_EXPORT
void SetValue (_PTR(SObject) theSObject, const char* theValue);
+SMESHGUI_EXPORT
CORBA::Object_var SObjectToObject (_PTR(SObject) theSObject,
_PTR(Study) theStudy);
+SMESHGUI_EXPORT
CORBA::Object_var SObjectToObject(_PTR(SObject) theSObject);
template<class TInterface> typename TInterface::_var_type
return TInterface::_nil();
}
+SMESHGUI_EXPORT
CORBA::Object_var IObjectToObject(const Handle(SALOME_InteractiveObject)& theIO);
template<class TInterface> typename TInterface::_var_type
return TInterface::_nil();
}
+SMESHGUI_EXPORT
CORBA::Object_var IORToObject(const char* theIOR);
template<class TInterface> typename TInterface::_var_type
return TInterface::_nil();
}
+SMESHGUI_EXPORT
int GetNameOfSelectedIObjects (LightApp_SelectionMgr*, QString& theName);
+SMESHGUI_EXPORT
_PTR(SObject) GetMeshOrSubmesh (_PTR(SObject) theSObject);
+SMESHGUI_EXPORT
void ModifiedMesh (_PTR(SObject) theSObject, bool theIsRight);
// void UpdateObjBrowser (bool);
#ifndef SMESHGUI_VTKUtils_HeaderFile
#define SMESHGUI_VTKUtils_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
class QString;
class vtkRenderer;
class TColStd_IndexedMapOfInteger;
class LightApp_SelectionMgr;
class SMESHGUI;
-#include <CORBA.h>
+#include <omniORB4/CORBA.h>
#include "SALOMEconfig.h"
#include CORBA_CLIENT_HEADER(SALOMEDS)
//----------------------------------------------------------------------------
typedef pair<int,string> TKeyOfVisualObj;
+SMESHGUI_EXPORT
TVisualObjPtr GetVisualObj(int theStudyId,
const char* theEntry);
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
SVTK_ViewWindow* GetViewWindow(const SalomeApp_Module* theModule);
+SMESHGUI_EXPORT
SUIT_ViewWindow* GetActiveWindow();
+SMESHGUI_EXPORT
SVTK_ViewWindow* FindVtkViewWindow( SUIT_ViewManager*,
SUIT_ViewWindow* );
+SMESHGUI_EXPORT
SVTK_ViewWindow* GetVtkViewWindow( SUIT_ViewWindow* );
+SMESHGUI_EXPORT
SVTK_ViewWindow* GetCurrentVtkView();
+SMESHGUI_EXPORT
void RepaintViewWindow(SVTK_ViewWindow*);
+SMESHGUI_EXPORT
void RenderViewWindow(SVTK_ViewWindow*);
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
SMESH_Actor* FindActorByEntry (SUIT_ViewWindow*, const char* theEntry);
+SMESHGUI_EXPORT
SMESH_Actor* FindActorByEntry (const char* theEntry);
+SMESHGUI_EXPORT
SMESH_Actor* FindActorByObject (CORBA::Object_ptr theObject);
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
SMESH_Actor* CreateActor (_PTR(Study), const char*, int = false);
+SMESHGUI_EXPORT
void DisplayActor (SUIT_ViewWindow*, SMESH_Actor* theActor);
+SMESHGUI_EXPORT
void RemoveActor (SUIT_ViewWindow*, SMESH_Actor* theActor);
//----------------------------------------------------------------------------
enum EDisplaing {eDisplayAll, eDisplay, eDisplayOnly, eErase, eEraseAll};
+SMESHGUI_EXPORT
void UpdateView (SUIT_ViewWindow*,
EDisplaing theAction,
const char* theEntry = "");
+SMESHGUI_EXPORT
void UpdateView (EDisplaing theAction,
const char* theEntry = "");
+SMESHGUI_EXPORT
void UpdateView();
+SMESHGUI_EXPORT
void Update(const Handle(SALOME_InteractiveObject)& theIO,
bool theDisplay);
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
void FitAll();
+SMESHGUI_EXPORT
void RepaintCurrentView();
+SMESHGUI_EXPORT
vtkRenderer* GetCurrentRenderer();
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
void SetPointRepresentation(bool theIsVisible);
+SMESHGUI_EXPORT
void SetPickable(SMESH_Actor* theActor = NULL);
+SMESHGUI_EXPORT
void UpdateSelectionProp( SMESHGUI* );
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
SVTK_Selector*
GetSelector(SUIT_ViewWindow* = GetActiveWindow());
+SMESHGUI_EXPORT
void SetFilter (const Handle(VTKViewer_Filter)& theFilter,
SVTK_Selector* theSelector = GetSelector());
+SMESHGUI_EXPORT
Handle(VTKViewer_Filter)
GetFilter (int theId, SVTK_Selector* theSelector = GetSelector());
+SMESHGUI_EXPORT
bool IsFilterPresent (int theId,
SVTK_Selector* theSelector = GetSelector());
+SMESHGUI_EXPORT
void RemoveFilter (int theId,
SVTK_Selector* theSelector = GetSelector());
+SMESHGUI_EXPORT
void RemoveFilters (SVTK_Selector* theSelector = GetSelector());
+SMESHGUI_EXPORT
bool IsValid (SALOME_Actor* theActor, int theCellId,
SVTK_Selector* theSelector = GetSelector());
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName);
+SMESHGUI_EXPORT
int GetNameOfSelectedElements(SVTK_Selector* theSelector,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName);
+SMESHGUI_EXPORT
int GetEdgeNodes(SVTK_Selector* theSelector,
const TVisualObjPtr& theVisualObj,
int& theId1,
int& theId2);
//----------------------------------------------------------------------------
+SMESHGUI_EXPORT
int GetNameOfSelectedNodes (LightApp_SelectionMgr*,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName);
+SMESHGUI_EXPORT
int GetNameOfSelectedNodes (LightApp_SelectionMgr*,
QString& aName);
+SMESHGUI_EXPORT
int GetNameOfSelectedElements (LightApp_SelectionMgr*,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName);
+SMESHGUI_EXPORT
int GetNameOfSelectedElements (LightApp_SelectionMgr*,
QString& aName);
+SMESHGUI_EXPORT
int GetSelected (LightApp_SelectionMgr*,
TColStd_IndexedMapOfInteger& theMap,
const bool theIsElement = true );
+SMESHGUI_EXPORT
int GetEdgeNodes (LightApp_SelectionMgr*, int& theId1, int& theId2);
+SMESHGUI_EXPORT
void SetControlsPrecision (const long theVal);
};
myServerLib = atts.value("server-lib");
myClientLib = atts.value("gui-lib");
+#ifdef WNT
+ myServerLib += ".dll";
+ myClientLib += ".dll";
+#else
+ myServerLib = "lib" + myServerLib + ".so";
+ myClientLib = "lib" + myClientLib + ".so";
+#endif
+
+
QString aResName = atts.value("resources");
if (aResName != "")
{
#ifndef SMESHGUI_XmlHandler_HeaderFile
#define SMESHGUI_XmlHandler_HeaderFile
+#include "SMESH_SMESHGUI.hxx"
+
#include "SMESHGUI_Hypotheses.h"
#include <qxml.h>
#include <map>
-class SMESHGUI_XmlHandler : public QXmlDefaultHandler
+class SMESHGUI_EXPORT SMESHGUI_XmlHandler : public QXmlDefaultHandler
{
public:
SMESHGUI_XmlHandler();
--- /dev/null
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+//
+//
+//
+// File : SMESH_SMESHGUI.hxx
+// Author : Alexander A. BORODIN
+// Module : SMESH
+
+#ifndef _SMESH_SMESHGUI_HXX_
+#define _SMESH_SMESHGUI_HXX_
+
+#ifdef WNT
+ #if defined SMESHGUI_EXPORTS
+ #define SMESHGUI_EXPORT __declspec( dllexport )
+ #else
+ #define SMESHGUI_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESHGUI_EXPORT
+#endif
+
+#endif
#, fuzzy
msgid ""
msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"PO-Revision-Date: 2006-01-13 13:50+0300\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=CHARSET\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-# This is a Qt message file in .po format. Each msgid starts with
-# a scope. This scope should *NOT* be translated - eg. "Foo::Bar"
-# would be translated to "Pub", not "Foo::Pub".
-msgid ""
-msgstr ""
"Project-Id-Version: PROJECT VERSION\n"
-"POT-Creation-Date: 2002-05-28 10:46:48 AM CEST\n"
-"PO-Revision-Date: 2004-10-20 17:25+0400\n"
+"POT-Creation-Date: 2002-05-28 10:57:43 AM CEST\n"
+"PO-Revision-Date: 2005-06-07 10:51+0400\n"
"Last-Translator: FULLNAME <EMAIL@ADDRESS>\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
// Module : SMESH
// $Header:
-#ifndef _SMESH_SMESH_HXX_
-#define _SMESH_SMESH_HXX_
+#ifndef _SMESH_I_SMESH_HXX_
+#define _SMESH_I_SMESH_HXX_
+
+#ifdef WNT
+ #if defined SMESH_I_EXPORTS
+ #define SMESH_I_EXPORT __declspec( dllexport )
+ #else
+ #define SMESH_I_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define SMESH_I_EXPORT
+#endif
// Tags definition
enum {
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_1D_Algo_i.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
* SMESH_1D_Algo_i::SMESH_1D_Algo_i
#ifndef _SMESH_1D_ALGO_I_HXX_
#define _SMESH_1D_ALGO_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
// ======================================================
// Generic 1D algorithm
// ======================================================
-class SMESH_1D_Algo_i:
+class SMESH_I_EXPORT SMESH_1D_Algo_i:
public virtual POA_SMESH::SMESH_1D_Algo,
public virtual SMESH_Algo_i
{
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_2D_Algo_i.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
* SMESH_2D_Algo_i::SMESH_2D_Algo_i
#ifndef _SMESH_2D_ALGO_I_HXX_
#define _SMESH_2D_ALGO_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
// ======================================================
// Generic 2D algorithm
// ======================================================
-class SMESH_2D_Algo_i:
+class SMESH_I_EXPORT SMESH_2D_Algo_i:
public virtual POA_SMESH::SMESH_2D_Algo,
public virtual SMESH_Algo_i
{
#include "SMESH_2smeshpy.hxx"
-#include "SMESH_Gen_i.hxx"
#include "utilities.h"
#include "SMESH_PythonDump.hxx"
#include "Resource_DataMapOfAsciiStringAsciiString.hxx"
+#include "SMESH_Gen_i.hxx"
+/* SALOME headers that include CORBA headers that include windows.h
+ * that defines GetObject symbol as GetObjectA should stand before SALOME headers
+ * that declare methods named GetObject - to apply the same rules of GetObject renaming
+ * and thus to avoid mess with GetObject symbol on Windows */
+
IMPLEMENT_STANDARD_HANDLE (_pyObject ,Standard_Transient);
IMPLEMENT_STANDARD_HANDLE (_pyCommand ,Standard_Transient);
IMPLEMENT_STANDARD_HANDLE (_pyGen ,_pyObject);
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_3D_Algo_i.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
* SMESH_3D_Algo_i::SMESH_3D_Algo_i
// ======================================================
// Generic 3D algorithm
// ======================================================
-class SMESH_3D_Algo_i:
+class SMESH_I_EXPORT SMESH_3D_Algo_i:
public virtual POA_SMESH::SMESH_3D_Algo,
public virtual SMESH_Algo_i
{
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_Algo_i.hxx"
#include "SMESH_Algo.hxx"
#include <string>
#include <vector>
+using namespace std;
+
//=============================================================================
/*!
* SMESH_Algo_i::SMESH_Algo_i
#ifndef _SMESH_ALGO_I_HXX_
#define _SMESH_ALGO_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
// ======================================================
// Generic algorithm
// ======================================================
-class SMESH_Algo_i:
+class SMESH_I_EXPORT SMESH_Algo_i:
public virtual POA_SMESH::SMESH_Algo,
public virtual SMESH_Hypothesis_i
{
#ifndef _SMESH_FILTER_I_HXX_
#define _SMESH_FILTER_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Filter)
Description : Predicate for verifying whether entiy belong to
specified geometrical support
*/
- class BelongToGeom: public virtual Predicate
+ class SMESH_I_EXPORT BelongToGeom: public virtual Predicate
{
public:
BelongToGeom();
Description : Predicate for verifying whether entiy lying or partially lying on
specified geometrical support
*/
- class LyingOnGeom: public virtual Predicate
+ class SMESH_I_EXPORT LyingOnGeom: public virtual Predicate
{
public:
LyingOnGeom();
Class : Functor_i
Description : An abstact class for all functors
*/
- class Functor_i: public virtual POA_SMESH::Functor,
+ class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
public virtual SALOME::GenericObj_i
{
public:
Class : NumericalFunctor_i
Description : Base class for numerical functors
*/
- class NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
+ class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
public virtual Functor_i
{
public:
Class : SMESH_MinimumAngleFunct
Description : Functor for calculation of minimum angle
*/
- class MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
+ class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
public virtual NumericalFunctor_i
{
public:
Class : AspectRatio_i
Description : Functor for calculating aspect ratio
*/
- class AspectRatio_i: public virtual POA_SMESH::AspectRatio,
+ class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio,
public virtual NumericalFunctor_i
{
public:
Class : AspectRatio3D_i
Description : Functor for calculating aspect ratio for 3D
*/
- class AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
+ class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
public virtual NumericalFunctor_i
{
public:
Class : Warping_i
Description : Functor for calculating warping
*/
- class Warping_i: public virtual POA_SMESH::Warping,
+ class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping,
public virtual NumericalFunctor_i
{
public:
Class : Taper_i
Description : Functor for calculating taper
*/
- class Taper_i: public virtual POA_SMESH::Taper,
+ class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper,
public virtual NumericalFunctor_i
{
public:
Class : Skew_i
Description : Functor for calculating skew in degrees
*/
- class Skew_i: public virtual POA_SMESH::Skew,
+ class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew,
public virtual NumericalFunctor_i
{
public:
Class : Area_i
Description : Functor for calculating area
*/
- class Area_i: public virtual POA_SMESH::Area,
+ class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area,
public virtual NumericalFunctor_i
{
public:
Class : Volume3D_i
Description : Functor for calculating volume of 3D element
*/
- class Volume3D_i: public virtual POA_SMESH::Volume3D,
+ class SMESH_I_EXPORT Volume3D_i: public virtual POA_SMESH::Volume3D,
public virtual NumericalFunctor_i
{
public:
Class : Length_i
Description : Functor for calculating length of edge
*/
- class Length_i: public virtual POA_SMESH::Length,
+ class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length,
public virtual NumericalFunctor_i
{
public:
Class : Length2D_i
Description : Functor for calculating length of edge
*/
- class Length2D_i: public virtual POA_SMESH::Length2D,
+ class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D,
public virtual NumericalFunctor_i
{
public:
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection_i: public virtual POA_SMESH::MultiConnection,
+ class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection,
public virtual NumericalFunctor_i
{
public:
Class : MultiConnection2D_i
Description : Functor for calculating number of faces conneted to the edge
*/
- class MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
+ class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
public virtual NumericalFunctor_i
{
public:
Class : Predicate_i
Description : Base class for all predicates
*/
- class Predicate_i: public virtual POA_SMESH::Predicate,
+ class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate,
public virtual Functor_i
{
public:
Description : Verify whether a mesh volume is incorrectly oriented from
the point of view of MED convention
*/
- class BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
+ class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
public virtual Predicate_i
{
public:
Class : BelongToGeom_i
Description : Predicate for selection on geometrical support
*/
- class BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
+ class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
public virtual Predicate_i
{
public:
Class : BelongToSurface_i
Description : Verify whether mesh element lie in pointed Geom planar object
*/
- class BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
+ class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
public virtual Predicate_i
{
public:
Class : BelongToPlane_i
Description : Verify whether mesh element lie in pointed Geom planar object
*/
- class BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
+ class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
public virtual BelongToSurface_i
{
public:
Class : BelongToCylinder_i
Description : Verify whether mesh element lie in pointed Geom cylindrical object
*/
- class BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
+ class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
public virtual BelongToSurface_i
{
public:
Class : LyingOnGeom_i
Description : Predicate for selection on geometrical support(lying or partially lying)
*/
- class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
+ class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
public virtual Predicate_i
{
public:
Class : FreeBorders_i
Description : Predicate for free borders
*/
- class FreeBorders_i: public virtual POA_SMESH::FreeBorders,
+ class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
public virtual Predicate_i
{
public:
Class : FreeEdges_i
Description : Predicate for free edges
*/
- class FreeEdges_i: public virtual POA_SMESH::FreeEdges,
+ class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
public virtual Predicate_i
{
public:
Class : RangeOfIds_i
Description : Predicate for Range of Ids
*/
- class RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
+ class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
public virtual Predicate_i
{
public:
Class : Comparator_i
Description : Base class for comparators
*/
- class Comparator_i: public virtual POA_SMESH::Comparator,
+ class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
public virtual Predicate_i
{
public:
Class : LessThan_i
Description : Comparator "<"
*/
- class LessThan_i: public virtual POA_SMESH::LessThan,
+ class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
public virtual Comparator_i
{
public:
Class : MoreThan_i
Description : Comparator ">"
*/
- class MoreThan_i: public virtual POA_SMESH::MoreThan,
+ class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
public virtual Comparator_i
{
public:
Class : EqualTo_i
Description : Comparator "="
*/
- class EqualTo_i: public virtual POA_SMESH::EqualTo,
+ class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
public virtual Comparator_i
{
public:
Class : LogicalNOT_i
Description : Logical NOT predicate
*/
- class LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
+ class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
public virtual Predicate_i
{
public:
Class : LogicalBinary_i
Description : Base class for binary logical predicate
*/
- class LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
+ class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
public virtual Predicate_i
{
public:
Class : LogicalAND_i
Description : Logical AND
*/
- class LogicalAND_i: public virtual POA_SMESH::LogicalAND,
+ class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
public virtual LogicalBinary_i
{
public:
Class : LogicalOR_i
Description : Logical OR
*/
- class LogicalOR_i: public virtual POA_SMESH::LogicalOR,
+ class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
public virtual LogicalBinary_i
{
public:
/*
FILTER
*/
- class Filter_i: public virtual POA_SMESH::Filter,
+ class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
public virtual SALOME::GenericObj_i
{
public:
/*
FILTER LIBRARY
*/
- class FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
+ class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
public virtual SALOME::GenericObj_i
{
public:
FILTER MANAGER
*/
- class FilterManager_i: public virtual POA_SMESH::FilterManager,
+ class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
public virtual SALOME::GenericObj_i
{
public:
#include "utilities.h"
#include <fstream>
#include <stdio.h>
-#include <dlfcn.h>
+
+#ifdef WNT
+ #include <windows.h>
+#else
+ #include <dlfcn.h>
+#endif
+
+#ifdef WNT
+ #define LibHandle HMODULE
+ #define LoadLib( name ) LoadLibrary( name )
+ #define GetProc GetProcAddress
+ #define UnLoadLib( handle ) FreeLibrary( handle );
+#else
+ #define LibHandle void*
+ #define LoadLib( name ) dlopen( name, RTLD_LAZY )
+ #define GetProc dlsym
+ #define UnLoadLib( handle ) dlclose( handle );
+#endif
#include <HDFOI.hxx>
{
// load plugin library
if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
- void* libHandle = dlopen (theLibName, RTLD_LAZY);
+ LibHandle libHandle = LoadLib( theLibName );
if (!libHandle)
{
// report any error, if occured
+#ifndef WNT
const char* anError = dlerror();
throw(SALOME_Exception(anError));
+#else
+ throw(SALOME_Exception(LOCALIZED( "Can't load server meshers plugin library" )));
+#endif
}
// get method, returning hypothesis creator
if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* theHypName);
GetHypothesisCreator procHandle =
- (GetHypothesisCreator)dlsym( libHandle, "GetHypothesisCreator" );
+ (GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
if (!procHandle)
{
throw(SALOME_Exception(LOCALIZED("bad hypothesis plugin library")));
- dlclose(libHandle);
+ UnLoadLib(libHandle);
}
// get hypothesis creator
//=============================================================================
extern "C"
-{
+{ SMESH_I_EXPORT
PortableServer::ObjectId* SMESHEngine_factory( CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
PortableServer::ObjectId* contId,
#ifndef _SMESH_GEN_I_HXX_
#define _SMESH_GEN_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Gen)
#include CORBA_SERVER_HEADER(SMESH_Mesh)
// ===========================================================
// Study context - stores study-connected objects references
// ==========================================================
-class StudyContext
+class SMESH_I_EXPORT StudyContext
{
public:
// constructor
// ===========================================================
// SMESH module's engine
// ==========================================================
-class SMESH_Gen_i:
+class SMESH_I_EXPORT SMESH_Gen_i:
public virtual POA_SMESH::SMESH_Gen,
public virtual Engines_Component_i
{
#ifndef SMESH_Group_i_HeaderFile
#define SMESH_Group_i_HeaderFile
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Group)
#include CORBA_SERVER_HEADER(SMESH_Mesh)
// ===========
// Group Base
// ===========
-class SMESH_GroupBase_i:
+class SMESH_I_EXPORT SMESH_GroupBase_i:
public virtual POA_SMESH::SMESH_GroupBase,
public virtual SALOME::GenericObj_i
{
// Group
// ======
-class SMESH_Group_i:
+class SMESH_I_EXPORT SMESH_Group_i:
public virtual POA_SMESH::SMESH_Group,
public SMESH_GroupBase_i
{
// Group linked to geometry
// =========================
-class SMESH_GroupOnGeom_i:
+class SMESH_I_EXPORT SMESH_GroupOnGeom_i:
public virtual POA_SMESH::SMESH_GroupOnGeom,
public SMESH_GroupBase_i
{
// Module : SMESH
// $Header$
-using namespace std;
#include <iostream>
#include <sstream>
#include "SMESH_Hypothesis_i.hxx"
#include "utilities.h"
+using namespace std;
+
//=============================================================================
/*!
* SMESH_Hypothesis_i::SMESH_Hypothesis_i
#ifndef _SMESH_HYPOTHESIS_I_HXX_
#define _SMESH_HYPOTHESIS_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
// ======================================================
// Generic hypothesis
// ======================================================
-class SMESH_Hypothesis_i:
+class SMESH_I_EXPORT SMESH_Hypothesis_i:
public virtual POA_SMESH::SMESH_Hypothesis,
public virtual SALOME::GenericObj_i
{
// ======================================================
// Generic hypothesis creator
// ======================================================
-class GenericHypothesisCreator_i
+class SMESH_I_EXPORT GenericHypothesisCreator_i
{
public:
// Create a hypothesis
// File : SMESH_MEDFamily_i.cxx
// Module : SMESH
-using namespace std;
#include "SMESH_MEDFamily_i.hxx"
#include "utilities.h"
#include "Utils_CorbaException.hxx"
+using namespace std;
+
//=============================================================================
/*!
* Default constructor
#ifndef SMESH_MED_FAMILY_I_HXX_
#define SMESH_MED_FAMILY_I_HXX_
+#include "SMESH.hxx"
+
#include "SMESH_MEDSupport_i.hxx"
#include<string>
-class SMESH_MEDFamily_i:
+class SMESH_I_EXPORT SMESH_MEDFamily_i:
public virtual POA_SALOME_MED::FAMILY,
public virtual SMESH_MEDSupport_i
{
SMESH_MEDFamily_i *famservant =
new SMESH_MEDFamily_i(famIdent, submesh_i,
famName, famDes, SALOME_MED::MED_NODE);
- SALOME_MED::FAMILY_ptr famille =
- SALOME_MED::FAMILY::_narrow(famservant->
- POA_SALOME_MED::FAMILY::_this());
+#ifdef WNT
+ SALOME_MED::FAMILY_ptr famille = SALOME_MED::FAMILY::_nil();
+ POA_SALOME_MED::FAMILY* servantbase = dynamic_cast<POA_SALOME_MED::FAMILY*>(famservant);
+ if ( servantbase )
+ famille = SALOME_MED::FAMILY::_narrow( servantbase->_this() );
+#else
+ SALOME_MED::FAMILY_ptr famille =
+ SALOME_MED::FAMILY::_narrow( famservant->POA_SALOME_MED::FAMILY::_this() );
+#endif
_families.push_back(famille);
}
}
#ifndef _MED_SMESH_MESH_I_HXX_
#define _MED_SMESH_MESH_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(MED)
#include <string>
class SMESH_Mesh_i;
-class SMESH_MEDMesh_i:
+class SMESH_I_EXPORT SMESH_MEDMesh_i:
public virtual POA_SALOME_MED::MESH, public virtual SALOME::GenericObj_i
{
public: private: protected:
// File : SMESH_MEDSupport_i.cxx
// Module : SMESH
-using namespace std;
#include "SMESH_MEDSupport_i.hxx"
#include "utilities.h"
#include "Utils_CorbaException.hxx"
#include "SMESH_Mesh_i.hxx"
#include "SMESH_subMesh_i.hxx"
+using namespace std;
+
//=============================================================================
/*!
#ifndef _MED_SMESH_MEDSUPPORT_I_HXX_
#define _MED_SMESH_MEDSUPPORT_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(MED)
#include <string>
#include "SALOME_GenericObj_i.hh"
class SMESH_subMesh_i;
-class SMESH_MEDSupport_i:
+class SMESH_I_EXPORT SMESH_MEDSupport_i:
public virtual POA_SALOME_MED::SUPPORT, public virtual SALOME::GenericObj_i
{
public:
{
list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
- SMESH::long_array& aGroup = GroupsOfNodes[ i ];
+ SMESH::long_array& aGroup = (*GroupsOfNodes)[i];
aGroup.length( aListOfNodes.size() );
for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
aGroup[ j ] = (*lIt)->GetID();
#ifndef _SMESH_MESHEDITOR_I_HXX_
#define _SMESH_MESHEDIOTR_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include "SMESH_Mesh.hxx"
-class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
+class SMESH_I_EXPORT SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
{
public:
SMESH_MeshEditor_i(SMESH_Mesh * theMesh);
#ifndef _SMESH_MESH_I_HXX_
#define _SMESH_MESH_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Group)
#include <map>
-class SMESH_Mesh_i:
+class SMESH_I_EXPORT SMESH_Mesh_i:
public virtual POA_SMESH::SMESH_Mesh,
public virtual SALOME::GenericObj_i
{
throw (SALOME::SALOME_Exception);
void ExportUNV( const char* file )
throw (SALOME::SALOME_Exception);
- void ExportSTL( const char* file, const bool isascii )
+ void ExportSTL( const char* file, bool isascii )
throw (SALOME::SALOME_Exception);
SALOME_MED::MESH_ptr GetMEDMesh()
SMESH::long_array* GetNodesId()
throw (SALOME::SALOME_Exception);
- SMESH::ElementType GetElementType( const CORBA::Long id, const bool iselem )
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
throw (SALOME::SALOME_Exception);
char* Dump();
#ifndef SMESH_Pattern_I_HeaderFile
#define SMESH_Pattern_I_HeaderFile
+#include "SMESH.hxx"
+
#include "SALOMEconfig.h"
#include CORBA_SERVER_HEADER(SMESH_Pattern)
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class SMESH_Gen_i;
class SMESH_Mesh;
-class SMESH_Pattern_i:
+class SMESH_I_EXPORT SMESH_Pattern_i:
public virtual POA_SMESH::SMESH_Pattern
{
public:
CORBA::Long theNode000Index,
CORBA::Long theNode001Index);
- CORBA::Boolean MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
+ //for omniORB conflict compilation
+ /*CORBA::Boolean MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
const CORBA::Boolean CreatePolygons,
- const CORBA::Boolean CreatePolyedrs);
+ const CORBA::Boolean CreatePolyedrs);*/
+
+ CORBA::Boolean MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs);
SMESH::SMESH_Pattern::ErrorCode GetErrorCode();
#ifndef _SMESH_PYTHONDUMP_HXX_
#define _SMESH_PYTHONDUMP_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SALOMEDS)
class Filter_i;
class Functor_i;
- class TPythonDump
+ class SMESH_I_EXPORT TPythonDump
{
std::ostringstream myStream;
static size_t myCounter;
// Module : SMESH
// $Header$
-using namespace std;
#include "SMESH_subMesh_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Mesh_i.hxx"
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
+using namespace std;
+
//=============================================================================
/*!
*
#ifndef _SMESH_SUBMESH_I_HXX_
#define _SMESH_SUBMESH_I_HXX_
+#include "SMESH.hxx"
+
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)
class SMESH_Gen_i;
class SMESH_Mesh_i;
-class SMESH_subMesh_i:
+class SMESH_I_EXPORT SMESH_subMesh_i:
public virtual POA_SMESH::SMESH_subMesh,
public virtual SALOME::GenericObj_i
{
SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType )
throw (SALOME::SALOME_Exception);
- SMESH::ElementType GetElementType( const CORBA::Long id, const bool iselem )
+ //for omniORB conflict compilation
+ /*SMESH::ElementType GetElementType( const CORBA::Long id, const bool iselem )
+ throw (SALOME::SALOME_Exception);*/
+ SMESH::ElementType GetElementType( CORBA::Long id, bool iselem )
throw (SALOME::SALOME_Exception);
SMESH::long_array* GetNodesId()
