- # Copyright (C) 2012-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ # Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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}_PATCH_VERSION 1)
+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)
# Various
# Python
- FIND_PACKAGE(SalomePython REQUIRED)
+ FIND_PACKAGE(SalomePythonInterp REQUIRED)
+ FIND_PACKAGE(SalomePythonLibs REQUIRED)
# PThread
FIND_PACKAGE(SalomePThread REQUIRED)
# SWIG
##
## 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})
- # Copyright (C) 2012-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ # Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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}")
- // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
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 );
- // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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 );
void GrpComputor::compute()
{
if ( !CORBA::is_nil( myGroup ) && myItem ) {
+ SUIT_OverrideCursor wc;
QTreeWidgetItem* item = myItem;
myItem = 0;
int nb = myToComputeSize ? myGroup->Size() : myGroup->GetNumberOfNodes();
{
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();
}
- // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
_CORBA_Octet* buffer = new _CORBA_Octet[real_size];
char tmp[3];
tmp[2]='\0';
- uint c = -1;
+ unsigned int c = -1;
for ( int i = 0; i < real_size; i++ )
{
memcpy( &(tmp[0]), &(theStream[i*3+1]), 2 );
- # Copyright (C) 2012-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+ # Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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}")
- # Copyright (C) 2013-2015 EDF R&D
+ # Copyright (C) 2013-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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 ---
# -*- coding: utf-8 -*-
- # Copyright (C) 2013-2015 EDF R&D
+ # Copyright (C) 2013-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# Modules Eficas
import os, subprocess
+ 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())
self.fichierIn=""
def prepareFichier(self):
- self.fichierIn="/tmp/ForMGCleaner_"+str(self.num)+".mesh"
+ self.fichierIn=tempfile.mktemp(suffix=".mesh",prefix="ForMGCleaner_")
+ if os.path.exists(self.fichierIn):
+ os.remove(self.fichierIn)
self.__selectedMesh.ExportGMF(self.__selectedMesh, self.fichierIn, True)
def PrepareLigneCommande(self):
#
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()
# -*- coding: utf-8 -*-
- # Copyright (C) 2013-2015 EDF R&D
+ # Copyright (C) 2013-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# Modules Python
- import string,types,os
+ import string,types,os,sys
+ 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 ???
cmds=''
+ '''
+ try :
+ LICENCE_FILE=os.environ["DISTENE_LICENCE_FILE_FOR_MGCLEANER"]
+ except:
+ LICENCE_FILE=''
+ try :
+ PATH=os.environ["DISTENE_PATH_FOR_MGCLEANER"]
+ except:
+ PATH=''
+ if LICENCE_FILE != '':
+ cmds+='source '+LICENCE_FILE+'\n'
+ else:
+ cmds+="# $DISTENE_LICENCE_FILE_FOR_MGCLEANER NOT SET\n"
+ if PATH != '':
+ cmds+='export PATH='+PATH+':$PATH\n'
+ else:
+ cmds+="# $DISTENE_PATH_FOR_MGCLEANER NOT SET\n"
+ #cmds+='env\n'
cmds+='rm -f '+self.parent().fichierOut+'\n'
+ '''
cmds+=txt+'\n'
cmds+='echo END_OF_MGCleaner\n'
- pid=self.monExe.pid()
- nomFichier='/tmp/MGCleaner_'+str(pid)+'.sh'
+ ext=''
+ if sys.platform == "win32":
+ ext = '.bat'
+ else:
+ ext = '.sh'
+ nomFichier=tempfile.mktemp(suffix=ext,prefix="MGCleaner_")
f=open(nomFichier,'w')
f.write(cmds)
f.close()
- maBidouille='sh ' + nomFichier
+ maBidouille=nomFichier
self.monExe.start(maBidouille)
self.monExe.closeWriteChannel()
self.enregistreResultatsDone=False
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()
# -*- coding: utf-8 -*-
- # Copyright (C) 2013-2015 EDF R&D
+ # Copyright (C) 2013-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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 :
- # Copyright (C) 2012-2015 EDF R&D
+ # Copyright (C) 2012-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
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)
- # Copyright (C) 2006-2015 EDF R&D
+ # Copyright (C) 2006-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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())]
- # Copyright (C) 2012-2015 EDF R&D
+ # Copyright (C) 2012-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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 ---
- # Copyright (C) 2012-2015 EDF R&D
+ # Copyright (C) 2012-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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 ---
# -*- coding: utf-8 -*-
- # Copyright (C) 2007-2015 EDF R&D
+ # Copyright (C) 2007-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# Modules Python
- import string,types,os
+ import string,types,os, sys
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 ???
cmds=''
- cmds+='rm -f '+self.parent().fichierOut+'\n'
+ #cmds+='#! /usr/bin/env python\n'
+ #cmds+='# -*- coding: utf-8 -*-\n'
cmds+=txt+'\n'
- cmds+='echo END_OF_Yams\n'
- pid=self.monExe.pid()
- nomFichier='/tmp/Yams_'+str(pid)+'.sh'
+ cmds+='echo "END_OF_Yams"\n'
+ if os.path.exists(self.parent().fichierOut):
+ os.remove(self.parent().fichierOut)
+
+ ext=''
+ if sys.platform == "win32":
+ ext = '.bat'
+ else:
+ ext = '.sh'
+
+ nomFichier=tempfile.mktemp(suffix=ext,prefix='Yams_')
f=open(nomFichier,'w')
f.write(cmds)
f.close()
- maBidouille='sh ' + nomFichier
+ maBidouille=nomFichier
self.monExe.start(maBidouille)
self.monExe.closeWriteChannel()
self.enregistreResultatsDone=False
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()
# -*- coding: utf-8 -*-
- # Copyright (C) 2007-2015 EDF R&D
+ # Copyright (C) 2007-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# Modules Eficas
import os, subprocess
+ 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())
self.fichierIn=""
def prepareFichier(self):
- self.fichierIn="/tmp/ForSurfOpt_"+str(self.num)+".meshb"
+ self.fichierIn=tempfile.mktemp(suffix=".meshb",prefix="ForSurfOpt_")
+ if os.path.exists(self.fichierIn):
+ os.remove(self.fichierIn)
self.__selectedMesh.ExportGMF(self.__selectedMesh, self.fichierIn, True)
def PrepareLigneCommande(self):
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()
# -*- coding: utf-8 -*-
- # Copyright (C) 2006-2015 EDF R&D
+ # Copyright (C) 2006-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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 :
- # Copyright (C) 2012-2015 EDF R&D
+ # Copyright (C) 2012-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-INCLUDE(UsePyQt4)
+INCLUDE(UsePyQt)
# --- scripts ---
__init__.py
fissureCoude_ihm.py
fissureCoude_plugin.py
+ fissureGenerale_plugin.py
dialogFissureCoude.dic
)
)
# 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)
+SALOME_INSTALL_SCRIPTS("${_pyuic_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/blocFissure/ihm)
# -*- coding: utf-8 -*-
- # Copyright (C) 2006-2015 EDF R&D
+ # Copyright (C) 2006-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
- # version 2.1 of the License.
+ # version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
import sys, traceback
import math
from blocFissure import gmu
- from blocFissure.gmu import initLog
- #initLog.setDebug()
- initLog.setVerbose()
-
- from blocFissure.gmu import geomsmesh
- from blocFissure.gmu.casStandard import casStandard
-
- from blocFissure.ihm.fissureCoude_ihm import fissureCoude_ihm
def fissureCoudeDlg(context):
# get context study, studyId, salomeGui
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(
return self.NOK
def execute(self):
+ from blocFissure.gmu import initLog
+ #initLog.setDebug()
+ initLog.setVerbose() # don't set the level too early, to be able to modify it
+ from blocFissure.gmu import geomsmesh
+ from blocFissure.gmu.casStandard import casStandard
+ from blocFissure.ihm.fissureCoude_ihm import fissureCoude_ihm
+
dico = self.creeDico()
NOK = self.testval(dico)
if not(NOK):
- # Copyright (C) 2012-2015 EDF R&D
+ # Copyright (C) 2012-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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)
# -*- coding: iso-8859-1 -*-
- # Copyright (C) 2011-2015 EDF R&D
+ # Copyright (C) 2011-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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()
# -*- coding: iso-8859-1 -*-
- # Copyright (C) 2011-2015 EDF R&D
+ # Copyright (C) 2011-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# 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_()
# -*- coding: iso-8859-1 -*-
- # Copyright (C) 2011-2015 EDF R&D
+ # Copyright (C) 2011-2016 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
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
