# Project name, upper case
STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
-SET(${PROJECT_NAME_UC}_MAJOR_VERSION 7)
-SET(${PROJECT_NAME_UC}_MINOR_VERSION 7)
+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 1)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
# 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})
SET_AND_CHECK(TBB_ROOT_DIR_EXP "@PACKAGE_TBB_ROOT_DIR@")
ENDIF()
-# For all prerequisites, load the corresponding targets if the package was used
+# For all prerequisites, load the corresponding targets if the package was used
# in CONFIG mode. This ensures dependent projects link correctly
# without having to set LD_LIBRARY_PATH:
-SET(_PREREQ @_PREREQ_LIST@)
-SET(_PREREQ_CONFIG_DIR @_PREREQ_DIR_LIST@)
-SET(_PREREQ_COMPONENTS "@_PREREQ_COMPO_LIST@")
-LIST(LENGTH _PREREQ_CONFIG_DIR _list_len)
-IF(NOT _list_len EQUAL 0)
+SET(_PREREQ_@PROJECT_NAME@ @_PREREQ_LIST@)
+SET(_PREREQ_@PROJECT_NAME@_CONFIG_DIR @_PREREQ_DIR_LIST@)
+SET(_PREREQ_@PROJECT_NAME@_COMPONENTS "@_PREREQ_COMPO_LIST@")
+LIST(LENGTH _PREREQ_@PROJECT_NAME@_CONFIG_DIR _list_len_@PROJECT_NAME@)
+IF(NOT _list_len_@PROJECT_NAME@ EQUAL 0)
# Another CMake stupidity - FOREACH(... RANGE r) generates r+1 numbers ...
- MATH(EXPR _range "${_list_len}-1")
- FOREACH(_p RANGE ${_range})
- LIST(GET _PREREQ ${_p} _pkg )
- LIST(GET _PREREQ_CONFIG_DIR ${_p} _pkg_dir)
- LIST(GET _PREREQ_COMPONENTS ${_p} _pkg_compo)
- MESSAGE(STATUS "===> Reloading targets from ${_pkg} ...")
- IF(NOT _pkg_compo)
- FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE
- PATHS "${_pkg_dir}"
- NO_DEFAULT_PATH)
- ELSE()
- STRING(REPLACE "," ";" _compo_lst "${_pkg_compo}")
- MESSAGE(STATUS "===> (components: ${_pkg_compo})")
- FIND_PACKAGE(${_pkg} REQUIRED NO_MODULE
- COMPONENTS ${_compo_lst}
- PATHS "${_pkg_dir}"
- NO_DEFAULT_PATH)
+ MATH(EXPR _range_@PROJECT_NAME@ "${_list_len_@PROJECT_NAME@}-1")
+ FOREACH(_p_@PROJECT_NAME@ RANGE ${_range_@PROJECT_NAME@})
+ LIST(GET _PREREQ_@PROJECT_NAME@ ${_p_@PROJECT_NAME@} _pkg_@PROJECT_NAME@ )
+ LIST(GET _PREREQ_@PROJECT_NAME@_CONFIG_DIR ${_p_@PROJECT_NAME@} _pkg_dir_@PROJECT_NAME@)
+ LIST(GET _PREREQ_@PROJECT_NAME@_COMPONENTS ${_p_@PROJECT_NAME@} _pkg_compo_@PROJECT_NAME@)
+ IF(NOT OMIT_DETECT_PACKAGE_${_pkg_@PROJECT_NAME@})
+ MESSAGE(STATUS "===> Reloading targets from ${_pkg_@PROJECT_NAME@} ...")
+ IF(NOT _pkg_compo_@PROJECT_NAME@)
+ FIND_PACKAGE(${_pkg_@PROJECT_NAME@} REQUIRED NO_MODULE
+ PATHS "${_pkg_dir_@PROJECT_NAME@}"
+ NO_DEFAULT_PATH)
+ ELSE()
+ STRING(REPLACE "," ";" _compo_lst_@PROJECT_NAME@ "${_pkg_compo_@PROJECT_NAME@}")
+ MESSAGE(STATUS "===> (components: ${_pkg_compo_@PROJECT_NAME@})")
+ FIND_PACKAGE(${_pkg_@PROJECT_NAME@} REQUIRED NO_MODULE
+ COMPONENTS ${_compo_lst_@PROJECT_NAME@}
+ PATHS "${_pkg_dir_@PROJECT_NAME@}"
+ NO_DEFAULT_PATH)
+ ENDIF()
ENDIF()
ENDFOREACH()
ENDIF()
# 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 );
myOrderMgr = new SMESHGUI_MeshOrderMgr( myDlg->getMeshOrderBox() );
myOrderMgr->SetMesh( myMesh );
bool isOrder = myOrderMgr->GetMeshOrder(myPrevOrder);
- myDlg->getMeshOrderBox()->setShown(isOrder);
+ myDlg->getMeshOrderBox()->setVisible(isOrder);
if ( !isOrder ) {
delete myOrderMgr;
myOrderMgr = 0;
SUIT_FileDlg* aDlg = new SUIT_FileDlg( this, false );
aDlg->setWindowTitle( tr( "SAVE_PATTERN" ) );
aDlg->setFileMode( QFileDialog::AnyFile );
- aDlg->setFilter( tr( "PATTERN_FILT" ) );
+ aDlg->setNameFilter( tr( "PATTERN_FILT" ) );
if ( myName->text() != "" )
aDlg->selectFile( myName->text() );
if ( QFileInfo( fName ).suffix().isEmpty() )
fName = autoExtension( fName );
- fName = QDir::convertSeparators( fName );
+ fName = QDir::toNativeSeparators( fName );
QString aData( myPattern->GetString() );
long aLen = aData.length();
//aDlg->setMode(myMode == COPY_FROM ? QFileDialogP::ExistingFile : QFileDialogP::AnyFile);
aDlg->setFileMode(myMode == COPY_FROM ? QFileDialog::ExistingFile : QFileDialog::AnyFile);
- aDlg->setFilters(prepareFilters());
+ aDlg->setNameFilters(prepareFilters());
aDlg->selectFile(getFileName());
QPushButton* anOkBtn = (QPushButton*)aDlg->findChild<QPushButton*>("OK");
if (QFileInfo(fName).suffix().isEmpty())
fName = autoExtension(fName);
- fName = QDir::convertSeparators(fName);
- QString prev = QDir::convertSeparators(getFileName());
+ fName = QDir::toNativeSeparators(fName);
+ QString prev = QDir::toNativeSeparators(getFileName());
if (prev == fName)
return;
if (QFileInfo(fName).suffix().isEmpty())
fName = autoExtension(fName);
- fName = QDir::convertSeparators(fName);
+ fName = QDir::toNativeSeparators(fName);
if (QFileInfo(fName).exists()) {
isWritable = QFileInfo(fName).isWritable();
" .. ... ... ",
" .. .. .. ",
" . . "};
- return iconFirst;
+ return QPixmap( iconFirst );
}
//=================================================================================
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();
}
DumpFileDlg fd( this );
fd.setWindowTitle( tr( "SAVE_INFO" ) );
- fd.setFilters( aFilters );
+ fd.setNameFilters( aFilters );
fd.myBaseChk->setChecked( anIsBase );
fd.myElemChk->setChecked( anIsElem );
fd.myAddChk ->setChecked( anIsAdd );
DumpFileDlg fd( this );
fd.setWindowTitle( tr( "SAVE_INFO" ) );
- fd.setFilters( aFilters );
+ fd.setNameFilters( aFilters );
fd.myBaseChk->hide();
fd.myElemChk->hide();
fd.myAddChk ->hide();
SUIT_FileDlg* aDlg = new SUIT_FileDlg (this, true);
aDlg->setWindowTitle(tr("LOAD_PATTERN"));
aDlg->setFileMode(QFileDialog::ExistingFile);
- aDlg->setFilters(prepareFilters());
+ aDlg->setNameFilters(prepareFilters());
if (!myName->text().isEmpty())
aDlg->selectFile(myName->text() + ".smp");
- QPushButton* anOkBtn = qFindChild<QPushButton*>( aDlg, "OK" );
+ QPushButton* anOkBtn = aDlg->findChild<QPushButton*>( "OK" );
if (anOkBtn != 0)
anOkBtn->setText(tr("SMESH_BUT_OK"));
if (QFileInfo(fName).suffix().isEmpty())
fName = autoExtension(fName);
- fName = QDir::convertSeparators(fName);
+ fName = QDir::toNativeSeparators(fName);
- QString prev = QDir::convertSeparators(myName->text());
+ QString prev = QDir::toNativeSeparators(myName->text());
if (prev == fName)
return;
# 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}")
void GridAxisTab::onMode(int isSpacing)
{
- mySpacingTreeWdg->setShown( isSpacing );
- myCoordList->setShown( !isSpacing );
- myStepSpin->setShown( !isSpacing );
- myStepLabel->setShown( !isSpacing );
+ mySpacingTreeWdg->setVisible( isSpacing );
+ myCoordList->setVisible( !isSpacing );
+ myStepSpin->setVisible( !isSpacing );
+ myStepLabel->setVisible( !isSpacing );
if ( isSpacing )
{
if ( mySpacingTreeWdg->topLevelItemCount() == 0 )
myTable->setData( arr ); //update data in table
}
- myScale->setShown( distr==1 );
- myLScale->setShown( distr==1 );
- myReversedEdgesBox->setShown( distr!=0 );
+ myScale->setVisible( distr==1 );
+ myLScale->setVisible( distr==1 );
+ myReversedEdgesBox->setVisible( distr!=0 );
if ( myReversedEdgesHelper ) {
myReversedEdgesHelper->Clear();
- myReversedEdgesHelper->setShown( distr!=0 );
+ myReversedEdgesHelper->setVisible( distr!=0 );
}
myDirectionWidget->ShowPreview( distr!=0 );
bool isFunc = distr==2 || distr==3;
#ifndef DISABLE_PLOT2DVIEWER
- myPreview->setShown( isFunc );
+ myPreview->setVisible( isFunc );
#endif
- myConvBox->setShown( isFunc );
+ myConvBox->setVisible( isFunc );
- myTable->setShown( distr==2 );
- myExpr->setShown( distr==3 );
- myLExpr->setShown( distr==3 );
- myInfo->setShown( distr==3);
+ myTable->setVisible( distr==2 );
+ myExpr->setVisible( distr==3 );
+ myLExpr->setVisible( distr==3 );
+ myInfo->setVisible( distr==3);
#ifndef DISABLE_PLOT2DVIEWER
//change of preview
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 os, subprocess
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 string,types,os
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 string,types,os
import traceback
-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 os, subprocess
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
