+# -*- coding: utf-8 -*-
+
+from Logger import ExtLogger
+
import qt
import notifqt
# -----------------------------------------------------------------------------
-import sys, os
+import sys, os, re,types
# Fin remplacement
"""
+
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,
]
import Editeur
-from Editeur import eficas
-from Editeur import splash
+try :
+ from Editeur import eficas
+ from Editeur import splash
+except :
+ from InterfaceTK import eficas
+ from InterfaceTK import splash
import salome
import meshGui
+import visuDriver
+import PALGUI_API
import studyManager
#from qxembed import QXEmbed
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"
+msgWarningGroupNoSelection = "Attention, GROUP_NO devrait prendre un point ou un noeud"
+
+
+
+
+# couleur pour visualisation des géometrie CS_CBO
+COLORS = ( studyManager.RED,
+ studyManager.GREEN,
+ studyManager.BLUE,
+ studyManager.SANDY,
+ studyManager.ORANGE,
+ studyManager.PURPLE,
+ studyManager.DARK_RED,
+ studyManager.DARK_GREEN,
+ studyManager.DARK_BLUE,
+ studyManager.YELLOW,
+ studyManager.PINK,
+ studyManager.CYAN )
+LEN_COLORS = len( COLORS )
+
+
+
+
+class SelectMainShapeDiagImpl( SelectMainShapeDiag ):
+ def __init__( self, mainShapeEntries, parent = None,name = None,modal = 1,fl = 0 ):
+ SelectMainShapeDiag.__init__( self,parent,name,modal,fl )
+
+ self.mainShapes = {} # ( entry, value )
+ for entry in mainShapeEntries:
+ name = studyManager.palStudy.getName( entry )
+ self.mainShapes[entry] = name
+
+ self.lbMainShapes.clear()
+ for entry,name in self.mainShapes.items():
+ self.lbMainShapes.insertItem( name )
+ self.lbMainShapes.setCurrentItem( 0 )
+
+
+ def getUserSelection( self ):
+ mainShapeEntry = None
+
+ item = self.lbMainShapes.selectedItem()
+ mainShapeName = str( item.text() )
+
+ for entry, name in self.mainShapes.items():
+ if mainShapeName == name:
+ mainShapeEntry = entry
+ break
+
+ return mainShapeEntry
+
+
+class SelectMeshDiagImpl( SelectMeshDiag ):
+ def __init__( self, meshGroupEntries, parent = None,name = None,modal = 1,fl = 0 ):
+ SelectMeshDiag.__init__( self,parent,name,modal,fl )
+
+ self.meshes = {} # ( entry, value )
+
+ for meshGroupEntry in meshGroupEntries:
+ meshEntry = studyManager.palStudy.getMesh(meshGroupEntry)
+ meshName = studyManager.palStudy.getName(meshEntry)
+ self.meshes[meshEntry] = meshName
+
+ self.lbMeshes.clear()
+ for entry,name in self.meshes .items():
+ self.lbMeshes.insertItem( name )
+ self.lbMeshes.setCurrentItem( 0 )
+
+ def getUserSelection( self ):
+ selMeshEntry, keep = None, False
+
+ item = self.lbMeshes.selectedItem()
+ meshName = str( item.text() )
+ for entry, name in self.meshes.items():
+ if meshName == name:
+ selMeshEntry = entry
+ break
+
+ keep = self.cbAgain.isChecked()
+
+ return selMeshEntry, keep
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, palStudyManager, code = None, fichier = None ):
+ def __init__( self, parent, code = None, fichier = None, module = studyManager.SEficas, version=None):
"""
Constructeur.
@type parent:
@param parent: widget Qt parent
-
- @type palStudyManager: studyManager.SalomeStudy
- @param palStudyManager: gestionnaire d'étude SALOME
+
@type code: string
@param code: catalogue à lancer ( ASTER, HOMARD ). optionnel ( défaut = ASTER ).
"""
#QXEmbed.__init__( self, parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
Tkinter.Toplevel.__init__( self )
-
- #---------------------------- 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
+
if Editeur.__dict__.has_key( 'session' ):
- print 'CS_pbruno has_key session'
from Editeur import session
- eficasArg = sys.argv
+ eficasArg = []
+ eficasArg += sys.argv
if fichier:
eficasArg += [ fichier ]
- session.parse( eficasArg )
+ if version:
+ eficasArg += [ "-c", version ]
+ session.parse( eficasArg )
+
+
+ #---------------------------------------- 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
- eficas.EFICAS.__init__( self, self, code = code )
- #----------------------------------------------------------------------
+ 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.initialize()
embedded.show()
embedded.embedTk( self.winfo_id() )
size = embedded.sizeHint()
- print 'CS_pbruno size (%s, %s )'%( size.width(), size.height () )
+ #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 -------------------
self.parent = parent
- self.salome = True #active les parties de code spécifique dans Salome
- self.palStudyManager = palStudyManager # gestionnaire étude SALOME
+ 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 )
- #----------------------------------------------------------------------
-
+ #----------------------------------------------------------------------
+
+ # visualisation groupes de mailles
+ self.workingMesh = {} #dictionnaire clé = identifiant JDC / valeur = entry Mesh
+ #----------------------------------------------------------------------
+
+ self.icolor = 0 # compteur pour mémoriser la couleur courante
+
def quit(self):
global appli
+ appli = None
self.destroy()
- appli = None
+
+ def destroy(self):
+ global appli
+ appli = None
+ Tkinter.Toplevel.destroy(self)
+
+ 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.
+
+ 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
+ return False
+
+ if activeStudyId != salome.myStudyId:
+ studyManager.palStudy.setCurrentStudyID( activeStudyId )
+ return True
+
+ def __createOCCView( self ):
+ """
+ Création vue Occ
+ """
+ #salome.salome_init()
+ import iparameters
- def __selectShape( self, jdcID, selectedEntry ):
+ # 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))
+ properties = ipar.getProperties()
+
+ while properties != []:
+ GUIStateID += 1
+ ipar = iparameters.IParameters(salome.myStudy.GetCommonParameters("Interface Applicative", GUIStateID))
+ properties = ipar.getProperties()
+
+ print "GUIStateID: ", GUIStateID
+
+ #Set up visual properties:
+ ipar.setProperty("AP_ACTIVE_VIEW", "OCCViewer_0_0")
+ ipar.setProperty("AP_WORKSTACK_INFO", "(splitter orientation=0 sizes=1045 (views active='OCCViewer_0_0' 'OCCViewer_0_0'))")
+ ipar.setProperty("AP_SAVEPOINT_NAME", "GUI state: %i"%(GUIStateID))
+
+ #Set up lists:
+ # fill list AP_VIEWERS_LIST
+ ipar.append("AP_VIEWERS_LIST", "OCCViewer_1")
+ # fill list OCCViewer_1
+ ipar.append("OCCViewer_1", "OCC scene:1 - viewer:1")
+ ipar.append("OCCViewer_1", "1.000000000000e+00*0.000000000000e+00*0.000000000000e+00*5.773502588272e-01*-5.773502588272e-01*5.773502588272e-01*0.000000000000e+00*0.000000000000e+00*0.000000000000e+00*0.000000000000e+00*2.886751294136e+02*-2.886751294136e+02*2.886751294136e+02")
+
+ if salome.sg.hasDesktop():
+ salome.sg.updateObjBrowser(1)
+ iparameters.getSession().restoreVisualState(GUIStateID)
+
+
+ def __selectWorkingMesh( self, meshGroupEntries ):
+ """
+ Sélection intéractive du maillage sur lequel on travail
+ """
+ selMeshEntry, keep = None, False
+ diag = SelectMeshDiagImpl( meshGroupEntries, self.parent )
+
+ if diag.exec_loop() == qt.QDialog.Accepted:
+ selMeshEntry, keep = diag.getUserSelection()
+ return selMeshEntry, keep
+
+
+
+ def __selectMainShape( self, groupeMaNamesIn, groupeNoNamesIn, jdcID ):
+ """
+ Sélection intéractive de la main shape
+ """
+ groupeMaNamesOut, groupeNoNamesOut = [], []
+ selectedMainShape = None
+ mainShapes = {}
+ mainShapeEntries = []
+
+ # liste des main shape possibles
+ for groups in ( groupeMaNamesIn, groupeNoNamesIn ):
+ for subShapeName in groups:
+ entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, subShapeName )
+ for entry in entries:
+ mainShapeEntry = studyManager.palStudy.getMainShapeEntry( entry )
+ if mainShapeEntry != entry:
+ if mainShapes.has_key(subShapeName):
+ mainShapes[ subShapeName ].append( mainShapeEntry )
+ else:
+ mainShapes[ subShapeName ] = [ mainShapeEntry ]
+ if not mainShapeEntry in mainShapeEntries:
+ mainShapeEntries += [ mainShapeEntry ]
+
+ if mainShapes:
+ if len(mainShapeEntries)>1:
+ diag = SelectMainShapeDiagImpl( mainShapeEntries, self.parent )
+
+ if diag.exec_loop() == qt.QDialog.Accepted:
+ selectedMainShape = diag.getUserSelection()
+ print 'main shape user selection ->',selectedMainShape
+
+ else:
+ selectedMainShape = mainShapeEntries[0]
+
+ self.mainShapeEntries[ jdcID ] = selectedMainShape
+
+ # filtre sur la main shape sélectionnée
+ for name in groupeMaNamesIn:
+ try:
+ if selectedMainShape in mainShapes[ name ] :
+ groupeMaNamesOut += [ name ]
+ except:
+ pass
+
+ for name in groupeNoNamesIn:
+ try:
+ if selectedMainShape in mainShapes[ name ] :
+ groupeNoNamesOut += [ name ]
+ except:
+ pass
+
+ return groupeMaNamesOut, groupeNoNamesOut
+
+
+
+
+ def __selectShape( self, jdcID, selectedEntry, kwType = None ):
"""
sélection sous-géométrie dans Salome:
- -test1) si c'est un élément géométrique.
+ -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
- """
- print 'CS_pbruno __selectShape'
- name, msgError = '',''
-
- selectedMainShapeEntry = self.palStudyManager.getMainShapeEntry( selectedEntry )
+ """
+ name, msgError = '',''
- if selectedMainShapeEntry: #ok test1)
+ selectedMainShapeEntry = studyManager.palStudy.getMainShapeEntry( selectedEntry )
+
+ if selectedMainShapeEntry and selectedMainShapeEntry != selectedEntry: #ok test1)
+
+ tGeo = studyManager.palStudy.getRealShapeType( selectedEntry )
+ if kwType == "GROUP_NO" and tGeo != studyManager.VERTEX:
+ msgError = msgWarningGroupNoSelection
+ elif kwType == "GROUP_MA" and tGeo == studyManager.VERTEX:
+ name, msgError = '', msgErrorGroupMaSelection
+ return name, msgError
+
if not self.mainShapeEntries.has_key( jdcID ):
self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
+ name = studyManager.palStudy.getName( selectedMainShapeEntry )
+ msgError = msgMainShapeSelection + name
if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
- name = self.palStudyManager.getName( selectedEntry )
- self.subShapes[ selectedEntry ] = name
- else:
- print 'CS_pbruno pas la même mainshape selectedEntry->',selectedEntry
+ name = studyManager.palStudy.getName( selectedEntry )
+ self.subShapes[ selectedEntry ] = name
+ else:
if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = self.palStudyManager.getName( self.mainShapeEntries[ jdcID ] )
- msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
+ self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName( self.mainShapeEntries[ jdcID ] )
+ msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
+ else:
+ name, msgError = '', msgErrorNeedSubShape
return name, msgError
- def __selectMeshGroup( self, jdcID, selectedEntry ):
+ def __selectMeshGroup( self, jdcID, selectedEntry, kwType = None ):
"""
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
- """
- print 'CS_pbruno __selectMeshGroup'
- name, msgError = '',''
+ """
+ name, msgError = '',''
- selectedMeshEntry = self.palStudyManager.getMesh( selectedEntry )
+ selectedMeshEntry = studyManager.palStudy.getMesh( selectedEntry )
- if selectedMeshEntry: # ok test 1)
- print 'CS_pbruno __selectMeshGroup selectedMeshEntry',selectedMeshEntry
- selectedMainShapeEntry = self.palStudyManager.getShapeFromMesh( selectedMeshEntry )
+ if selectedMeshEntry: # ok test 1)
+ tGroup = studyManager.palStudy.getGroupType( selectedEntry )
+ if kwType == "GROUP_NO" and tGroup != studyManager.NodeGroups:
+ msgError = msgWarningGroupNoSelection
+ elif kwType == "GROUP_MA" and tGroup == studyManager.NodeGroups:
+ name, msgError = '', msgErrorGroupMaSelection
+ return name, msgError
+
+ selectedMainShapeEntry = studyManager.palStudy.getShapeFromMesh( selectedMeshEntry )
- if selectedMainShapeEntry: #test 2)
- print 'CS_pbruno __selectMeshGroup selectedMainShapeEntry',selectedMainShapeEntry
+ if selectedMainShapeEntry: #test 2)
if not self.mainShapeEntries.has_key( jdcID ):
self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
+ name = studyManager.palStudy.getName( selectedMainShapeEntry )
+ msgError = msgMainShapeSelection + name
if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
- name = self.palStudyManager.getName( selectedEntry ) #ok test 2)
- else:
- print 'CS_pbruno pas la même mainshape selectedEntry ->',selectedEntry
+ name = studyManager.palStudy.getName( selectedEntry ) #ok test 2)
+ else:
if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = self.palStudyManager.getName( self.mainShapeEntries[ jdcID ] )
- msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
-
- return name, msgError
+ self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName(
+ self.mainShapeEntries[ jdcID ] )
+ msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
+ else:
+ # 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
mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
"""
for name in groupeNames:
- entries = self.palStudyManager.getEntriesFromName( studyManager.SGeom, name )
+ entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, name )
for entry in entries:
- ok, msgError = self.__selectShape( jdcID, entry ) # filtre
- if ok:
- self.subShapes[ entry ] = name
-
+ if not self.subShapes.has_key( entry ):
+ ok, msgError = self.__selectShape( jdcID, entry ) # filtre
+ if ok:
+ self.subShapes[ entry ] = name
def __getAllGroupeMa(self, item ):
"""
groupMa = ()
try:
itemName = item.get_nom()
- #print 'CS_pbruno itemName',itemName
- if itemName == 'GROUP_MA':
+ if 'GROUP_MA' in itemName:
+ #print 'CS_pbruno itemName',itemName
itemValue = item.get_valeur()
- print 'CS_pbruno trouvé! GROUP_MA->', itemValue
if type( itemValue ) == str:
groupMa += ( itemValue , )
elif type( itemValue ) == tuple:
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
+ groupMa += ( itemValue['GROUP_MA'], )
else:
- children = item.GetSubList()
+ children = item._GetSubList()
for child in children:
groupMa += self.__getAllGroupeMa( child )
- except: # à cause de GetSubList()...
- pass
- print 'CS_pbruno groupMa',groupMa
+ except:
+ # traitement des MCLIST Pour CREA_GROUP_MA
+ try:
+ itemName = item.get_nom()
+ if 'GROUP_MA' in itemName:
+ children = item._GetSubList()
+ for child in children:
+ groupMa += self.__getAllGroupeMa( child )
+ except:
+ pass
return groupMa
"""
groupNo = ()
try:
- itemName = item.get_nom()
- print 'CS_pbruno itemName',itemName
- if itemName == 'GROUP_NO':
- itemValue = item.get_valeur()
- print 'CS_pbruno trouvé! GROUP_NO->', itemValue
+ itemName = item.get_nom()
+ if 'GROUP_NO' in itemName:
+ itemValue = item.get_valeur()
if type( itemValue ) == str:
groupNo += ( itemValue , )
elif type( itemValue ) == tuple:
groupNo += itemValue
+ 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
+ groupNo += ( itemValue['GROUP_NO'], )
else:
- children = item.GetSubList()
+ children = item._GetSubList()
for child in children:
groupNo += self.__getAllGroupeNo( child )
- except: # à cause de GetSubList()...
- pass
+ except:
+ # traitement des MCLIST Pour CREA_GROUP_NO dans DEFI_GROUP
+ try:
+ itemName = item.get_nom()
+ if 'GROUP_NO' in itemName:
+ children = item._GetSubList()
+ for child in children:
+ groupNo += self.__getAllGroupeNo( child )
+ except:
+ pass
return groupNo
+
- #----------------------- LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
- def selectGroupFromSalome( self ):
+ #----------------------- LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
+ def selectGroupFromSalome( self, kwType = 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
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
"""
- print 'CS_pbruno selectGroupFromSalome'
names, msg = [], ''
- try:
+ try:
+ atLeastOneStudy = self.__studySync()
+ if not atLeastOneStudy:
+ return names, msg
# récupère toutes les sélections de l'utilsateur dans l'arbre Salome
entries = salome.sg.getAllSelected()
- print 'CS_pbruno entries->',entries
nbEntries = len( entries )
if nbEntries >= 1:
- print 'CS_pbruno len( entries ) >= 1:'
- jdcID = self.bureau.nb.getcurselection()
+# jdcID = self.bureau.nb.getcurselection()
+ jdcID = self.bureau.JDCDisplay_courant
for entry in entries:
- if self.palStudyManager.isMeshGroup( entry ): #sélection d'un groupe de maille
- name, msg = self.__selectMeshGroup( jdcID, entry )
- elif self.palStudyManager.isShape( entry ): #sélection d'une sous-géométrie
- name, msg = self.__selectShape( jdcID, entry )
+ 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 )
else:
name, msg = '', msgUnAuthorizedSelecion
if name:
if names and len( names ) < nbEntries:
msg = msgIncompleteSelection
- except:
- pass
- salome.sg.EraseAll()
- print 'CS_pbruno selectGroupFromSalome names = ',names
+ salome.sg.EraseAll()
+ except:
+ logger.debug(50*'=')
return names, msg
"""
Ajoute le Jeu De Commande ASTER ou HOMARD dans l'arbre d'étude Salome dans la rubrique EFICAS
"""
- ok, msgError = False, ''
-
- if self.bureau.code == 'ASTER':
- ok = self.palStudyManager.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_ASTER )
- elif self.bureau.code == 'HOMARD':
- ok = self.palStudyManager.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_HOMARD )
- #ok = self.palStudyManager.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_HOMARD_CONF ) CS_pbruno ?????
- if not ok:
- msgError = msgErrorAddJdcInSalome
+ ok, msgError = False, msgErrorAddJdcInSalome
+ try:
+ atLeastOneStudy = self.__studySync()
+ if not atLeastOneStudy:
+ return ok, msgError
+
+ fileType = { 'ASTER': studyManager.FICHIER_EFICAS_ASTER,
+ 'HOMARD': studyManager.FICHIER_EFICAS_HOMARD }
+
+ folderName = { 'ASTER': 'AsterFiles',
+ 'HOMARD': 'HomardFiles' }
+
+ moduleEntry = studyManager.palStudy.addComponent(self.module)
+ itemName = re.split("/",jdcPath)[-1]
+
+ fatherEntry = studyManager.palStudy.addItem(
+ moduleEntry,
+ itemName = folderName[self.bureau.code],
+ itemIcon = "ICON_COMM_FOLDER",
+ itemType = studyManager.ASTER_FILE_FOLDER,
+ bDoublonCheck = True )
+
+ commEntry = studyManager.palStudy.addItem( fatherEntry ,
+ itemName = itemName,
+ itemType = fileType[ self.bureau.code ],
+ itemValue = jdcPath,
+ itemComment = str( jdcPath ),
+ itemIcon = "ICON_COMM_FILE",
+ bDoublonCheck = True )
+ studyManager.palStudy.refresh()
+ print 'addJdcInSalome commEntry->', commEntry
+ if commEntry:
+ ok, msgError = True, ''
+ except:
+ logger.debug(50*'=')
return ok, msgError
def createOrUpdateMesh( self ):
- """
+ """
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.
- """
+ """
+ try:
+ atLeastOneStudy = self.__studySync()
+ if not atLeastOneStudy:
+ return
- jdcID = self.bureau.nb.getcurselection()
+# 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 )
+ groupeNoNames = self.__getAllGroupeNo( self.bureau.JDCDisplay_courant.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
# mise à jours de la liste des sous-géométrie ( self.subShapes )
- self.__updateSubShapes( jdcID, groupeMaNames )
- self.__updateSubShapes( jdcID, groupeNoNames )
-
+ 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 )
+
+ if groupeMaNames or groupeNoNames:
+ print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
+ print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
+ self.__updateSubShapes( jdcID, groupeMaNames + groupeNoNames )
+
+ # recupération des identifiants( entries ) associés aux noms des groupes
+ groupeMaEntries = []
+ groupeNoEntries = []
+
+ for entry, name in self.subShapes.items():
+ if name in groupeMaNames:
+ groupeMaEntries.append( entry )
+ if name in groupeNoNames:
+ groupeNoEntries.append( entry )
+
+ if groupeMaEntries or groupeNoEntries:
+ diag = meshGui.MeshUpdateDialogImpl(
+ self.mainShapeEntries[jdcID],
+ groupeMaEntries,
+ groupeNoEntries,
+ studyManager.palStudy,
+ self.parent )
+ diag.show()
+
+ self.subShapes.clear()
+ self.mainShapeNames.clear()
+ self.mainShapeEntries.clear()
+ except:
+ logger.debug(50*'=')
+
+
+ def displayMeshGroups(self, meshGroupName):
+ """
+ visualisation group de maille de nom meshGroupName dans salome
+ """
+ ok, msgError = False, ''
+ try:
+ sg = salome.ImportComponentGUI('SMESH')
+ currentjdcID = self.bureau.nb.getcurselection()
+ meshGroupEntries = []
+ selMeshEntry = None
+ selMeshGroupEntry = None
- # recupération des identifiants( entries ) associés aux noms des groupes
- groupeMaEntries = []
- groupeNoEntries = []
+ # liste des groupes de maille de nom meshGroupName
+ listSO = studyManager.palStudy._myStudy.FindObjectByName(meshGroupName, "SMESH")
+ print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
- for entry, name in self.subShapes.items():
- if name in groupeMaNames:
- groupeMaEntries.append( entry )
- if name in groupeNoNames:
- groupeNoEntries.append( entry )
-
-
- print 'CS_pbruno groupeMaEntries ->',groupeMaEntries
- print 'CS_pbruno groupeNoEntries ->',groupeNoEntries
- if groupeMaEntries or groupeNoEntries:
- print 'if groupeMaEntries or groupeNoEntries:'
- diag = meshGui.MeshUpdateDialogImpl( self.mainShapeEntries[jdcID], groupeMaEntries, groupeNoEntries, self.palStudyManager,
- self.parent )
- diag.show()
-
+ if len(listSO)>0:
+ for SObjet in listSO:
+ groupEntry = SObjet.GetID()
+ meshGroupEntries += [groupEntry]
+
+ if len(meshGroupEntries)>1:
+ # choix d'un maillage
+ 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
+ selMeshEntry = self.workingMesh[currentjdcID]
+
+ # le groupe de maille est il ds ce maillage?
+ lselMeshEntry = len(selMeshEntry)
+ for groupEntry in meshGroupEntries:
+ if selMeshEntry == groupEntry[0:lselMeshEntry]:
+ selMeshGroupEntry = groupEntry
+ break
+
+ else:
+ selMeshGroupEntry = meshGroupEntries[0]
+
+ # on affiche le groupe ds la vue VTK
+ if selMeshGroupEntry:
+ #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 )
+ sg.CreateAndDisplayActor(selMeshGroupEntry)
+ salome.sg.Display(selMeshGroupEntry)
+ salome.sg.FitAll()
+ ok = True
+ except:
+ msgError = msgErrorDisplayMeshGroup
+ logger.debug(50*'=')
+ return ok, msgError
+
+
def displayShape( self, shapeName ):
"""
visualisation géométrie de nom shapeName dans salome
"""
- ok, msgError = False, ''
- salome.sg.EraseAll()
- print 'displayShapestrGeomShape shapeName -> ', shapeName
- ok = self.palStudyManager.displayShapeByName( shapeName )
- if not ok:
- msgError = msgErrorDisplayShape
+ ok, msgError = False, ''
+ try:
+ import VISU
+ import visu_gui
+ currentViewType = None
+ m = visu_gui.myVisu.GetViewManager()
+ v = m.GetCurrentView()
+ if v:
+ currentViewType = v.GetType()
+
+ atLeastOneStudy = self.__studySync()
+ if not atLeastOneStudy:
+ return ok, msgError
+
+ #salome.sg.EraseAll()
+ print 'displayShapestrGeomShape shapeName -> ', shapeName
+
+ if currentViewType == VISU.TVIEW3D: # maillage
+ print 'Vue courante = VTK : affichage groupe de maille'
+ ok, msgError = self.displayMeshGroups(shapeName)
+ else: #geometrie
+ print 'Vue courante = OCC : affichage element geometrique'
+ #self.__createOCCView()
+ current_color = COLORS[ self.icolor % LEN_COLORS ]
+ ok = studyManager.palStudy.displayShapeByName( shapeName, current_color )
+ salome.sg.FitAll()
+ self.icolor = self.icolor + 1
+ if not ok:
+ msgError = msgErrorDisplayShape
+ except:
+ logger.debug(50*'=')
return ok, msgError
print "fin crreConfigTxt"
"""
pass #CS_pbruno à implémenter
+
+
+ def buildCabriGeom( self, name, **param ):
+ """
+ visualisation dans GEOM d'une géométrie CABRI
+ """
+ import cabri
+ qt.QApplication.setOverrideCursor( qt.QCursor.waitCursor )
+ cabri.tetra( name, **param )
+ qt.QApplication.restoreOverrideCursor()
-
-
-
+
+#-------------------------------------------------------------------------------------------------------
+# Pilotage de la Visu des elements de structures
+#
+
+ def envoievisu(self,liste_commandes):
+ #try:
+ if ( 1 == 1 ):
+ atLeastOneStudy = self.__studySync()
+ if not atLeastOneStudy:
+ return
+ monDriver=visuDriver.visuDriver(studyManager.palStudy,liste_commandes)
+ monId = monDriver.analyse()
+ PALGUI_API.displaySE(monId)
+
+ else:
+ #except:
+ print "boum dans envoievisu"
+
+
+#-------------------------------------------------------------------------------------------------------
+# Point d'entree lancement EFICAS
+#
+def runEficas( code="ASTER", fichier=None, module = studyManager.SEficas, version=None ):
+ global appli
+ if not appli: #une seul instance possible!
+ appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier, module = module, version=version )
-#def runEficas( palStudyManager, code="ASTER", fichier=None, studyId=None):
-def runEficas( parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.palStudy, code="ASTER", fichier=None ):
+
+# pour compatibilitee
+def runHomard( code="HOMARD", fichier=None ):
global appli
if not appli: #une seul instance possible!
- appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
+ appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier )
-
-def runHomard( parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.palStudy, code="HOMARD", fichier=None ):
- global appli
- if not appli: #une seul instance possible!
- appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
+
"""
def runAster(parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.palStudy, code="ASTER", fichier=None ) :
global appli
root = Tkinter.Tk()
root.withdraw()
-appli = None
+appli = None
+logger=ExtLogger( "eficasSalome.py" )
-"""
- #embedded.showMaximized()
- #embedded.embed( appli.winfo_id() )
-
- embedded.setWFlags( qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
- embedded.setFocus()
-
- if embedded.hasFocus () :
- print 'hasfocus'
- else:
- print 'pas focus'
-
-
- if embedded.isFocusEnabled():
- print 'isFocusEnabled()'
- else:
- print 'not isFocusEnabled()'
-
- focusP = embedded.focusPolicy()
-
- if focusP == qt.QWidget.TabFocus:
- print 'qt.QWidgetTabFocus'
- elif focusP == qt.QWidget.ClickFocus:
- print 'qt.ClickFocus'
- elif focusP == qt.QWidget.StrongFocus:
- print 'qt.StrongFocus'
- elif focusP == qt.QWidget.WheelFocus:
- print 'qt.WheelFocus'
- elif focusP == qt.QWidget.NoFocus:
- print 'qt.NoFocus'
- else:
- print 'bizarre'
-
- embedded.grabKeyboard()
- """
\ No newline at end of file
