# Project name, upper case
STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
-SET(${PROJECT_NAME_UC}_MAJOR_VERSION 7)
-SET(${PROJECT_NAME_UC}_MINOR_VERSION 8)
+SET(${PROJECT_NAME_UC}_MAJOR_VERSION 8)
+SET(${PROJECT_NAME_UC}_MINOR_VERSION 0)
SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
# Find KERNEL
# ===========
##
## Prerequisites From GUI:
##
- # Qt4
- FIND_PACKAGE(SalomeQt4 REQUIRED COMPONENTS QtCore QtGui QtXml)
+ # Qt
+ IF(NOT SALOME_GUI_BUILD_WITH_QT5)
+ FIND_PACKAGE(SalomeQt4 REQUIRED COMPONENTS QtCore QtGui QtXml)
+ ELSE()
+ FIND_PACKAGE(SalomeQt5 REQUIRED)
+ ENDIF()
# SIP
- FIND_PACKAGE(SalomeSIP REQUIRED) # should come after Python and before PyQt4
- # PyQt4
- FIND_PACKAGE(SalomePyQt4 REQUIRED)
+ FIND_PACKAGE(SalomeSIP REQUIRED) # should come after Python and before PyQt5
+ # PyQt
+ IF (NOT SALOME_GUI_BUILD_WITH_QT5)
+ FIND_PACKAGE(SalomePyQt4 REQUIRED)
+ ELSE()
+ FIND_PACKAGE(SalomePyQt5 REQUIRED)
+ ENDIF()
# Qwt
FIND_PACKAGE(SalomeQwt REQUIRED)
ELSE(EXISTS ${GUI_ROOT_DIR})
#include <TopoDS_Shape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <map>
#include <list>
class SMESH_Gen;
class SMESHDS_Document;
class SMESH_Group;
-class TopTools_ListOfShape;
class SMESH_subMesh;
class SMESH_HypoFilter;
class TopoDS_Solid;
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UseQt4Ext)
+INCLUDE(UseQtExt)
# --- options ---
# additional include directories
# --- sources ---
# sources / moc wrappings
-QT4_WRAP_CPP(_moc_SOURCES ${_moc_HEADERS})
+QT_WRAP_MOC(_moc_SOURCES ${_moc_HEADERS})
# sources / static
SET(_other_SOURCES
INSTALL(FILES ${SMESH_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
-QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_SMESH_INSTALL_RES_DATA}")
+QT_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_SMESH_INSTALL_RES_DATA}")
myTable->hideColumn( COL_PUBLISHED );
myTable->hideColumn( COL_SHAPEID );
myTable->hideColumn( COL_BAD_MESH );
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
myTable->horizontalHeader()->setResizeMode( COL_ERROR, QHeaderView::Interactive );
+#else
+ myTable->horizontalHeader()->setSectionResizeMode( COL_ERROR, QHeaderView::Interactive );
+#endif
myTable->setWordWrap( true );
myTable->horizontalHeader()->setStretchLastSection( true );
myTable->setMinimumWidth( 500 );
#include <SMDS_Mesh.hxx>
#include <SMDSAbs_ElementType.hxx>
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_Filter, VTKViewer_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_Filter, VTKViewer_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_PredicateFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_PredicateFilter, SMESHGUI_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_TriangleFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_TriangleFilter, SMESHGUI_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_FacesFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_FacesFilter, SMESHGUI_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_VolumesFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_VolumesFilter, SMESHGUI_Filter)
-
-IMPLEMENT_STANDARD_HANDLE(SMESHGUI_VolumeShapeFilter, SMESHGUI_Filter)
-IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_VolumeShapeFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_Filter, VTKViewer_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_PredicateFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_TriangleFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_FacesFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_VolumesFilter, SMESHGUI_Filter)
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_VolumeShapeFilter, SMESHGUI_Filter)
/*
Class : SMESHGUI_PredicateFilter
Standard_EXPORT virtual bool IsObjValid( const int ) const = 0;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_Filter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_Filter,VTKViewer_Filter)
};
/*
SMESH::Predicate_var myPred;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_PredicateFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_PredicateFilter,SMESHGUI_Filter)
};
/*
Standard_EXPORT virtual bool IsNodeFilter() const;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_QuadrangleFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_QuadrangleFilter,SMESHGUI_Filter)
};
/*
Standard_EXPORT virtual bool IsNodeFilter() const;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_TriangleFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_TriangleFilter,SMESHGUI_Filter)
};
/*
Standard_EXPORT virtual bool IsNodeFilter() const;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_FacesFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_FacesFilter,SMESHGUI_Filter)
};
/*
Standard_EXPORT virtual bool IsNodeFilter() const;
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_VolumesFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_VolumesFilter,SMESHGUI_Filter)
};
/*
Standard_EXPORT static int GetId( SMDSAbs_GeometryType geom );
public:
- DEFINE_STANDARD_RTTI(SMESHGUI_VolumeShapeFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(SMESHGUI_VolumeShapeFilter,SMESHGUI_Filter)
};
#endif // SMESHGUI_FILTER_H
// SALOME KERNEL includes
#include <SALOMEDSClient_definitions.hxx>
+// GUI includes
+#include <SALOME_InteractiveObject.hxx>
+
// IDL includes
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(GEOM_Gen)
class SALOMEDSClient_SObject;
-class Handle_SALOME_InteractiveObject;
class QString;
namespace SMESH
SMESHGUI_EXPORT GEOM::GEOM_Object_ptr GetSubShape( GEOM::GEOM_Object_ptr, long );
- SMESHGUI_EXPORT bool GetGeomEntries( Handle_SALOME_InteractiveObject& hypIO,
+ SMESHGUI_EXPORT bool GetGeomEntries( Handle(SALOME_InteractiveObject)& hypIO,
QString& subGeom, QString& meshGeom);
}
#include <SMDS_Mesh.hxx>
#include <SVTK_ViewWindow.h>
-#include <TColStd_MapOfInteger.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include <vtkActor2D.h>
#include <list>
#include <vector>
+#include <TColStd_MapOfInteger.hxx>
+
#include <gp_XYZ.hxx>
class SALOME_Actor;
class SMDS_Mesh;
class SVTK_ViewWindow;
-class TColStd_MapOfInteger;
class vtkActor2D;
class vtkLabeledDataMapper;
class vtkMaskPoints;
#include <SALOME_ListIO.hxx>
// OCCT includes
-#include <TColStd_MapOfInteger.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
// IDL includes
// OCCT includes
#include <gp_XYZ.hxx>
+#include <TColStd_MapOfInteger.hxx>
// STL includes
#include <list>
class SMESH_Actor;
class SUIT_SelectionFilter;
class SVTK_Selector;
-class TColStd_MapOfInteger;
namespace SMESH
{
myInfo->setColumnCount( 2 );
myInfo->setHeaderLabels( QStringList() << tr( "PROPERTY" ) << tr( "VALUE" ) );
myInfo->header()->setStretchLastSection( true );
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
myInfo->header()->setResizeMode( 0, QHeaderView::ResizeToContents );
+#else
+ myInfo->header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
+#endif
myInfo->setItemDelegate( new ItemDelegate( myInfo ) );
QVBoxLayout* l = new QVBoxLayout( frame() );
l->setMargin( 0 );
{
setColumnCount( 2 );
header()->setStretchLastSection( true );
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
header()->setResizeMode( 0, QHeaderView::ResizeToContents );
+#else
+ header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
+#endif
header()->hide();
}
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
+// OCCT includes
+#include <TColStd_MapOfInteger.hxx>
+
class SUIT_SelectionFilter;
-class TColStd_MapOfInteger;
class SVTK_ViewWindow;
class SVTK_Selector;
class SMESH_Actor;
#include <vtkUnstructuredGrid.h>
// OCCT includes
-#include <TColStd_IndexedMapOfInteger.hxx>
#include <Standard_ErrorHandler.hxx>
namespace SMESH
#include <SALOME_InteractiveObject.hxx>
#include <VTKViewer_Filter.h>
-class TColStd_IndexedMapOfInteger;
+// OCCT includes
+#include <TColStd_IndexedMapOfInteger.hxx>
class SALOMEDSClient_Study;
{
GC_MakeSegment edge( SMESH_TNodeXYZ( face->GetNode( i )),
SMESH_TNodeXYZ( face->GetNode( (i+1)%nbNodes) ));
- anExtCC.Init( lineCurve, edge);
+ anExtCC.Init( lineCurve, edge.Value() );
if ( anExtCC.NbExtrema() > 0 && anExtCC.LowerDistance() <= tol)
{
Quantity_Parameter pl, pe;
#include <unistd.h>
#endif
-
-IMPLEMENT_STANDARD_HANDLE (_pyObject ,Standard_Transient);
-IMPLEMENT_STANDARD_HANDLE (_pyCommand ,Standard_Transient);
-IMPLEMENT_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient);
-IMPLEMENT_STANDARD_HANDLE (_pyGen ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyMesh ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pySubMesh ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyMeshEditor ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyHypothesis ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pySelfEraser ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyGroup ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyFilter ,_pyObject);
-IMPLEMENT_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis);
-IMPLEMENT_STANDARD_HANDLE (_pyComplexParamHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_HANDLE (_pyNumberOfSegmentsHyp,_pyHypothesis);
-
-IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject);
-IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
-IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
+OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
using namespace std;
using SMESH::TPythonDump;
}
while ( myObjectNames.IsBound( aNewID ) );
- myObjectNames.Bind( aNewID, myObjectNames.IsBound( theID )
- ? (myObjectNames.Find( theID ) + _pyID( "_" ) + _pyID( index-1 ))
- : _pyID( "A" ) + aNewID );
+ if ( myObjectNames.IsBound( theID ) )
+ myObjectNames.Bind( aNewID, ( myObjectNames.Find( theID ) + _pyID( "_" ) + _pyID( index-1 ) ) );
+ else
+ myObjectNames.Bind( aNewID, ( _pyID( "A" ) + aNewID ) );
return aNewID;
}
return;
const bool isHyp = theObj->IsKind( STANDARD_TYPE( _pyHypothesis ));
- Handle(_pyObject) existing =
- isHyp ? FindHyp( theObj->GetID() ) : FindObject( theObj->GetID() );
+ Handle(_pyObject) existing;
+ if( isHyp )
+ existing = Handle(_pyObject)::DownCast( FindHyp( theObj->GetID() ) );
+ else
+ existing = FindObject( theObj->GetID() );
if ( !existing.IsNull() && existing != theObj )
{
existing->SetRemovedFromStudy( true );
{
map< _pyID, Handle(_pyMesh) >::const_iterator id_obj = myMeshes.find( theObjID );
if ( id_obj != myMeshes.end() )
- return id_obj->second;
+ return Handle(_pyObject)::DownCast( id_obj->second );
}
// {
// map< _pyID, Handle(_pyMeshEditor) >::const_iterator id_obj = myMeshEditors.find( theObjID );
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfInteger.hxx>
+#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
#include <list>
#include <map>
#include <vector>
#include <set>
+#include <Basics_OCCTVersion.hxx>
+
#include <SALOMEconfig.h>
#include CORBA_CLIENT_HEADER(SALOMEDS)
*/
// ===========================================================================================
-class Resource_DataMapOfAsciiStringAsciiString;
-
// ===========================================================================================
// =====================
// INTERNAL STUFF
bool AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod );
- DEFINE_STANDARD_RTTI (_pyCommand)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyCommand,Standard_Transient)
};
// -------------------------------------------------------------------------------------
virtual void ClearCommands();
virtual void Free() {}
- DEFINE_STANDARD_RTTI (_pyObject)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyObject,Standard_Transient)
};
// -------------------------------------------------------------------------------------
std::map< _AString, ExportedMeshData > myFile2ExportedMesh;
Handle( _pyHypothesisReader ) myHypReader;
- DEFINE_STANDARD_RTTI (_pyGen)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyGen,_pyObject)
};
// -------------------------------------------------------------------------------------
static void AddMeshAccess( const Handle(_pyCommand)& theCommand )
{ theCommand->SetObject( theCommand->GetObject() + "." _pyMesh_ACCESS_METHOD ); }
- DEFINE_STANDARD_RTTI (_pyMesh)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyMesh,_pyObject)
};
#undef _pyMesh_ACCESS_METHOD
virtual void Flush() {}
virtual bool CanClear();
- DEFINE_STANDARD_RTTI (_pyMesh)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyMesh,_pyObject)
};
// -------------------------------------------------------------------------------------
//void ComputeSaved ( const Handle(_pyCommand)& theComputeCommand );
- DEFINE_STANDARD_RTTI (_pyHypothesis)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyHypothesis,_pyObject)
};
// -------------------------------------------------------------------------------------
virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
- DEFINE_STANDARD_RTTI (_pyAlgorithm)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis)
};
// -------------------------------------------------------------------------------------
virtual void Process( const Handle(_pyCommand)& theCommand);
virtual void Flush();
- DEFINE_STANDARD_RTTI (_pyComplexParamHypo)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
};
DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
const _pyID& theMesh);
virtual void Free() { my1dHyp.Nullify(); }
- DEFINE_STANDARD_RTTI (_pyLayerDistributionHypo)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
};
DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
const _pyID& theMesh);
void Flush();
- DEFINE_STANDARD_RTTI (_pyNumberOfSegmentsHyp)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
};
DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
_pySegmentLengthAroundVertexHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
const _pyID& theMesh);
- DEFINE_STANDARD_RTTI (_pySegmentLengthAroundVertexHyp)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
};
DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
virtual bool CanClear();
static bool IsAliveCmd( const Handle(_pyCommand)& theCmd );
- DEFINE_STANDARD_RTTI (_pySelfEraser)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pySelfEraser,_pyObject)
};
DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
static bool CanBeArgOfMethod(const _AString& theMethodName);
- DEFINE_STANDARD_RTTI (_pySubMesh)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
};
// -------------------------------------------------------------------------------------
/*!
//virtual void Free() { myUsers.clear(); }
const _pyID& GetNewID() const { return myNewID; }
- DEFINE_STANDARD_RTTI (_pyFilter)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyFilter,_pyObject)
};
DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
virtual bool CanClear();
void RemovedWithContents();
- DEFINE_STANDARD_RTTI (_pyGroup)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyGroup,_pySubMesh)
};
// -------------------------------------------------------------------------------------
_pyHypothesisReader();
Handle(_pyHypothesis) GetHypothesis(const _AString& hypType,
const Handle(_pyCommand)& creationCmd) const;
- DEFINE_STANDARD_RTTI (_pyHypothesisReader)
+ OCCT_DEFINE_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
};
#endif
#include <SALOMEDS_wrap.hxx>
#include <GEOM_wrap.hxx>
+#include <Basics_OCCTVersion.hxx>
+
#include <BRep_Tool.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_Plane.hxx>
if ( myFileName == 0 || strlen( myFileName ) == 0 )
return false;
+#if OCC_VERSION_MAJOR < 7
FILE* aOutFile = fopen( myFileName, "wt" );
if ( !aOutFile )
return false;
aWriter.SetIndentation( 2 );
aWriter << myDoc;
fclose( aOutFile );
+#else
+ std::filebuf fb;
+ fb.open( myFileName, std::ios::out );
+
+ Standard_OStream os( &fb );
+
+ LDOM_XmlWriter aWriter;
+ aWriter.SetIndentation( 2 );
+ aWriter.Write( os, myDoc );
+ fb.close();
+#endif
TPythonDump()<<this<<".Save()";
return true;
#include CORBA_SERVER_HEADER(SALOMEDS)
#include <TCollection_AsciiString.hxx>
+#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
#include <sstream>
#include <vector>
class SMESH_Gen_i;
class SMESH_MeshEditor_i;
-class Resource_DataMapOfAsciiStringAsciiString;
// ===========================================================================================
/*!
}
if ( surf->IsKind( STANDARD_TYPE(Geom_BSplineSurface )) ||
surf->IsKind( STANDARD_TYPE(Geom_BezierSurface )))
+#if OCC_VERSION_MAJOR < 7
if ( !noSafeTShapes.insert((const Standard_Transient*) _face.TShape() ).second )
+#else
+ if ( !noSafeTShapes.insert( _face.TShape().get() ).second )
+#endif
isSafe = false;
double f, l;
edgeIsSafe = false;
}
}
+#if OCC_VERSION_MAJOR < 7
if ( !edgeIsSafe && !noSafeTShapes.insert((const Standard_Transient*) e.TShape() ).second )
+#else
+ if ( !edgeIsSafe && !noSafeTShapes.insert( _face.TShape().get() ).second )
+#endif
isSafe = false;
}
return isSafe;
#endif
#include <Standard_Failure.hxx>
+#include <Expr_NamedUnknown.hxx>
#ifdef NO_CAS_CATCH
#include <Standard_ErrorHandler.hxx>
#include "SMDS_MeshElement.hxx"
#include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
class SMESH_Hypothesis;
class SMESH_Mesh;
class SMESH_subMesh;
-class TopTools_IndexedDataMapOfShapeListOfShape;
-class TopTools_IndexedMapOfShape;
class TopoDS_Shape;
/*!
#include "SMESH_ProxyMesh.hxx"
+#include <TColgp_Array1OfPnt.hxx>
+#include <TColgp_Array1OfVec.hxx>
+
class SMESH_Mesh;
class SMESH_ElementSearcher;
class SMDS_MeshElement;
class SMDS_MeshNode;
class SMDS_MeshFace;
-class TColgp_Array1OfPnt;
-class TColgp_Array1OfVec;
class gp_Pnt;
class gp_Vec;
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UseQt4Ext)
+INCLUDE(UseQtExt)
# --- options ---
# additional include directories
# --- sources ---
# sources / moc wrappings
-QT4_WRAP_CPP(_moc_SOURCES ${_moc_HEADERS})
+QT_WRAP_MOC(_moc_SOURCES ${_moc_HEADERS})
# sources / static
SET(_other_SOURCES
INSTALL(TARGETS StdMeshersGUI EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
INSTALL(FILES ${StdMeshersGUI_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
-QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_SMESH_INSTALL_RES_DATA}")
+QT_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_SMESH_INSTALL_RES_DATA}")
ADD_SUBDIRECTORY(doc)
ENDIF(SALOME_BUILD_DOC)
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
)
# scripts / pyuic wrappings
-PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
# --- rules ---
import tempfile
from MGCleanerPlugDialog_ui import Ui_MGCleanerPlugDialog
from MGCleanerMonViewText import MGCleanerMonViewText
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from qtsalome import *
class MGCleanerMonPlugDialog(Ui_MGCleanerPlugDialog,QWidget):
self.clean()
def connecterSignaux(self) :
- self.connect(self.PB_Cancel,SIGNAL("clicked()"),self.PBCancelPressed)
- self.connect(self.PB_Default,SIGNAL("clicked()"),self.clean)
- self.connect(self.PB_Help,SIGNAL("clicked()"),self.PBHelpPressed)
- self.connect(self.PB_OK,SIGNAL("clicked()"),self.PBOKPressed)
+ self.PB_Cancel.clicked.connect(self.PBCancelPressed)
+ self.PB_Default.clicked.connect(self.clean)
+ self.PB_Help.clicked.connect(self.PBHelpPressed)
+ self.PB_OK.clicked.connect(self.PBOKPressed)
- self.connect(self.PB_Load,SIGNAL("clicked()"),self.PBLoadPressed)
- self.connect(self.PB_Save,SIGNAL("clicked()"),self.PBSavePressed)
- self.connect(self.PB_LoadHyp,SIGNAL("clicked()"),self.PBLoadHypPressed)
- self.connect(self.PB_SaveHyp,SIGNAL("clicked()"),self.PBSaveHypPressed)
+ self.PB_Load.clicked.connect(self.PBLoadPressed)
+ self.PB_Save.clicked.connect(self.PBSavePressed)
+ self.PB_LoadHyp.clicked.connect(self.PBLoadHypPressed)
+ self.PB_SaveHyp.clicked.connect(self.PBSaveHypPressed)
- self.connect(self.PB_MeshFile,SIGNAL("clicked()"),self.PBMeshFilePressed)
- self.connect(self.PB_MeshSmesh,SIGNAL("clicked()"),self.PBMeshSmeshPressed)
- self.connect(self.LE_MeshSmesh,SIGNAL("returnPressed()"),self.meshSmeshNameChanged)
- self.connect(self.PB_ParamsFileExplorer,SIGNAL("clicked()"),self.setParamsFileName)
- self.connect(self.LE_MeshFile,SIGNAL("returnPressed()"),self.meshFileNameChanged)
- self.connect(self.LE_ParamsFile,SIGNAL("returnPressed()"),self.paramsFileNameChanged)
+ self.PB_MeshFile.clicked.connect(self.PBMeshFilePressed)
+ self.PB_MeshSmesh.clicked.connect(self.PBMeshSmeshPressed)
+ self.LE_MeshSmesh.returnPressed.connect(self.meshSmeshNameChanged)
+ self.PB_ParamsFileExplorer.clicked.connect(self.setParamsFileName)
+ self.LE_MeshFile.returnPressed.connect(self.meshFileNameChanged)
+ self.LE_ParamsFile.returnPressed.connect(self.paramsFileNameChanged)
#QtCore.QObject.connect(self.checkBox, QtCore.SIGNAL("stateChanged(int)"), self.change)
- self.connect(self.CB_FillHoles,SIGNAL("stateChanged(int)"),self.SP_MinHoleSize.setEnabled)
- self.connect(self.CB_ComputedToleranceDisplacement,SIGNAL("stateChanged(int)"),self.SP_ToleranceDisplacement.setDisabled)
- self.connect(self.CB_ComputedResolutionLength,SIGNAL("stateChanged(int)"),self.SP_ResolutionLength.setDisabled)
- self.connect(self.CB_ComputedOverlapDistance,SIGNAL("stateChanged(int)"),self.SP_OverlapDistance.setDisabled)
+ self.CB_FillHoles.stateChanged[int].connect(self.SP_MinHoleSize.setEnabled)
+ self.CB_ComputedToleranceDisplacement.stateChanged[int].connect(self.SP_ToleranceDisplacement.setDisabled)
+ self.CB_ComputedResolutionLength.stateChanged[int].connect(self.SP_ResolutionLength.setDisabled)
+ self.CB_ComputedOverlapDistance.stateChanged[int].connect(self.SP_OverlapDistance.setDisabled)
def PBHelpPressed(self):
import SalomePyQt
if fd.exec_():
infile = fd.selectedFiles()[0]
self.LE_MeshFile.setText(infile)
- self.fichierIn=infile.toLatin1()
+ self.fichierIn=unicode(infile).encode("latin-1")
self.MeshIn=""
self.LE_MeshSmesh.setText("")
if fd.exec_():
infile = fd.selectedFiles()[0]
self.LE_ParamsFile.setText(infile)
- self.paramsFile=infile.toLatin1()
+ self.paramsFile=unicode(infile).encode("latin-1")
def meshFileNameChanged(self):
self.fichierIn=str(self.LE_MeshFile.text())
#
def TEST_MGCleanerMonPlugDialog():
import sys
- from PyQt4.QtGui import QApplication
- from PyQt4.QtCore import QObject, SIGNAL, SLOT
+ from qtsalome import QApplication
app = QApplication(sys.argv)
- QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
+ app.lastWindowClosed.connect(app.quit)
dlg=MGCleanerMonPlugDialog()
dlg.show()
import tempfile
import traceback
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from qtsalome import *
# Import des panels
self.setupUi(self)
self.resize( QSize(1000,600).expandedTo(self.minimumSizeHint()) )
#self.connect( self.PB_Ok,SIGNAL("clicked()"), self, SLOT("close()") )
- self.connect( self.PB_Ok,SIGNAL("clicked()"), self.theClose )
- self.connect( self.PB_Save,SIGNAL("clicked()"), self.saveFile )
+ self.PB_Ok.clicked.connect( self.theClose )
+ self.PB_Save.clicked.connect( self.saveFile )
self.PB_Save.setToolTip("Save trace in log file")
self.PB_Ok.setToolTip("Close view")
self.monExe=QProcess(self)
- self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
- self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
+ self.monExe.readyReadStandardOutput.connect( self.readFromStdOut )
+ self.monExe.readyReadStandardError.connect( self.readFromStdErr )
# Je n arrive pas a utiliser le setEnvironment du QProcess
# fonctionne hors Salome mais pas dans Salome ???
def readFromStdErr(self):
a=self.monExe.readAllStandardError()
- self.TB_Exe.append(QString.fromUtf8(a.data(),len(a)))
+ self.TB_Exe.append(unicode(a.data()))
def readFromStdOut(self) :
a=self.monExe.readAllStandardOutput()
- aa=QString.fromUtf8(a.data(),len(a))
+ aa=unicode(a.data())
self.TB_Exe.append(aa)
if "END_OF_MGCleaner" in aa:
self.parent().enregistreResultat()
import os
import subprocess
import tempfile
- from PyQt4 import QtCore
- from PyQt4 import QtGui
- from PyQt4.QtGui import QFileDialog
- from PyQt4.QtGui import QMessageBox
+ from qtsalome import QFileDialog, QMessageBox
#prior test to avoid unnecessary user GUI work with ending crash
try :
#
IF(SALOME_BUILD_GUI)
- INCLUDE(UsePyQt4)
+ INCLUDE(UsePyQt)
ENDIF(SALOME_BUILD_GUI)
# --- options ---
)
# scripts / pyuic wrappings
- PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+ PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
ENDIF(SALOME_BUILD_GUI)
import os
import subprocess
import tempfile
- from PyQt4 import QtCore
- from PyQt4 import QtGui
- from PyQt4.QtGui import QFileDialog
- from PyQt4.QtGui import QMessageBox
+ from qtsalome import QFileDialog, QMessageBox, QDialog
from MeshCutDialog_ui import Ui_Dialog
- class CutDialog(QtGui.QDialog):
+ class CutDialog(QDialog):
def __init__(self):
- QtGui.QDialog.__init__(self)
+ QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = Ui_Dialog()
self.ui.setupUi(self)
# Connect up the buttons.
- self.connect(self.ui.pb_origMeshFile, QtCore.SIGNAL("clicked()"),
- self.setInputFile)
- self.connect(self.ui.pb_cutMeshFile, QtCore.SIGNAL("clicked()"),
- self.setOutputFile)
- self.connect(self.ui.pb_help, QtCore.SIGNAL("clicked()"),
- self.helpMessage)
+ self.ui.pb_origMeshFile.clicked.connect(self.setInputFile)
+ self.ui.pb_cutMeshFile.clicked.connect(self.setOutputFile)
+ self.ui.pb_help.clicked.connect(self.helpMessage)
pass
def setInputFile(self):
if fd.exec_():
infile = fd.selectedFiles()[0]
self.ui.le_origMeshFile.setText(infile)
- insplit = os.path.splitext(infile.toLocal8Bit().data())
+ insplit = os.path.splitext(unicode(infile).encode())
outfile = insplit[0] + '_cut' + insplit[1]
self.ui.le_cutMeshFile.setText(outfile)
pass
if result:
# dialog accepted
args = ['MeshCut']
- args += [window.ui.le_origMeshFile.text().toLocal8Bit().data()]
- args += [window.ui.le_cutMeshFile.text().toLocal8Bit().data()]
- args += [window.ui.le_outMeshName.text().toLocal8Bit().data()]
- args += [window.ui.le_groupAbove.text().toLocal8Bit().data()]
- args += [window.ui.le_groupBelow.text().toLocal8Bit().data()]
+ args += [unicode(window.ui.le_origMeshFile.text()).encode()]
+ args += [unicode(window.ui.le_cutMeshFile.text()).encode()]
+ args += [unicode(window.ui.le_outMeshName.text()).encode()]
+ args += [unicode(window.ui.le_groupAbove.text()).encode()]
+ args += [unicode(window.ui.le_groupBelow.text()).encode()]
args += [str(window.ui.dsb_normX.value())]
args += [str(window.ui.dsb_normY.value())]
args += [str(window.ui.dsb_normZ.value())]
import datetime
import sys
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableMaillages import TableMaillages
from tableMailleurs import TableMailleurs
from tableMachines import TableMachines
class Base:
def __init__(self,file):
- self.db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
+ self.db = QSqlDatabase.addDatabase("QSQLITE")
self.db.setDatabaseName(file)
self.db.setHostName("localhost");
self.db.setUserName("");
#!/usr/bin/env python
import sys,os
-from PyQt4 import QtGui,QtCore
pathRacine=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),'..'))
if os.path.dirname(pathRacine) not in sys.path :
-from PyQt4 import QtSql, QtCore
-from PyQt4.QtSql import *
+from qtsalome import QSqlQuery
import datetime
class TableDeBase :
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableGroupeRatios (TableDeBase):
self.setTypeField(('int','int','str','float','float','float','float','float','float'),('idMaillage','idVersion','Groupe'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table GroupesRatios(idMaillage int, idVersion int, Groupe varchar(40),"
texteQuery+="RatioMax float, RatioMin float, "
print "Creation de TableGroupeRatios : " , query.exec_(texteQuery)
def getVal(self,idMaillage, idVersion, Groupe, Entite):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select '+ str(Entite) + ' from GroupesRatios where idMaillage='+str(idMaillage)
texteQuery+=' and idVersion='+str(idVersion)
texteQuery+=" and Groupe='" + str(Groupe) +"';"
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableGroupeTailles (TableDeBase):
self.setTypeField(('int','int','str','float','float','float','float','float','float'),('idMaillage','idVersion'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table GroupeTailles(idMaillage int, idVersion int, "
texteQuery+="Groupe varchar(40),TailleMax float, TailleMin float, "
print "Creation de TableGroupeTailles : " , query.exec_(texteQuery)
def getVal(self,idMaillage, idVersion, Groupe, Entite):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select '+ str(Entite) + ' from GroupeTailles where idMaillage='+str(idMaillage)
texteQuery+=' and idVersion='+str(idVersion)
texteQuery+=" and Groupe='" + str(Groupe) +"';"
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableGroupes (TableDeBase):
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Groupes( nomGroupe varchar(40),idMaillage int, idVersion int,"
def getVal(self,nomGroupe,idMaillage,idVersion,typeMaille):
val=0 # Valeur si l enregistrement n existe pas
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select NbEntite from Groupes where nomGroupe ="' + nomGroupe +'"'
texteQuery +=' and idMaillage=' + str(idMaillage)
texteQuery +=' and idVersion = ' + str(idVersion)
def getAllEntity(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="select distinct Entite from Groupes;"
query.exec_(texteQuery)
maListe=[]
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableGroupesRef (TableDeBase):
self.setTypeField(('str','int'),('nomGroupe'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table GroupesRef(nomGroupe varchar(40), idMaillage int,"
texteQuery+="foreign key (idMaillage) references Maillages(idMaillage),"
texteQuery+="primary key (nomGroupe,idMaillage));"
print "Creation de TableGroupesRef : " , query.exec_(texteQuery)
def getVals(self,idMaillage):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select NomGroupe from GroupesRef where idMaillage='+str(idMaillage) +";"
listeGroupes=[]
query.exec_(texteQuery)
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
import os
self.setTypeField(('str','str'),('nomMachine'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
print "creation de TableMachine : ", query.exec_("create table Machines( nomMachine varchar(10) primary key, os varchar(10));")
def creeMachine(self):
self.insereLigne((nomMachine,nomOs))
def chercheMachine(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
machine=os.uname()[1]
texteQuery ="select nomMachine from Machines where nomMachine ='" + machine +"' ;"
query.exec_(texteQuery)
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableMaillages (TableDeBase):
self.setTypeField(('int','str','str','str','int','int','int','int','int','int','str'),('id'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Maillages(id integer primary key autoincrement, nomMaillage varchar(10), "
texteQuery+="nomScript varchar(40), medResultat varchar(15), idMailleur int, dimension int,"
texteQuery+="seuilCPU int, seuilRatio int, seuilTaille int, seuilNbMaille int, commentaire varchar(60), "
print "creation de TableMaillages : " , query.exec_(texteQuery)
def getVal(self,idMaillage, nomChamp):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
valeur=None
texteQuery ='select '+ nomChamp + ' from Maillages where id=' + str(idMaillage) + ";"
query.exec_(texteQuery)
def dejaRemplie(self):
texteQuery="select * from Maillages where medResultat='/tmp/tetra.med';"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
# self.insereLigneAutoId(('Fiche_7957_AILETTE', '/home/H77945/CAS_TEST/MAILLEUR/FICHE_7957_AILETTE/Fiche_7957_AILETTE.py', '/tmp/Fiche_7957_AILETTE.med', 1,2,10,10,10,10, 'Maillage d une attache d aillette'))
def construitListeMaillages(self):
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
texteQuery="select id, nomScript,medResultat from Maillages;"
maQuery.exec_(texteQuery)
listeMaillages=[]
def verifieListeMaillages(self,listeMaillage):
newListeMaillages=[]
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
for idM in listeMaillage:
texteQuery="select id, nomScript,medResultat from Maillages where id = " + str(idM) +';'
maQuery.exec_(texteQuery)
def getSeuilsPourMaillage(self,idMaillage):
texteQuery="select id,nomMaillage,seuilCPU,seuilRatio,seuilTaille,seuilNbMaille from Maillages where id = "+ str(idMaillage) +" ;"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
l1 = maQuery.value(0).toInt()[0]
def getTous(self):
maillagesIdListe=[]; maillagesNomListe=[]
texteQuery="select id,nomMaillage from Maillages order by id;"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
maillagesIdListe.append( maQuery.value(0).toInt()[0])
def getMailleurId(self,idMaillage):
texteQuery="select idMailleur from Maillages where id = "+ str(idMaillage) +" ;"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
print texteQuery
print maQuery.exec_(texteQuery)
maQuery.exec_(texteQuery)
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableMailles (TableDeBase):
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Mailles(idMaillage int, idVersion int, Entite var(40), NbEntite int, "
def getVal(self,idMaillage, idVersion, Entite):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select NbEntite from Mailles where idMaillage='+str(idMaillage)
texteQuery+=' and idVersion='+str(idVersion)
texteQuery+=" and Entite='" + str(Entite) +"';"
def getAllEntity(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="select distinct Entite from Mailles;"
query.exec_(texteQuery)
maListe=[]
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableMailleurs (TableDeBase):
self.setTypeField(("int","str"),('id'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
print "Creation de TableMailleurs", query.exec_("create table Mailleurs(id integer primary key autoincrement, nomMailleur varchar(40));")
def dejaRemplie(self):
texteQuery="select * from Mailleurs where nomMailleur='Blsurf+Ghs3D';"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
nb=0
while(maQuery.next()): nb=nb+1
def insereLigneAutoId(self,valeurs,debug=False):
# difficulte a construire le texte avec une seule valeur
texteQuery='insert into Mailleurs (nomMailleur) values ("'+ str(valeurs[0])+ '");'
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
if debug : print texteQuery, " " , maQuery.exec_(texteQuery)
else : maQuery.exec_(texteQuery)
l1=[]
l2=[]
texteQuery="select * from Mailleurs;"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
l1.append( maQuery.value(0).toInt()[0])
def getName(self,mailleurId):
texteQuery="select nomMailleur from Mailleurs where id = " + str(mailleurId) + " ;"
- maQuery=QtSql.QSqlQuery()
+ maQuery=QSqlQuery()
maQuery.exec_(texteQuery)
while(maQuery.next()):
mailleurName=maQuery.value(0).toString()
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TablePerfs (TableDeBase):
self.setTypeField(('int','int','str','int','int'),('idMaillage','idVersion','Machine'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Perfs(idMaillage int, idVersion int, Machine varchar(10), NbCpu int, Mem int, "
texteQuery+="foreign key (idMaillage) references Maillages(id),"
texteQuery+="foreign key (idVersion) references Versions(id),"
print "Creation de TablePerfs : " , query.exec_(texteQuery)
def getVal(self,idMaillage,idVersion,Machine):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select NbCpu from Perfs where idMaillage=' + str(idMaillage)
texteQuery +=' and idVersion = ' + str(idVersion)
texteQuery +=" and Machine ='" + Machine + "';"
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableRatios (TableDeBase):
self.setTypeField(('int','int','float','float','float','float','float','float'),('idMaillage','idVersion','Machine'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Ratios(idMaillage int, idVersion int, "
texteQuery+="RatioMax float, RatioMin float, "
print "Creation de TableRatios : " , query.exec_(texteQuery)
def getVal(self,idMaillage, idVersion, Entite):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select '+ str(Entite) + ' from Ratios where idMaillage='+str(idMaillage)
texteQuery+=' and idVersion='+str(idVersion)
query.exec_(texteQuery)
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableTailles (TableDeBase):
self.setTypeField(('int','int','str','float','float','float','float','float','float'),('idMaillage','idVersion'))
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Tailles(idMaillage int, idVersion int, "
texteQuery+="TailleMax float, TailleMin float, "
print "Creation de TableTailles : " , query.exec_(texteQuery)
def getVal(self,idMaillage, idVersion, Entite):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ='select '+ str(Entite) + ' from Tailles where idMaillage='+str(idMaillage)
texteQuery+=' and idVersion='+str(idVersion)
query.exec_(texteQuery)
-from PyQt4 import QtSql, QtCore
+from qtsalome import QSqlQuery
from tableDeBase import TableDeBase
class TableVersions (TableDeBase):
self.cols=" (nomVersion, commentaire) "
def createSqlTable(self):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
texteQuery ="create table Versions(id integer primary key autoincrement, nomVersion varchar(10),"
texteQuery+="commentaire varchar(30));"
print "Creation de TableVersions : " , query.exec_(texteQuery)
def chercheVersion(self,version):
- query=QtSql.QSqlQuery()
+ query=QSqlQuery()
version=str(version)
- if QtCore.QString(version).toInt()[1]==True :
+ if bool(version) == True :
texteQuery ="select id, nomVersion from Versions where id = " + str(version) +";"
else:
texteQuery ="select id, nomVersion from Versions where nomVersion ='" + version +"' ;"
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
)
# scripts / pyuic wrappings
-PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
# --- rules ---
from desFenetreChoix_ui import Ui_Choix
-from PyQt4 import *
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from qtsalome import *
from monEditor import TableEditor
# Import des panels
-class MaFenetreChoix(Ui_Choix ,QtGui.QDialog):
+class MaFenetreChoix(Ui_Choix ,QDialog):
"""
"""
def __init__(self,db):
- QtGui.QDialog.__init__(self)
+ QDialog.__init__(self)
self.setModal(True)
self.setupUi(self)
self.db=db
self.connecterSignaux()
def connecterSignaux(self):
- self.connect(self.PBMailleur,SIGNAL("clicked()"),self.MailleurPush)
- self.connect(self.PBMaillage,SIGNAL("clicked()"),self.MaillagePush)
- self.connect(self.PBVersion,SIGNAL("clicked()"),self.VersionPush)
- self.connect(self.PBMachine,SIGNAL("clicked()"),self.MachinePush)
- self.connect(self.PBGroupe,SIGNAL("clicked()"),self.GroupePush)
- self.connect(self.PBRatio,SIGNAL("clicked()"),self.RatioPush)
- self.connect(self.PBGroupeRatio,SIGNAL("clicked()"),self.GroupeRatioPush)
- self.connect(self.PBGroupeTaille,SIGNAL("clicked()"),self.GroupeTaillePush)
- self.connect(self.PBPerf,SIGNAL("clicked()"),self.PerfPush)
- self.connect(self.PBMaille,SIGNAL("clicked()"),self.MaillePush)
- self.connect(self.PBTaille,SIGNAL("clicked()"),self.TaillePush)
- self.connect(self.PBGroupesRef,SIGNAL("clicked()"),self.GroupesRefPush)
+ self.PBMailleur.clicked.connect(self.MailleurPush)
+ self.PBMaillage.clicked.connect(self.MaillagePush)
+ self.PBVersion.clicked.connect(self.VersionPush)
+ self.PBMachine.clicked.connect(self.MachinePush)
+ self.PBGroupe.clicked.connect(self.GroupePush)
+ self.PBRatio.clicked.connect(self.RatioPush)
+ self.PBGroupeRatio.clicked.connect(self.GroupeRatioPush)
+ self.PBGroupeTaille.clicked.connect(self.GroupeTaillePush)
+ self.PBPerf.clicked.connect(self.PerfPush)
+ self.PBMaille.clicked.connect(self.MaillePush)
+ self.PBTaille.clicked.connect(self.TaillePush)
+ self.PBGroupesRef.clicked.connect(self.GroupesRefPush)
def MailleurPush(self):
editor=TableEditor(self.db.maTableMailleurs,self)
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtSql import *
-
+from qtsalome import *
class TableEditor(QDialog):
quitButton=QPushButton("Quit")
buttonBox=QDialogButtonBox(Qt.Vertical)
buttonBox.addButton(quitButton, QDialogButtonBox.RejectRole);
- self.connect(quitButton, SIGNAL("clicked()"), self, SLOT("close()"))
+ quitButton.clicked.connect(self.close())
mainLayout = QHBoxLayout(self)
mainLayout.addWidget(self.view)
self.view.resizeColumnsToContents()
self.view.adjustSize()
self.adjustSize()
- self.connect(self.view,SIGNAL("pressed(QModelIndex*)"),self.donneLigne)
- self.connect(self.view,SIGNAL("itemPressed(QTableWidgetItem*)"),self.donneLigne)
- self.connect(self.view,SIGNAL("clicked(QModelIndex*)"),self.donneLigne)
- self.connect(self.view,SIGNAL("clicked()"),self.donneLigne)
- self.connect(self.view,SIGNAL("pressed()"),self.donneLigne)
+ self.view.pressed[QModelIndex].connect(self.donneLigne)
+ self.view.itemPressed[QTableWidgetItem].conect(self.donneLigne)
+ self.view.clicked[QModelIndex].connect(self.donneLigne)
+ self.view.clicked.connect(self.donneLigne)
+ self.view.pressed.connect(self.donneLigne)
def donneLigne(self):
print "jjjjjjjjjjjjjjjj"
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtSql import *
+from qtsalome import *
from nomBase_ui import Ui_LEDataBaseName
self.setupUi(self)
self.setModal(True)
self.parent=parent
- self.connect(self.LEBaseName, SIGNAL("returnPressed()"), self.LEDBreturnPressed)
+ self.LEBaseName.returnPressed.connect(self.LEDBreturnPressed)
def LEDBreturnPressed(self):
installDir=os.path.join(rep,'..')
sys.path.insert(0,installDir)
-from PyQt4 import QtGui,QtCore
+from qtsalome import QApplication
from Gui.maFenetreChoix_ui import MaFenetreChoix
from Base.dataBase import Base
p.add_option('-d',dest='database',default="myMesh.db",help='nom de la database')
options, args = p.parse_args()
- app = QtGui.QApplication(sys.argv)
+ app = QApplication(sys.argv)
maBase=Base(options.database)
maBase.initialise()
window = MaFenetreChoix(maBase)
import os
import subprocess
import time
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
-
class Job:
def __init__(self,listeParamMaillage,salomePath,versionId,mesGroupesRef):
import os
import subprocess
import time
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
-from PyQt4.QtSql import *
-
class Ref:
def __init__(self,maBase,idMaillage,idVersion,machine):
installDir=os.path.join(rep,'..')
sys.path.insert(0,installDir)
-from PyQt4 import QtGui,QtCore,QtSql
+from qtsalome import *
from Base.dataBase import Base
def completeDatabase(fichier,table,enregistrement):
maBase.initialise()
nomTable="ma"+str(table)
matable=getattr(maBase,nomTable)
- model= QtSql.QSqlTableModel()
+ model= QSqlTableModel()
model.setTable(matable.nom)
nbCols=model.columnCount() -1
if table == "TableGroupesRef" : nbCols==nbCols+1
import sys
import os
-from PyQt4 import QtGui,QtCore
from Base.dataBase import Base
from Base.versions import Chercheversion
#!/usr/bin/env python
import sys
-from PyQt4 import QtGui,QtCore
from Base.dataBase import Base
def creeDatabase(fichier):
#!/usr/bin/env python
-from PyQt4 import *
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from qtsalome import *
from Gui.myMain_ui import Ui_Gestion
import sys
self.version=""
def connectSignaux(self) :
- self.connect(self.BExp,SIGNAL("clicked()"),self.BExpPressed)
- self.connect(self.BImp,SIGNAL("clicked()"),self.BImpPressed)
- self.connect(self.BCree,SIGNAL("clicked()"),self.BCreePressed)
- self.connect(self.BVue,SIGNAL("clicked()"),self.BVuePressed)
- self.connect(self.BStat,SIGNAL("clicked()"),self.BStatPressed)
+ self.BExp.clicked.connect(self.BExpPressed)
+ self.BImp.clicked.connect(self.BImpPressed)
+ self.BCree.clicked.connect(self.BCreePressed)
+ self.BVue.clicked.connect(BVuePressed)
+ self.BStat.clicked.connect(BStatPressed)
def BExpPressed(self):
import sys
import os
-from PyQt4 import QtGui,QtCore
from Base.dataBase import Base
from Base.versions import Chercheversion
ADD_SUBDIRECTORY(doc)
ENDIF(SALOME_BUILD_DOC)
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
)
# scripts / pyuic wrappings
-PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
# --- rules ---
import traceback
import tempfile
-from PyQt4 import *
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
+from qtsalome import *
# Import des panels
QDialog.__init__(self,parent)
self.setupUi(self)
self.resize( QSize(1000,600).expandedTo(self.minimumSizeHint()) )
- #self.connect( self.PB_Ok,SIGNAL("clicked()"), self, SLOT("close()") )
- self.connect( self.PB_Ok,SIGNAL("clicked()"), self.theClose )
- self.connect( self.PB_Save,SIGNAL("clicked()"), self.saveFile )
+ # self.PB_Ok.clicked.connect(self.close)
+ self.PB_Ok.clicked.connect( self.theClose )
+ self.PB_Save.clicked.connect( self.saveFile )
self.monExe=QProcess(self)
- self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
- self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
+ self.monExe.readyReadStandardOutput.connect( self.readFromStdOut )
+ self.monExe.readyReadStandardError.connect( self.readFromStdErr )
# Je n arrive pas a utiliser le setEnvironment du QProcess
# fonctionne hors Salome mais pas dans Salome ???
def saveFile(self):
#recuperation du nom du fichier
savedir=os.environ['HOME']
- fn = QFileDialog.getSaveFileName(None, self.trUtf8("Save File"),savedir)
+ fn = QFileDialog.getSaveFileName(None,"Save File",savedir)
if fn.isNull() : return
ulfile = os.path.abspath(unicode(fn))
try:
f.write(str(self.TB_Exe.toPlainText()))
f.close()
except IOError, why:
- QMessageBox.critical(self, self.trUtf8('Save File'),
- self.trUtf8('The file <b>%1</b> could not be saved.<br>Reason: %2')
- .arg(unicode(fn)).arg(str(why)))
+ QMessageBox.critical(self, 'Save File',
+ 'The file <b>%1</b> could not be saved.<br>Reason: %2'%(unicode(fn), str(why)))
def readFromStdErr(self):
a=self.monExe.readAllStandardError()
- self.TB_Exe.append(QString.fromUtf8(a.data(),len(a)))
+ self.TB_Exe.append(unicode(a.data().encode()))
def readFromStdOut(self) :
a=self.monExe.readAllStandardOutput()
- aa=QString.fromUtf8(a.data(),len(a))
+ aa=unicode(a.data(),len(a))
self.TB_Exe.append(aa)
if "END_OF_Yams" in aa:
self.parent().enregistreResultat()
import tempfile
from YamsPlugDialog_ui import Ui_YamsPlugDialog
from monViewText import MonViewText
-from PyQt4.QtGui import *
-from PyQt4.QtCore import *
-
+from qtsalome import *
class MonYamsPlugDialog(Ui_YamsPlugDialog,QWidget):
"""
self.clean()
def connecterSignaux(self) :
- self.connect(self.PB_Cancel,SIGNAL("clicked()"),self.PBCancelPressed)
- self.connect(self.PB_Default,SIGNAL("clicked()"),self.clean)
- self.connect(self.PB_Help,SIGNAL("clicked()"),self.PBHelpPressed)
- self.connect(self.PB_OK,SIGNAL("clicked()"),self.PBOKPressed)
+ self.PB_Cancel.clicked.connect(self.PBCancelPressed)
+ self.PB_Default.clicked.connect(self.clean)
+ self.PB_Help.clicked.connect(self.PBHelpPressed)
+ self.PB_OK.clicked.connect(self.PBOKPressed)
- self.connect(self.PB_Load,SIGNAL("clicked()"),self.PBLoadPressed)
- self.connect(self.PB_Save,SIGNAL("clicked()"),self.PBSavePressed)
- self.connect(self.PB_LoadHyp,SIGNAL("clicked()"),self.PBLoadHypPressed)
- self.connect(self.PB_SaveHyp,SIGNAL("clicked()"),self.PBSaveHypPressed)
+ self.PB_Load.clicked.connect(self.PBLoadPressed)
+ self.PB_Save.clicked.connect(self.PBSavePressed)
+ self.PB_LoadHyp.clicked.connect(self.PBLoadHypPressed)
+ self.PB_SaveHyp.clicked.connect(self.PBSaveHypPressed)
- self.connect(self.PB_MeshFile,SIGNAL("clicked()"),self.PBMeshFilePressed)
- self.connect(self.PB_MeshSmesh,SIGNAL("clicked()"),self.PBMeshSmeshPressed)
- self.connect(self.LE_MeshSmesh,SIGNAL("returnPressed()"),self.meshSmeshNameChanged)
- self.connect(self.PB_ParamsFileExplorer,SIGNAL("clicked()"),self.setParamsFileName)
- self.connect(self.LE_MeshFile,SIGNAL("returnPressed()"),self.meshFileNameChanged)
- self.connect(self.LE_ParamsFile,SIGNAL("returnPressed()"),self.paramsFileNameChanged)
+ self.PB_MeshFile.clicked.connect(self.PBMeshFilePressed)
+ self.PB_MeshSmesh.clicked.connect(self.PBMeshSmeshPressed)
+ self.LE_MeshSmesh.returnPressed.connect(self.meshSmeshNameChanged)
+ self.PB_ParamsFileExplorer.clicked.connect(self.setParamsFileName)
+ self.LE_MeshFile.returnPressed.connect(self.meshFileNameChanged)
+ self.LE_ParamsFile.returnPressed.connect(self.paramsFileNameChanged)
def PBHelpPressed(self):
import SalomePyQt
if fd.exec_():
infile = fd.selectedFiles()[0]
self.LE_MeshFile.setText(infile)
- self.fichierIn=infile.toLatin1()
+ self.fichierIn=unicode(infile).encode("latin-1")
self.MeshIn=""
self.LE_MeshSmesh.setText("")
if fd.exec_():
infile = fd.selectedFiles()[0]
self.LE_ParamsFile.setText(infile)
- self.paramsFile=infile.toLatin1()
+ self.paramsFile=unicode(infile).encode("latin-1")
def meshFileNameChanged(self):
self.fichierIn=str(self.LE_MeshFile.text())
except:
pass
- style = self.style.toLatin1()
+ style = unicode(self.style).encode("latin-1")
# Translation of old Yams options to new MG-SurfOpt options
if style == "0" :
self.commande+= " --optimisation only"
#
def TEST_MonYamsPlugDialog():
import sys
- from PyQt4.QtGui import QApplication
- from PyQt4.QtCore import QObject, SIGNAL, SLOT
+ from qtsalome import QApplication
app = QApplication(sys.argv)
- QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
+ app.lastWindowClosed.connect(app.quit)
dlg=MonYamsPlugDialog()
dlg.show()
import os
import subprocess
import tempfile
- from PyQt4 import QtCore
- from PyQt4 import QtGui
- from PyQt4.QtGui import QFileDialog
- from PyQt4.QtGui import QMessageBox
+ from qtsalome import QFileDialog, QMessageBox
#prior test to avoid unnecessary user GUI work with ending crash
try :
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
)
# scripts / pyuic wrappings
-PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
# --- rules ---
SALOME_INSTALL_SCRIPTS("${plugin_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/blocFissure/ihm)
-SALOME_INSTALL_SCRIPTS("${_pyuic_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/blocFissure/ihm)
\ No newline at end of file
+SALOME_INSTALL_SCRIPTS("${_pyuic_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/blocFissure/ihm)
<sender>cb_optDiscrSain</sender>
<signal>clicked(bool)</signal>
<receiver>gb_discrSain</receiver>
- <slot>setShown(bool)</slot>
+ <slot>setVisible(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>69</x>
<sender>cb_optDiscrFiss</sender>
<signal>clicked(bool)</signal>
<receiver>gb_discrFacesExternes</receiver>
- <slot>setShown(bool)</slot>
+ <slot>setVisible(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>1033</x>
<sender>cb_optDiscrFiss</sender>
<signal>clicked(bool)</signal>
<receiver>gb_zoneRemail</receiver>
- <slot>setShown(bool)</slot>
+ <slot>setVisible(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>1033</x>
import os
#import subprocess
#import tempfile
- from PyQt4 import QtCore
- from PyQt4 import QtGui
- from PyQt4.QtGui import QFileDialog
- from PyQt4.QtGui import QMessageBox
- from PyQt4.QtGui import QPalette
- from PyQt4.QtGui import QColor
+ from qtsalome import QFileDialog, QMessageBox, QPalette, QColor, QDialog
from fissureCoude_ui import Ui_Dialog
- class fissureCoudeDialog(QtGui.QDialog):
+ class fissureCoudeDialog(QDialog):
def __init__(self):
- QtGui.QDialog.__init__(self)
+ QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.lb_calcul.hide()
# Connect up the buttons.
- self.connect(self.ui.pb_valPrec, QtCore.SIGNAL("clicked()"),
- self.readValPrec)
- self.connect(self.ui.pb_reset, QtCore.SIGNAL("clicked()"),
- self.resetVal)
- self.connect(self.ui.pb_recharger, QtCore.SIGNAL("clicked()"),
- self.recharger)
- self.connect(self.ui.pb_sauver, QtCore.SIGNAL("clicked()"),
- self.sauver)
- self.disconnect(self.ui.buttonBox, QtCore.SIGNAL("accepted()"), self.accept)
- self.connect(self.ui.buttonBox, QtCore.SIGNAL("accepted()"),
- self.execute)
+ self.ui.pb_valPrec.clicked.connect(self.readValPrec)
+ self.ui.pb_reset.clicked.connect(self.resetVal)
+ self.ui.pb_recharger.clicked.connect(self.recharger)
+ self.ui.pb_sauver.clicked.connect(self.sauver)
+ self.ui.buttonBox.accepted.disconnect(self.accept)
+ self.ui.buttonBox.accepted.connect(self.execute)
def initDefaut(self):
self.defaut = dict(
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
)
# scripts / pyuic wrappings
-PYQT4_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
+PYQT_WRAP_UIC(_pyuic_SCRIPTS ${_pyuic_files})
# --- rules ---
SALOME_INSTALL_SCRIPTS("${_pyuic_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/smesh/spadder/gui)
from omniORB import CORBA
-from PyQt4.QtCore import QObject, SIGNAL, SLOT
-from PyQt4.QtGui import QIcon, QStandardItemModel, QStandardItem, QMessageBox
+from qtsalome import QIcon, QStandardItemModel, QStandardItem, QMessageBox, pyqtSignal
from inputframe_ui import Ui_InputFrame
from inputdata import InputData
class InputDialog(GenericDialog):
TBL_HEADER_LABEL=["Input Mesh", "Output group name"]
+
+ inputValidated = pyqtSignal()
def __init__(self, parent=None, name="InputDialog", modal=0):
"""
# The click on btnSmeshObject (signal clicked() emitted by the
# button btnSmeshObject) is connected to the slot
# onSelectSmeshObject, etc ...
- self.connect(self.__ui.btnSmeshObject, SIGNAL('clicked()'), self.onSelectSmeshObject )
- self.connect(self.__ui.btnAddInput, SIGNAL('clicked()'), self.onAddInput )
- self.connect(self.__ui.btnDeleteInput, SIGNAL('clicked()'), self.onDeleteInput )
+ self.__ui.btnSmeshObject.clicked.connect( self.onSelectSmeshObject )
+ self.__ui.btnAddInput.clicked.connect( self.onAddInput )
+ self.__ui.btnDeleteInput.clicked.connect( self.onDeleteInput )
# Set up the model of the Qt table list
self.__inputModel = QStandardItemModel(0,2)
# been validated so that it can process the event
GenericDialog.accept(self)
if self.wasOk():
- self.emit(SIGNAL('inputValidated()'))
+ self.inputValidated.emit()
def onSelectSmeshObject(self):
'''
creates a new entry in the list of input data, or updates this
entry if it already exists.
"""
- meshName = str(self.__ui.txtSmeshObject.text().trimmed())
+ meshName = str(self.__ui.txtSmeshObject.text()).strip()
meshObject = self.__selectedMesh
meshType = self.__ui.cmbMeshType.currentIndex()
- groupName = str(self.__ui.txtGroupName.text().trimmed())
+ groupName = str(self.__ui.txtGroupName.text()).strip()
self.__addInputInGui(meshName, meshObject, meshType, groupName)
self.__addInputInMap(meshName, meshObject, meshType, groupName)
#
def TEST_InputDialog():
import sys
- from PyQt4.QtCore import QObject, SIGNAL, SLOT
- from PyQt4.QtGui import QApplication
+ from qtsalome import QApplication
app = QApplication(sys.argv)
- QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
+ app.lastWindowClosed.connect( app.quit )
dlg=InputDialog()
dlg.displayAndWait()
def TEST_InputDialog_setData():
import sys
- from PyQt4.QtCore import QObject, SIGNAL, SLOT
- from PyQt4.QtGui import QApplication
+ from qtsalome import QApplication
app = QApplication(sys.argv)
- QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
+ app.lastWindowClosed.connect( app.quit )
dlg=InputDialog()
# Author : Guillaume Boulant (EDF)
#
-from PyQt4.QtGui import QDialog, QIcon
-from PyQt4.QtCore import QObject, SIGNAL, SLOT, Qt
+from qtsalome import QDialog, QIcon, Qt
from plugindialog_ui import Ui_PluginDialog
from inputdialog import InputDialog
self.__ui.btnClear.setIcon(icon)
# Then, we can connect the slot to there associated button event
- self.connect(self.__ui.btnInput, SIGNAL('clicked()'), self.onInput )
- self.connect(self.__ui.btnCompute, SIGNAL('clicked()'), self.onCompute )
- self.connect(self.__ui.btnRefresh, SIGNAL('clicked()'), self.onRefresh )
- self.connect(self.__ui.btnPublish, SIGNAL('clicked()'), self.onPublish )
- self.connect(self.__ui.btnClear, SIGNAL('clicked()'), self.onClear )
+ self.__ui.btnInput.clicked.connect( self.onInput )
+ self.__ui.btnCompute.clicked.connect( self.onCompute )
+ self.__ui.btnRefresh.clicked.connect( self.onRefresh )
+ self.__ui.btnPublish.clicked.connect( self.onPublish )
+ self.__ui.btnClear.clicked.connect( self.onClear )
self.clear()
self.__inputDialog.windowFlags() | Qt.WindowStaysOnTopHint)
# The signal inputValidated emited from inputDialog is
# connected to the slot function onProcessInput:
- self.connect(self.__inputDialog, SIGNAL('inputValidated()'), self.onProcessInput)
+ self.__inputDialog.inputValidated.connect( self.onProcessInput )
else:
self.__ui.frameInput.setVisible(True)
#
def TEST_PluginDialog():
import sys
- from PyQt4.QtGui import QApplication
- from PyQt4.QtCore import QObject, SIGNAL, SLOT
+ from qtsalome import QApplication
app = QApplication(sys.argv)
- QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
+ app.lastWindowClosed.connect( app.quit )
dlg=PluginDialog()
dlg.exec_()
try:
dialog=plugindialog.getDialog()
except UiException, err:
- from PyQt4.QtGui import QMessageBox
+ from qtsalome import QMessageBox
QMessageBox.critical(None,"An error occurs during PADDER configuration",
err.getUIMessage())
return