--- /dev/null
+#
+# PLEASE DO NOT MODIFY configure.in FILE
+#
+# ALL CHANGES WILL BE DISCARDED BY THE NEXT
+# build_configure COMMAND
+#
+# CHANGES MUST BE MADE IN configure.in.base FILE
+#
+#
+# Author : Marc Tajchman (CEA)
+# Date : 28/06/2001
+# Modified by : Patrick GOLDBRONN (CEA)
+# Modified by : Marc Tajchman (CEA)
+#
+# Created from configure.in.base
+#
+
+AC_INIT(src)
+AC_CONFIG_AUX_DIR(${KERNEL_ROOT_DIR}/salome_adm/unix/config_files/DEPRECATED)
+AC_CANONICAL_HOST
+
+PACKAGE=salome
+AC_SUBST(PACKAGE)
+
+VERSION=3.2.3
+XVERSION=0x030203
+AC_SUBST(VERSION)
+AC_SUBST(XVERSION)
+
+# set up MODULE_NAME variable for dynamic construction of directories (resources, etc.)
+MODULE_NAME=eficas
+AC_SUBST(MODULE_NAME)
+
+dnl
+dnl Initialize source and build root directories
+dnl
+
+ROOT_BUILDDIR=`pwd`
+ROOT_SRCDIR=`echo $0 | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
+cd $ROOT_SRCDIR
+ROOT_SRCDIR=`pwd`
+cd $ROOT_BUILDDIR
+
+AC_SUBST(ROOT_SRCDIR)
+AC_SUBST(ROOT_BUILDDIR)
+
+echo
+echo Source root directory : $ROOT_SRCDIR
+echo Build root directory : $ROOT_BUILDDIR
+echo
+echo
+
+if test -z "$AR"; then
+ AC_CHECK_PROGS(AR,ar xar,:,$PATH)
+fi
+AC_SUBST(AR)
+
+dnl Export the AR macro so that it will be placed in the libtool file
+dnl correctly.
+export AR
+
+echo
+echo ---------------------------------------------
+echo testing make
+echo ---------------------------------------------
+echo
+
+AC_PROG_MAKE_SET
+AC_PROG_INSTALL
+dnl
+dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + pour les librairies dynamiques !
+
+AC_ENABLE_DEBUG(yes)
+AC_DISABLE_PRODUCTION
+
+echo ---------------------------------------------
+echo testing libtool
+echo ---------------------------------------------
+
+dnl first, we set static to no!
+dnl if we want it, use --enable-static
+AC_ENABLE_STATIC(no)
+
+AC_LIBTOOL_DLOPEN
+AC_PROG_LIBTOOL
+
+dnl Fix up the INSTALL macro if it s a relative path. We want the
+dnl full-path to the binary instead.
+case "$INSTALL" in
+ *install-sh*)
+ INSTALL='\${KERNEL_ROOT_DIR}'/salome_adm/unix/config_files/DEPRECATED/install-sh
+ ;;
+esac
+
+echo
+echo ---------------------------------------------
+echo testing python
+echo ---------------------------------------------
+echo
+
+CHECK_PYTHON
+
+echo
+echo ---------------------------------------------
+echo testing omniORB
+echo ---------------------------------------------
+echo
+
+CHECK_OMNIORB
+
+echo
+echo ---------------------------------------------
+echo default ORB : omniORB
+echo ---------------------------------------------
+echo
+
+DEFAULT_ORB=omniORB
+CHECK_CORBA
+
+AC_SUBST_FILE(CORBA)
+corba=make_$ORB
+CORBA=adm_local/unix/$corba
+
+
+echo
+echo ---------------------------------------------
+echo Testing pyqt
+echo ---------------------------------------------
+echo
+
+CHECK_PYQT
+
+echo
+echo ---------------------------------------------
+echo Testing Kernel
+echo ---------------------------------------------
+echo
+
+CHECK_KERNEL
+
+echo
+echo ---------------------------------------------
+echo Testing GUI
+echo ---------------------------------------------
+echo
+
+CHECK_SALOME_GUI
+
+echo
+echo ---------------------------------------------
+echo testing msg2qm
+echo ---------------------------------------------
+echo
+
+CHECK_MSG2QM
+
+echo
+echo ---------------------------------------------
+echo Testing Pal
+echo ---------------------------------------------
+echo
+
+CHECK_PAL
+
+echo
+echo ---------------------------------------------
+echo Testing Visu
+echo ---------------------------------------------
+echo
+
+CHECK_VISU
+echo
+echo ---------------------------------------------
+echo Summary
+echo ---------------------------------------------
+echo
+
+echo Configure
+variables="python_ok threads_ok OpenGL_ok qt_ok omniORB_ok Kernel_ok SalomeGUI_ok msg2qm_ok"
+
+for var in $variables
+do
+ printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
+ eval echo \$$var
+done
+
+echo
+echo "Default ORB : $DEFAULT_ORB"
+echo
+
+echo
+echo ---------------------------------------------
+echo RunTime Dependencies
+echo ---------------------------------------------
+echo
+variables="Visu_ok pal_ok"
+
+for var in $variables
+do
+ printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
+ eval echo \$$var
+done
+
+
+
+dnl generals files which could be included in every makefile
+
+AC_SUBST_FILE(COMMENCE) COMMENCE=adm_local/unix/make_commence
+AC_SUBST_FILE(CONCLUDE) CONCLUDE=salome_adm/unix/make_conclude
+AC_SUBST_FILE(MODULE) MODULE=salome_adm/unix/make_module
+
+dnl les dependences
+AC_SUBST_FILE(DEPEND) DEPEND=salome_adm/unix/depend
+
+dnl We don t need to say when we re entering directories if we re using
+dnl GNU make becuase make does it for us.
+if test "X$GMAKE" = "Xyes"; then
+ AC_SUBST(SETX) SETX=":"
+else
+ AC_SUBST(SETX) SETX="set -x"
+fi
+
+# make other build directories
+for rep in salome_adm adm_local doc bin/salome include/salome lib/salome share/salome/resources/${MODULE_NAME} share/salome/doc idl
+do
+# if test ! -d $rep ; then
+# eval mkdir $rep
+# fi
+ $INSTALL -d $rep
+done
+
+echo
+echo ---------------------------------------------
+echo copying resource files, shell scripts, and
+echo xml files
+echo ---------------------------------------------
+echo
+
+
+dnl copy resources directories
+
+#for i in `find $ROOT_SRCDIR -name 'resources' -print`
+#do
+# local_res=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
+# local_res_dir=`echo $local_res | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
+# mkdir -p $local_res_dir
+# cd $local_res_dir
+# ln -fs $i
+# echo $local_res
+# cd $ROOT_BUILDDIR
+#done
+
+dnl copy shells and utilities contained in the bin directory
+dnl excluding .in files (treated in AC-OUTPUT below) and CVS
+dnl directory
+
+cd bin
+for i in $ROOT_SRCDIR/bin/*
+do
+ local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
+ case "$local_bin" in
+ *.in | *~) ;;
+ ./bin/CVS) ;;
+ *) ln -fs $i; echo $local_bin ;;
+ esac
+done
+cd $ROOT_BUILDDIR
+
+AC_SUBST_FILE(ENVSCRIPT) ENVSCRIPT=salome_adm/unix/envScript
+
+dnl copy xml files to the build tree (lib directory)
+dnl pourquoi ????
+
+#cd lib
+#for i in `find $ROOT_SRCDIR -name "*.xml" -print`
+#do
+# ln -fs $i
+# echo `echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
+#done
+#cd $ROOT_BUILDDIR
+
+
+echo
+echo ---------------------------------------------
+echo generating Makefiles and configure files
+echo ---------------------------------------------
+echo
+
+AC_OUTPUT_COMMANDS([ \
+ chmod +x ./bin/* \
+])
+
+## do not delete this line
+
+ln -fs ${KERNEL_ROOT_DIR}/salome_adm ${ROOT_SRCDIR}
+
+AC_OUTPUT([ \
+ ./salome_adm/unix/SALOMEconfig.h \
+ ./salome_adm/unix/F77config.h \
+ ./salome_adm/unix/sstream \
+ ./salome_adm/unix/depend \
+ ./adm_local/unix/make_omniorb \
+ ./salome_adm/unix/envScript \
+ ./adm_local/unix/make_commence \
+ ./salome_adm/unix/make_conclude \
+ ./salome_adm/unix/make_module \
+ ./Makefile \
+ ./doc/Makefile \
+ ./idl/Makefile \
+ ./src/Makefile \
+ ./src/CONFIG/Makefile \
+ ./src/EFICAS/Makefile \
+ ./src/EFICASGUI/Makefile \
+ ./src/STUDY/Makefile \
+])
+
# -*- coding: utf-8 -*-
from Logger import ExtLogger
+logger=ExtLogger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
-import qt
-import notifqt
# -----------------------------------------------------------------------------
import sys, os, re,types
import eficasConfig
-sys.path[:0]=[os.path.join( eficasConfig.eficasPath,'Aster'),
- os.path.join( eficasConfig.eficasPath,'Homard'),
- os.path.join( eficasConfig.eficasPath,'InterfaceTK'),
- os.path.join( eficasConfig.eficasPath,'Editeur'),
- eficasConfig.eficasPath,
- ]
+# __GBO__ lignes de path ajoutées pour accéder aux packages python du
+# logiciel Eficas. Le package Aster est ajouté explicitement pour
+# accéder au module prefs.py. A FAIRE: il convient plutôt de packager
+# Eficas pour que le chargement de prefs puisse se faire sans cette
+# adaptation (ex: faire un prefs.py chapeau qui aiguille entre les
+# prefs spécifiques Aster ou Openturn).
+sys.path[:0]=[eficasConfig.eficasPath,
+ os.path.join( eficasConfig.eficasPath,'Aster')
+ ]
+
+#sys.path[:0]=[os.path.join( eficasConfig.eficasPath,'Aster'),
+# os.path.join( eficasConfig.eficasPath,'Homard'),
+# # __GBO__ os.path.join( eficasConfig.eficasPath,'InterfaceQT'),
+# os.path.join( eficasConfig.eficasPath,'Openturns'),
+# os.path.join( eficasConfig.eficasPath,'Editeur'),
+# eficasConfig.eficasPath,
+# ]
-import Tkinter
# mode de lancement Eficas
ASTER = "ASTER"
HOMARD = "HOMARD"
+OPENTURNS = "OPENTURNS"
import Editeur
-try :
- from Editeur import eficas
- from Editeur import splash
-except :
- from InterfaceTK import eficas
- from InterfaceTK import splash
+import qt
+from InterfaceQT import qtEficas
import salome
import meshGui
-import visuDriver
import PALGUI_API
-import studyManager
-#from qxembed import QXEmbed
+# __MEM_GBO: Pour mémoire, on préfère importer visuDriver après
+# studyManager car le premier dépend du second. Cependant, le problème
+# est résolu à sa source: le fichier visuDriver importe le
+# studyManager. Ainsi, il n'est plus nécessaire de se préoccuper
+# explicitement de l'ordre des import.
+import studyManager
+import visuDriver
import SalomePyQt
-
from SelectMainShapeDiag_ui import SelectMainShapeDiag
from SelectMeshDiag_ui import SelectMeshDiag
# message utilisateur
msgWarning = "Attention"
-msgMainShapeSelection = "On travaille sur la géométrie principale : "
-msgSubShapeBadMainShape = "La sélection géométrique SALOME ne correspond pas à une sous-géométrie de la géométrie principale : "
-msgMeshGroupBadMainShape = "Le groupe de maillage sélectionné dans SALOME ne référence pas la bonne géométrie principale : "
-msgIncompleteSelection = "Tous les éléments de la sélection SALOME n'ont pu étre ajoutée"
-msgUnAuthorizedSelecion = "Sélection SALOME non authorisé. Autorisé : sous-géométrie, groupe de maille"
-msgErrorAddJdcInSalome = "Erreur dans l'export du fichier de commande dans l'arbre d'étude Salome"
-msgErrorDisplayShape = "Erreur dans l'affichage de la forme géométrique sélectionnée"
-msgErrorDisplayMeshGroup = "Erreur dans l'affichage du groupe de maillage sélectionné"
-msgErrorNeedSubShape = "Sélection d'un élément sous géométrique seulement"
-
-
-msgErrorGroupMaSelection = "Sélection GROUP_MA ne peut pas prendre un point ou un noeud"
+msgMainShapeSelection = "On travaille sur la géométrie principale : "
+msgSubShapeBadMainShape = "La sélection géométrique SALOME ne correspond pas à une sous-géométrie de la géométrie principale : "
+msgMeshGroupBadMainShape = "Le groupe de maillage sélectionné dans SALOME ne référence pas la bonne géométrie principale : "
+msgIncompleteSelection = "Tous les éléments de la sélection SALOME n'ont pu étre ajoutée"
+msgUnAuthorizedSelecion = "Sélection SALOME non authorisé. Autorisé : sous-géométrie, groupe de maille"
+msgErrorAddJdcInSalome = "Erreur dans l'export du fichier de commande dans l'arbre d'étude Salome"
+msgErrorDisplayShape = "Erreur dans l'affichage de la forme géométrique sélectionnée"
+msgErrorDisplayMeshGroup = "Erreur dans l'affichage du groupe de maillage sélectionné"
+msgErrorNeedSubShape = "Sélection d'un élément sous géométrique seulement"
+
+
+msgErrorGroupMaSelection = "Sélection GROUP_MA ne peut pas prendre un point ou un noeud"
msgWarningGroupNoSelection = "Attention, GROUP_NO devrait prendre un point ou un noeud"
-# couleur pour visualisation des géometrie CS_CBO
+# couleur pour visualisation des géometrie CS_CBO
COLORS = ( studyManager.RED,
studyManager.GREEN,
studyManager.BLUE,
-
-#class MyEficas( Tkinter.Toplevel, eficas.EFICAS, QXEmbed ):
-class MyEficas( Tkinter.Toplevel, eficas.EFICAS ):
+class MyEficas( qtEficas.Appli ):
"""
Classe de lancement du logiciel EFICAS dans SALOME.
- Cette classe spécialise le logiciel Eficas par l'ajout de:
- a)la création de groupes de mailles dans le composant SMESH de SALOME
- b)la visualisation d'éléments géométrique dans le coposant GEOM de SALOME par sélection dans EFICAS
+ Cette classe spécialise le logiciel Eficas par l'ajout de:
+ a)la création de groupes de mailles dans le composant SMESH de SALOME
+ b)la visualisation d'éléments géométrique dans le coposant GEOM de SALOME par sélection dans EFICAS
"""
def __init__( self, parent, code = None, fichier = None, module = studyManager.SEficas, version=None):
"""
@type code: string
- @param code: catalogue à lancer ( ASTER, HOMARD ). optionnel ( défaut = ASTER ).
+ @param code: catalogue à lancer ( ASTER, HOMARD OPENTURNS ). optionnel ( défaut = ASTER ).
@type fichier: string
- @param fichier: chemin absolu du fichier eficas à ouvrir à dès le lancement. optionnel
+ @param fichier: chemin absolu du fichier eficas à ouvrir à dès le lancement. optionnel
"""
- #QXEmbed.__init__( self, parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
- Tkinter.Toplevel.__init__( self )
if Editeur.__dict__.has_key( 'session' ):
from Editeur import session
if fichier:
eficasArg += [ fichier ]
if version:
+ print version
eficasArg += [ "-c", version ]
+ else :
+ print "noversion"
session.parse( eficasArg )
+ qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent)
- #---------------------------------------- initialisation EFICAS --------------------------
- splash.init_splash( self, code = code, titre = "Lancement d'EFICAS pour %s" %code )
- splash._splash.configure( text="Chargement d'EFICAS en cours.\n Veuillez patienter ..." )
- # différence eficas 1.7 et 1.8
-
- # compatibilite 1.12
- V112=0
- try :
- from Editeur import appli
- V112=1
- except :
- pass
-
- if V112 :
- eficas.EFICAS.__init__( self, self, code = code )
- else :
- eficas.EFICAS.__init__( self, self, code = code , salome = 1)
-
-
- #---------------------------------------------------------------------------------------------
-
-
- """
- #------ embarcation dans une fenêtre qt pour mise au premier plan ---
- #embedded = QXEmbed( parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
- embedded = QXEmbed( parent, "" )
- #embedded.initialize()
- embedded.show()
- embedded.embedTk( self.winfo_id() )
- size = embedded.sizeHint()
- #print 'CS_pbruno size (%s, %s )'%( size.width(), size.height () )
- embedded.resize( size.width(), size.height () )
- embedded.setWFlags( qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
- #---------------------------------------------------------------------------------------------
- """
-
- #--------------- spécialisation EFICAS dans SALOME -------------------
+ #--------------- spécialisation EFICAS dans SALOME -------------------
self.parent = parent
- self.salome = True #active les parties de code spécifique dans Salome( pour le logiciel Eficas )
- self.module = module #indique sous quel module dans l'arbre d'étude ajouter le JDC.
+ self.salome = True #active les parties de code spécifique dans Salome( pour le logiciel Eficas )
+ self.module = module #indique sous quel module dans l'arbre d'étude ajouter le JDC.
- # donnée pour la création de groupe de maille
- self.mainShapeNames = {} #dictionnaire pour gérer les multiples fichiers possibles ouverts par
- self.mainShapeEntries = {} #eficas ( clé = identifiant du JDC ), une mainshape par fichier ouvert.
- self.subShapes = {} #dictionnaire des sous-géométrie de la géométrie principale ( clé = entry, valeur = name )
+ # donnée pour la création de groupe de maille
+ self.mainShapeNames = {} #dictionnaire pour gérer les multiples fichiers possibles ouverts par
+ self.mainShapeEntries = {} #eficas ( clé = identifiant du JDC ), une mainshape par fichier ouvert.
+ self.subShapes = {} #dictionnaire des sous-géométrie de la géométrie principale ( clé = entry, valeur = name )
#----------------------------------------------------------------------
# visualisation groupes de mailles
- self.workingMesh = {} #dictionnaire clé = identifiant JDC / valeur = entry Mesh
+ self.workingMesh = {} #dictionnaire clé = identifiant JDC / valeur = entry Mesh
#----------------------------------------------------------------------
- self.icolor = 0 # compteur pour mémoriser la couleur courante
+ self.icolor = 0 # compteur pour mémoriser la couleur courante
+ self.show()
- def quit(self):
- global appli
- appli = None
- self.destroy()
-
- def destroy(self):
+ def closeEvent(self,event):
+ import InterfaceQT.readercata
+ if hasattr(InterfaceQT.readercata,'reader') :
+ del InterfaceQT.readercata.reader
global appli
appli = None
- Tkinter.Toplevel.destroy(self)
-
+ event.accept()
+
def __studySync( self ):
"""
- IMPORTANT( à appeler préalablement à chaque appel du gestionnaire d'étude ) : spécifique au lancement de Eficas dans Salome,
- permet au gestionnaire d'étude ( studyManager.palStudy ) de pointer sur la bonne étude.
+ IMPORTANT( à appeler préalablement à chaque appel du gestionnaire d'étude ) : spécifique au lancement de Eficas dans Salome,
+ permet au gestionnaire d'étude ( studyManager.palStudy ) de pointer sur la bonne étude.
- Un retour à False indique qu'il n'y a aucune étude active, dans ce cas ne faire aucune opération avec le gestionnaire d'étude(
+ Un retour à False indique qu'il n'y a aucune étude active, dans ce cas ne faire aucune opération avec le gestionnaire d'étude(
gros plantage sinon )
"""
activeStudyId = salome.sg.getActiveStudyId()
- if activeStudyId == 0: # pas d'étude active
+ if activeStudyId == 0: # pas d'étude active
return False
if activeStudyId != salome.myStudyId:
def __createOCCView( self ):
"""
- Création vue Occ
+ Création vue Occ
"""
#salome.salome_init()
import iparameters
- # On détermine le nombre de GUI states déjà présents dans l'arbre d'étude
+ # On détermine le nombre de GUI states déjà présents dans l'arbre d'étude
GUIStateID = 1
ipar = iparameters.IParameters(salome.myStudy.GetCommonParameters("Interface Applicative", GUIStateID))
def __selectWorkingMesh( self, meshGroupEntries ):
"""
- Sélection intéractive du maillage sur lequel on travail
+ Sélection intéractive du maillage sur lequel on travail
"""
selMeshEntry, keep = None, False
diag = SelectMeshDiagImpl( meshGroupEntries, self.parent )
- def __selectMainShape( self, groupeMaNamesIn, groupeNoNamesIn, jdcID ):
+ def __selectMainShape( self, groupeMaNamesIn, groupeNoNamesIn, editor ):
"""
- Sélection intéractive de la main shape
+ Sélection intéractive de la main shape
"""
groupeMaNamesOut, groupeNoNamesOut = [], []
selectedMainShape = None
else:
selectedMainShape = mainShapeEntries[0]
- self.mainShapeEntries[ jdcID ] = selectedMainShape
+ self.mainShapeEntries[ editor ] = selectedMainShape
- # filtre sur la main shape sélectionnée
+ # filtre sur la main shape sélectionnée
for name in groupeMaNamesIn:
try:
if selectedMainShape in mainShapes[ name ] :
- def __selectShape( self, jdcID, selectedEntry, kwType = None ):
+ def __selectShape( self, editor, selectedEntry, kwType = None ):
"""
- sélection sous-géométrie dans Salome:
- -test1) si c'est un élément sous-géométrique .
- -test2) si appartient à la géométrie principale.
+ sélection sous-géométrie dans Salome:
+ -test1) si c'est un élément sous-géométrique .
+ -test2) si appartient à la géométrie principale.
- met à jours la liste self.subShapes si test ok
+ met à jours la liste self.subShapes si test ok
"""
name, msgError = '',''
name, msgError = '', msgErrorGroupMaSelection
return name, msgError
- if not self.mainShapeEntries.has_key( jdcID ):
- self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
+ if not self.mainShapeEntries.has_key( editor ):
+ self.mainShapeEntries[ editor ] = selectedMainShapeEntry
name = studyManager.palStudy.getName( selectedMainShapeEntry )
msgError = msgMainShapeSelection + name
- if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
+ if selectedMainShapeEntry == self.mainShapeEntries[ editor ]:
name = studyManager.palStudy.getName( selectedEntry )
self.subShapes[ selectedEntry ] = name
else:
- if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName( self.mainShapeEntries[ jdcID ] )
- msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
+ if not self.mainShapeNames.has_key( editor ):
+ self.mainShapeNames[ editor ] = studyManager.palStudy.getName( self.mainShapeEntries[ editor ] )
+ msgError = msgSubShapeBadMainShape + self.mainShapeNames[ editor ]
else:
name, msgError = '', msgErrorNeedSubShape
- def __selectMeshGroup( self, jdcID, selectedEntry, kwType = None ):
+ def __selectMeshGroup( self, editor, selectedEntry, kwType = None ):
"""
- sélection groupe de maille dans Salome:
+ sélection groupe de maille dans Salome:
-test 1) si c'est un groupe de maille
- -test 2) si le maillage fait référence à la géométrie principale
+ -test 2) si le maillage fait référence à la géométrie principale
"""
name, msgError = '',''
selectedMainShapeEntry = studyManager.palStudy.getShapeFromMesh( selectedMeshEntry )
if selectedMainShapeEntry: #test 2)
- if not self.mainShapeEntries.has_key( jdcID ):
- self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
+ if not self.mainShapeEntries.has_key( editor ):
+ self.mainShapeEntries[ editor ] = selectedMainShapeEntry
name = studyManager.palStudy.getName( selectedMainShapeEntry )
msgError = msgMainShapeSelection + name
- if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
+ if selectedMainShapeEntry == self.mainShapeEntries[ editor ]:
name = studyManager.palStudy.getName( selectedEntry ) #ok test 2)
else:
- if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName(
- self.mainShapeEntries[ jdcID ] )
- msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
+ if not self.mainShapeNames.has_key( editor ):
+ self.mainShapeNames[ editor ] = studyManager.palStudy.getName(
+ self.mainShapeEntries[ editor ] )
+ msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ editor ]
else:
- # on authorise quand même les groupes de maillage ne faisant
- # pas référence à une géométrie principale (dixit CS_CBO )
+ # on authorise quand même les groupes de maillage ne faisant
+ # pas référence à une géométrie principale (dixit CS_CBO )
name = studyManager.palStudy.getName( selectedEntry )
return name, msgError
- def __updateSubShapes( self, jdcID, groupeNames ):
+ def __updateSubShapes( self, editor, groupeNames ):
"""
- mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
+ mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
"""
for name in groupeNames:
entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, name )
for entry in entries:
if not self.subShapes.has_key( entry ):
- ok, msgError = self.__selectShape( jdcID, entry ) # filtre
+ ok, msgError = self.__selectShape( editor, entry ) # filtre
if ok:
self.subShapes[ entry ] = name
def __getAllGroupeMa(self, item ):
"""
- Récupère tous les GROUPE_MA dans le JDC courant
+ Récupère tous les GROUPE_MA dans le JDC courant
"""
groupMa = ()
try:
+ #if 1 :
itemName = item.get_nom()
if 'GROUP_MA' in itemName:
- #print 'CS_pbruno itemName',itemName
itemValue = item.get_valeur()
if type( itemValue ) == str:
groupMa += ( itemValue , )
elif type( itemValue ) == list:
groupMa += tuple(itemValue)
elif type( itemValue ) == types.InstanceType and itemValue.has_key('GROUP_MA'):
- # pour créer le groupe de mailles dans DEFI_GROUP> CREA_GROUP_MA> GROUP_MA
+ # pour créer le groupe de mailles dans DEFI_GROUP> CREA_GROUP_MA> GROUP_MA
groupMa += ( itemValue['GROUP_MA'], )
+ else :
+ # sert pour DEFI_GROUP_MA / UNION
+ mc=item.get_definition()
+ if type( mc ) == types.InstanceType :
+ children = item._GetSubList()
+ for child in children:
+ try :
+ if 'grma' in repr(child.get_definition().type[0]) :
+ val=tuple(child.get_valeur())
+ groupMa += val
+ except :
+ pass
else:
children = item._GetSubList()
for child in children:
groupMa += self.__getAllGroupeMa( child )
except:
+ #else :
# traitement des MCLIST Pour CREA_GROUP_MA
try:
itemName = item.get_nom()
def __getAllGroupeNo(self, item ):
"""
- Récupère tous les GROUPE_NO dans le JDC courant
+ Récupère tous les GROUPE_NO dans le JDC courant
"""
groupNo = ()
try:
elif type( itemValue ) == list:
groupNo += tuple(itemValue)
elif type( itemValue ) == types.InstanceType and itemValue.has_key('GROUP_NO'):
- # pour créer le groupe de Noeuds dans DEFI_GROUP> CREA_GROUP_NO> GROUP_NO
+ # pour créer le groupe de Noeuds dans DEFI_GROUP> CREA_GROUP_NO> GROUP_NO
groupNo += ( itemValue['GROUP_NO'], )
else:
children = item._GetSubList()
#----------------------- LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
- def selectGroupFromSalome( self, kwType = None):
+ def selectGroupFromSalome( self, kwType = None, editor=None):
"""
- Sélection d'élément(s) d'une géométrie ( sub-shape ) ou d'élément(s) de maillage ( groupe de maille) à partir de l'arbre salome
+ Sélection d'élément(s) d'une géométrie ( sub-shape ) ou d'élément(s) de maillage ( groupe de maille) à partir de l'arbre salome
retourne ( la liste des noms des groupes, message d'erreur )
- Note: Appelé par EFICAS lorsqu'on clique sur le bouton ajouter à la liste du panel AFF_CHAR_MECA
+ Note: Appelé par EFICAS lorsqu'on clique sur le bouton ajouter à la liste du panel AFF_CHAR_MECA
"""
names, msg = [], ''
try:
+ self.editor=editor
atLeastOneStudy = self.__studySync()
if not atLeastOneStudy:
return names, msg
- # récupère toutes les sélections de l'utilsateur dans l'arbre Salome
+ # récupère toutes les sélections de l'utilsateur dans l'arbre Salome
entries = salome.sg.getAllSelected()
nbEntries = len( entries )
if nbEntries >= 1:
-# jdcID = self.bureau.nb.getcurselection()
- jdcID = self.bureau.JDCDisplay_courant
for entry in entries:
- if studyManager.palStudy.isMeshGroup( entry ): #sélection d'un groupe de maille
- name, msg = self.__selectMeshGroup( jdcID, entry, kwType )
- elif studyManager.palStudy.isShape( entry ): #sélection d'une sous-géométrie
- name, msg = self.__selectShape( jdcID, entry, kwType )
+ if studyManager.palStudy.isMeshGroup( entry ): #sélection d'un groupe de maille
+ name, msg = self.__selectMeshGroup( editor, entry, kwType )
+ elif studyManager.palStudy.isShape( entry ): #sélection d'une sous-géométrie
+ name, msg = self.__selectShape( editor, entry, kwType )
else:
name, msg = '', msgUnAuthorizedSelecion
if name:
if names and len( names ) < nbEntries:
msg = msgIncompleteSelection
- salome.sg.EraseAll()
except:
- logger.debug(50*'=')
+ logger.debug("selectGroupFromSalome: An error occurs")
return names, msg
def addJdcInSalome( self, jdcPath ):
"""
- Ajoute le Jeu De Commande ASTER ou HOMARD dans l'arbre d'étude Salome dans la rubrique EFICAS
+ Ajoute le Jeu De Commande ASTER ou HOMARD dans l'arbre d'étude Salome dans la rubrique EFICAS
"""
ok, msgError = False, msgErrorAddJdcInSalome
- try:
+ #try:
+ if 1:
atLeastOneStudy = self.__studySync()
if not atLeastOneStudy:
return ok, msgError
- fileType = { 'ASTER': studyManager.FICHIER_EFICAS_ASTER,
- 'HOMARD': studyManager.FICHIER_EFICAS_HOMARD }
+ fileType = { 'ASTER' : studyManager.FICHIER_EFICAS_ASTER,
+ 'HOMARD' : studyManager.FICHIER_EFICAS_HOMARD ,
+ 'OPENTURNS': studyManager.FICHIER_EFICAS_OPENTURNS}
- folderName = { 'ASTER': 'AsterFiles',
- 'HOMARD': 'HomardFiles' }
+ folderName = { 'ASTER' : 'AsterFiles',
+ 'HOMARD' : 'HomardFiles' ,
+ 'OPENTURNS': 'OpenturnsFiles'}
+
+ folderType = { 'ASTER': studyManager.ASTER_FILE_FOLDER,
+ 'HOMARD': studyManager.ASTER_FILE_FOLDER,
+ 'OPENTURNS': studyManager.OPENTURNS_FILE_FOLDER
+ }
+
moduleEntry = studyManager.palStudy.addComponent(self.module)
itemName = re.split("/",jdcPath)[-1]
fatherEntry = studyManager.palStudy.addItem(
moduleEntry,
- itemName = folderName[self.bureau.code],
+ itemName = folderName[self.code],
itemIcon = "ICON_COMM_FOLDER",
- itemType = studyManager.ASTER_FILE_FOLDER,
+ itemType = folderType[self.code],
bDoublonCheck = True )
commEntry = studyManager.palStudy.addItem( fatherEntry ,
itemName = itemName,
- itemType = fileType[ self.bureau.code ],
+ itemType = fileType[ self.code ],
itemValue = jdcPath,
itemComment = str( jdcPath ),
itemIcon = "ICON_COMM_FILE",
print 'addJdcInSalome commEntry->', commEntry
if commEntry:
ok, msgError = True, ''
- except:
+ #except:
logger.debug(50*'=')
return ok, msgError
- def createOrUpdateMesh( self ):
+ def createOrUpdateMesh( self, editor ):
"""
Ouverture d'une boite de dialogue : Creation de groupes de mailles dans un maillage existant ou un nouveau maillage.
- Note: Appelé par EFICAS à la sauvegarde du JDC.
+ Note: Appelé par EFICAS à la sauvegarde du JDC.
"""
try:
atLeastOneStudy = self.__studySync()
if not atLeastOneStudy:
return
-# jdcID = self.bureau.nb.getcurselection()
- jdcID = self.bureau.JDCDisplay_courant
-
- groupeMaNames = self.__getAllGroupeMa( self.bureau.JDCDisplay_courant.tree.item )
- groupeNoNames = self.__getAllGroupeNo( self.bureau.JDCDisplay_courant.tree.item )
+ groupeMaNames = self.__getAllGroupeMa( editor.tree.item )
+ groupeNoNames = self.__getAllGroupeNo( editor.tree.item )
# on elimine les doublons de la liste
groupeMaNames = dict.fromkeys(groupeMaNames).keys()
groupeNoNames = dict.fromkeys(groupeNoNames).keys()
- print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
- print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
+ #print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
- # mise à jours de la liste des sous-géométrie ( self.subShapes )
- if not self.mainShapeEntries.has_key( jdcID ):
- # l'utilisateur n'a sélectionné aucune sous-géométrie et donc pas de géométrie principale
- groupeMaNames, groupeNoNames = self.__selectMainShape( groupeMaNames, groupeNoNames, jdcID )
+ # mise à jours de la liste des sous-géométrie ( self.subShapes )
+ if not self.mainShapeEntries.has_key( editor ):
+ # l'utilisateur n'a sélectionné aucune sous-géométrie et donc pas de géométrie principale
+ groupeMaNames, groupeNoNames = self.__selectMainShape( groupeMaNames, groupeNoNames, editor )
if groupeMaNames or groupeNoNames:
print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
- self.__updateSubShapes( jdcID, groupeMaNames + groupeNoNames )
+ self.__updateSubShapes( editor, groupeMaNames + groupeNoNames )
- # recupération des identifiants( entries ) associés aux noms des groupes
+ # recupération des identifiants( entries ) associés aux noms des groupes
groupeMaEntries = []
groupeNoEntries = []
if groupeMaEntries or groupeNoEntries:
diag = meshGui.MeshUpdateDialogImpl(
- self.mainShapeEntries[jdcID],
+ self.mainShapeEntries[editor],
groupeMaEntries,
groupeNoEntries,
studyManager.palStudy,
ok, msgError = False, ''
try:
sg = salome.ImportComponentGUI('SMESH')
- currentjdcID = self.bureau.nb.getcurselection()
+ currentjdcID = self.editor.nb.getcurselection()
meshGroupEntries = []
selMeshEntry = None
selMeshGroupEntry = None
if len(meshGroupEntries)>1:
# choix d'un maillage
- if not self.workingMesh.has_key(currentjdcID): # aucun maillage de défini par défaut encore
+ if not self.workingMesh.has_key(currentjdcID): # aucun maillage de défini par défaut encore
#selMeshEntry = "0:1:3:5" #CS_pbruno todo : choix maillage + test si c un maillage
selMeshEntry, keep = self.__selectWorkingMesh(meshGroupEntries)
if keep:
self.workingMesh[currentjdcID] = selMeshEntry
- else: # déja un de défini par défaut
+ else: # déja un de défini par défaut
selMeshEntry = self.workingMesh[currentjdcID]
# le groupe de maille est il ds ce maillage?
# on affiche le groupe ds la vue VTK
if selMeshGroupEntry:
- #CS_pbruno: marche QUE si le module SMESH est activé
+ #CS_pbruno: marche QUE si le module SMESH est activé
myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
SCom = studyManager.palStudy._myStudy.FindComponent("SMESH")
studyManager.palStudy._myBuilder.LoadWith( SCom , myComponent )
def displayShape( self, shapeName ):
"""
- visualisation géométrie de nom shapeName dans salome
+ visualisation géométrie de nom shapeName dans salome
"""
ok, msgError = False, ''
try:
initialdir = fichier)
f=open(sauvegarde,'w+')
for unite in dico.keys():
- print unite
type=dico[unite][0]
fic=dico[unite][1:]
ligne="fort."+str(unite)+" "+type+" "+fic
f.close()
self.rangeInStudy(sauvegarde)
print "==============================="
- print "fin crreConfigTxt"
"""
- pass #CS_pbruno à implémenter
+ pass #CS_pbruno à implémenter
def buildCabriGeom( self, name, **param ):
"""
- visualisation dans GEOM d'une géométrie CABRI
+ visualisation dans GEOM d'une géométrie CABRI
"""
import cabri
qt.QApplication.setOverrideCursor( qt.QCursor.waitCursor )
qt.QApplication.restoreOverrideCursor()
-
+
#-------------------------------------------------------------------------------------------------------
# Pilotage de la Visu des elements de structures
#
+
def envoievisu(self,liste_commandes):
- #try:
- if ( 1 == 1 ):
+ import traceback
+ try:
atLeastOneStudy = self.__studySync()
if not atLeastOneStudy:
return
+ logger.debug(10*'#'+":envoievisu: creating a visuDriver instance")
monDriver=visuDriver.visuDriver(studyManager.palStudy,liste_commandes)
+
+ logger.debug(10*'#'+":envoievisu: analyse visu commandes using the visuDriver "+str(monDriver))
monId = monDriver.analyse()
+ logger.debug(10*'#'+":envoievisu: display the structural elements using PALGUI")
PALGUI_API.displaySE(monId)
-
- else:
- #except:
- print "boum dans envoievisu"
+ except:
+ traceback.print_exc()
+ logger.debug(10*'#'+":pb dans envoievisu")
# Point d'entree lancement EFICAS
#
def runEficas( code="ASTER", fichier=None, module = studyManager.SEficas, version=None ):
+ logger.debug(10*'#'+":runEficas: START")
global appli
+ logger.debug(10*'#'+":runEficas: code="+str(code))
+ logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
+ logger.debug(10*'#'+":runEficas: module="+str(module))
+ logger.debug(10*'#'+":runEficas: version="+str(version))
+
if not appli: #une seul instance possible!
appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier, module = module, version=version )
+ logger.debug(10*'#'+":runEficas: END")
+
appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
"""
-
-
-# Init globale du module
-root = Tkinter.Tk()
-root.withdraw()
-
-
appli = None
-logger=ExtLogger( "eficasSalome.py" )
-
