-import qt
-import notifqt
-# -----------------------------------------------------------------------------
-import sys, os
+# -*- coding: utf-8 -*-
+#_____________________________________
+import sys, os, re,types
+import traceback
+from PyQt5.QtWidgets import QMessageBox
+from PyQt5.QtWidgets import QApplication
-"""
-# Remplacement de la fonction exit standard par une fonction
-# qui n'interrompt pas l'execution
+from salome.kernel.logger import Logger
+logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
-sys._exit=sys.exit
-
-def exit(ier):
- print "appel de exit: ",ier
-
-
-# Fin remplacement
-"""
-
-import eficasConfig
-
-sys.path[:0]=[os.path.join( eficasConfig.eficasPath,'Aster'),
- os.path.join( eficasConfig.eficasPath,'Homard'),
+import eficasConfig
+# eficasConfig definit le EFICAS_ROOT
+# lignes de path ajoutees pour acceder aux packages python du
+# logiciel Eficas. Le package Aster est ajoute explicitement pour
+# acceder au module prefs.py. A
+# ajout de InterfaceQT4 pour permettre l acces a la fenetre Option
+sys.path[:0]=[eficasConfig.eficasPath,
os.path.join( eficasConfig.eficasPath,'Editeur'),
+ os.path.join( eficasConfig.eficasPath,'UiQT5'),
+ os.path.join( eficasConfig.eficasPath,'InterfaceQT4'),
+ #os.path.join( eficasConfig.eficasPath,'Extensions'),
eficasConfig.eficasPath,
]
-import Tkinter
-
-
-# mode de lancement Eficas
-ASTER = "ASTER"
-HOMARD = "HOMARD"
-
-
import Editeur
-from Editeur import eficas
-from Editeur import splash
+from InterfaceQT4 import qtEficas
import salome
-import meshGui
-import studyManager
-
-#from qxembed import QXEmbed
-
import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+langue=str(sgPyQt.stringSetting("language","language"))
-
-# message utilisateur
-msgWarning = "Attention"
-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"
+from salome.kernel.studyedit import getStudyEditor
+# couleur pour visualisation des geometries
+import colors
+COLORS = colors.ListeColors
+LEN_COLORS = len( COLORS )
+from Extensions import localisation
+localisation.localise(None,langue)
-#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
+ Classe de lancement du logiciel EFICAS dans SALOME
+ Cette classe specialise le logiciel Eficas par l'ajout de:
+ a)la creation de groupes de mailles dans le composant SMESH de SALOME
+ b)la visualisation d'elements geometrique dans le coposant GEOM de SALOME par selection dans EFICAS
"""
- def __init__(self, parent, palStudyManager, code = None, fichier = None ):
+ def __init__( self, parent, code = None, fichier = None, module = "EFICAS",
+ version = None, componentName = "Eficas",multi=False,lang=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 ).
-
+ @param code: catalogue a lancer
@type fichier: string
- @param fichier: chemin absolu du fichier eficas à ouvrir à dès le lancement. optionnel
+ @param fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
"""
- #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
+
+ #dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF',
+ # 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac',
+ # 'pytel' : 'pytel', 'telemac2d' : 'telemac2dSalome','coupling1d2d':'coupling1d2d',
+ # 'mascaret':'mascaret','boundary_conditions':'boundary_conditions'}
+
+ dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF',
+ 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac'}
+
+ if code in dictPathCode.keys():
+ pathCode=dictPathCode[code]
+ sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)]
+
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 )
-
- eficas.EFICAS.__init__( self, self, code = code )
- #----------------------------------------------------------------------
-
-
- """
- #------ 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 )
- #----------------------------------------------------------------------
- """
+ if version:
+ eficasArg += [ "-c", version ]
+ #else :
+ # print "noversion"
+ session.parse( eficasArg )
+
+ self.editor = getStudyEditor() # Editeur de l'arbre d'etude
+
+ if lang!=None : langue=lang
+ else : langue=str(sgPyQt.stringSetting("language","language"))
+
+ qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
- #--------------- spécialisation EFICAS dans SALOME -------------------
+ #--------------- specialisation EFICAS dans SALOME -------------------
self.parent = parent
- self.salome = True #active les parties de code spécifique dans Salome
- self.palStudyManager = palStudyManager # gestionnaire étude SALOME
-
- # 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 )
- #----------------------------------------------------------------------
-
-
- def quit(self):
- global appli
- self.destroy()
- appli = None
-
-
+ self.salome = True #active les parties de code specifique dans Salome( pour le logiciel Eficas )
+ self.module = module #indique sous quel module dans l'arbre d'etude ajouter le JDC.
+ self.componentName = componentName
+
+ # donnee pour la creation de groupe de maille
+ self.mainShapeNames = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par
+ #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.
+ #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name )
+ #----------------------------------------------------------------------
+
+ self.icolor = 0 # compteur pour memoriser la couleur courante
+ self.show()
+
+
+ def closeEvent(self,event):
+ res=self.fileExit()
+ if res==2 :
+ event.ignore()
+ return
+ if hasattr(self,'readercata') :
+ del self.readercata
+ import math
+ try:
+ import Numeric
+ except:
+ import numpy
+ Numeric = numpy
+
+ from Extensions.param2 import originalMath
+ #Numeric.cos=originalMath.numeric_ncos
+ #Numeric.sin=originalMath.numeric_nsin
+ #Numeric.array=originalMath.numeric_narray
+ #math.sin=originalMath.sin
+ #math.cos=originalMath.cos
+ #math.sqrt=originalMath.sqrt
+ #math.ceil=originalMath.ceil
+ #math.pi=originalMath.pi
+ originalMath.toOriginal()
+
+ global appli
+ appli = None
+ event.accept()
+
+
+# ___________________________ Methodes de l ex Pal __________________________________
+
+ #----------------------------------------------------------------
+ def getCORBAObjectInComponent( self, entry, composant ):
+ #----------------------------------------------------------------
+ object = None
+ mySO = self.editor.study.FindObjectID(entry)
+ if mySO:
+ object = mySO.GetObject()
+ if not object:
+ myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
+ SCom = self.editor.study.FindComponent( composant )
+ print myComponent , SCom
+ self.editor.builder.LoadWith( SCom , myComponent )
+ object = mySO.GetObject()
+ if not object :
+ logger.debug("selectedEntry: An error occurs")
+ return object
+
+
+ #----------------------------------------------
+ def giveMeshGroups( self,entry,label1,typeMesh):
+ #----------------------------------------------
+ msg=None
+ names=[]
+ import SMESH
+ try:
+ monMaillage =self.getCORBAObjectInComponent(entry,"SMESH")
+ if monMaillage != None : # selection d'un groupe de SMESH
+ if monMaillage._narrow(SMESH.SMESH_Mesh):
+ mailSO = self.editor.study.FindObjectID(entry)
+ if mailSO == None : return names, msg
+
+
+ subIt = self.editor.study.NewChildIterator(mailSO)
+ while subIt.More():
+ subSO = subIt.Value()
+ subIt.Next()
+
+ if (subSO.GetName()[0:9]!=label1) : continue
+ subSSMeshit=self.editor.study.NewChildIterator(subSO)
+ while subSSMeshit.More():
+ subSSMeshSO = subSSMeshit.Value()
+ subSSMeshit.Next()
+ if subSSMeshSO.GetObject()._narrow(typeMesh):
+ names.append(subSSMeshSO.GetName())
+ else :
+ msg=entry + self.tr(" n est pas un maillage")
+ except :
+ logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )
+ msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry
+ return names, msg
+
+ #-------------------------------------
+ def isMeshGroup( self,entry):
+ #-------------------------------------
+ result=False
+ import SMESH
+ try:
+ monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
+ if monObjet != None : # selection d'un groupe de SMESH
+ if monObjet._narrow(SMESH.SMESH_GroupBase):
+ result = True
+ except :
+ logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )
+ return result
+
+ #-------------------------------------
+ def isMesh( self,entry):
+ #-------------------------------------
+ result=False
+ import SMESH
+ try:
+ monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
+ if monObjet != None : # selection d'un groupe de SMESH
+ if monObjet._narrow(SMESH.SMESH_Mesh):
+ result = True
+ except :
+ logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )
+ return result
+
+ #-------------------------------------
+ def getMesh( self,entry):
+ #-------------------------------------
+ meshObject=None
+ import SMESH
+ try:
+ #if 1 :
+ monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
+ if monObjet != None : # selection d'un groupe de SMESH
+ meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
+ except :
+ logger.debug(' pb avec ( entry = %s ) ' %entry )
+ return meshObject
+
+ #-------------------------------------
+
+ #-------------------------------------
+ def isShape( self,entry):
+ #-------------------------------------
+ result=False
+ import GEOM
+ try:
+ monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
+ if monObjet != None : # selection d'un objet GEOM
+ if monObjet._narrow(GEOM.GEOM_Object ):
+ result = True
+ except :
+ logger.debug(' isShape pb avec ( entry = %s ) ' %entry )
+ return result
+
+ #-----------------------------------------------------------------
+ def getMainShapeEntry(self,entry):
+ #-----------------------------------------------------------------
+ result=None
+ try:
+ mainShapeEntry = entry.split(':')[:4]
+ if len(mainShapeEntry) == 4:
+ strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
+ if self.isMainShape(strMainShapeEntry):
+ result = strMainShapeEntry
+ except:
+ logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
+ result = None
+ return result
+
+ #-----------------------------------------------------------------
+ def isMainShape(self,entry):
+ #-----------------------------------------------------------------
+ result = False
+ try:
+ monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
+ import GEOM
+ shape = monObjet._narrow( GEOM.GEOM_Object )
+ if shape.IsMainShape():
+ result = True
+ except:
+ logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
+ result = False
+ return result
- def __selectShape( self, jdcID, selectedEntry ):
- """
- sélection sous-géométrie dans Salome:
- -test1) si c'est un élément 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 )
-
- if selectedMainShapeEntry: #ok test1)
- if not self.mainShapeEntries.has_key( jdcID ):
- self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
- if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
- name = self.palStudyManager.getNameAttribute( selectedEntry )
- self.subShapes[ selectedEntry ] = name
- else:
- print 'CS_pbruno pas la même mainshape selectedEntry->',selectedEntry
- if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = self.palStudyManager.getNameAttribute( self.mainShapeEntries[ jdcID ] )
- msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
-
- return name, msgError
-
-
-
- def __selectMeshGroup( self, jdcID, selectedEntry ):
- """
- 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 = '',''
-
- selectedMeshEntry = self.palStudyManager.getMesh( selectedEntry )
-
- if selectedMeshEntry: # ok test 1)
- print 'CS_pbruno __selectMeshGroup selectedMeshEntry',selectedMeshEntry
- selectedMainShapeEntry = self.palStudyManager.getShapeFromMesh( selectedMeshEntry )
-
- if selectedMainShapeEntry: #test 2)
- print 'CS_pbruno __selectMeshGroup selectedMainShapeEntry',selectedMainShapeEntry
- if not self.mainShapeEntries.has_key( jdcID ):
- self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
- if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
- name = self.palStudyManager.getNameAttribute( selectedEntry ) #ok test 2)
- else:
- print 'CS_pbruno pas la même mainshape selectedEntry ->',selectedEntry
- if not self.mainShapeNames.has_key( jdcID ):
- self.mainShapeNames[ jdcID ] = self.palStudyManager.getNameAttribute( self.mainShapeEntries[ jdcID ] )
- msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
-
- return name, msgError
-
-
-
- def __updateSubShapes( self, jdcID, groupeNames ):
+ #-----------------------------------------------------------------
+ def ChercheType( self, shape ):
+ #-----------------------------------------------------------------
+ tgeo = shape.GetShapeType()
+ geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
+ #print dir(self.editor.study)
+ groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
+ if tgeo != "COMPOUND" : return tgeo
+
+ strInfo = groupIMeasureOp.WhatIs( shape )
+ dictInfo = {}
+ l = strInfo.split('\n')
+
+ for couple in l:
+ nom, valeur = couple.split(':')
+ dictInfo[ nom.strip() ] = valeur.strip()
+
+ ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
+ for t in ordre:
+ if dictInfo[ t ] != '0':
+ tgeo = t
+ return tgeo
+ return None
+
+
+ #-----------------------------------------------------------------
+ def selectShape( self, editor, entry, kwType = None ):
+ #-----------------------------------------------------------------
"""
- mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
+ selection sous-geometrie dans Salome:
+ -test1) si c'est un element sous-geometrique .
+ -test2) si appartient a la geometrie principale.
"""
- for name in groupeNames:
- entries = self.palStudyManager.getEntriesFromName( studyManager.SGeom, name )
- for entry in entries:
- ok, msgError = self.__selectShape( jdcID, entry ) # filtre
- if ok:
- self.subShapes[ entry ] = name
-
-
- def __getAllGroupeMa(self, item ):
+ name, msgError = '',''
+ mySO = self.editor.study.FindObjectID(entry)
+ if mySO == None :
+ return name, msgError
+ object = mySO.GetObject()
+ if object == None :
+ return name, msgError
+
+ import GEOM
+ shape = object._narrow( GEOM.GEOM_Object )
+ if not shape :
+ return name, msgError
+
+ tGeo=self.ChercheType(shape)
+ if not tGeo :
+ return name, msgError
+ #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
+ # name,msgError = '',"la selection n est pas un Vertex"
+ # return name, msgError
+ if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
+ name, msgError = '', "la selection n est pas un groupe de maille"
+ return name, msgError
+
+ mainShapeEntry = self.getMainShapeEntry( entry )
+ if self.mainShapeNames.has_key( editor ):
+ #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
+ if self.mainShapeNames[editor] == mainShapeEntry:
+ name=mySO.GetName()
+ else :
+ msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
+ else :
+ self.mainShapeNames[editor] = mainShapeEntry
+ name=mySO.GetName()
+
+ return name, msgError
+
+
+ #-----------------------------------------------------------------
+ def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
+ #-----------------------------------------------------------------
"""
- Récupère tous les GROUPE_MA dans le JDC courant
+ selection groupe de maille dans Salome:
+ -test 1) si c'est un groupe de maille
+ -test 2) si le maillage fait reference a la geometrie principale
"""
- groupMa = ()
- try:
- itemName = item.get_nom()
- #print 'CS_pbruno itemName',itemName
- if itemName == 'GROUP_MA':
- itemValue = item.get_valeur()
- print 'CS_pbruno trouvé! GROUP_MA->', itemValue
- if type( itemValue ) == str:
- groupMa += ( itemValue , )
- elif type( itemValue ) == tuple:
- groupMa += itemValue
- else:
- children = item.GetSubList()
- for child in children:
- groupMa += self.__getAllGroupeMa( child )
- except: # à cause de GetSubList()...
- pass
- print 'CS_pbruno groupMa',groupMa
- return groupMa
-
-
- def __getAllGroupeNo(self, item ):
+ name, msgError = '',''
+
+ mySO=self.editor.study.FindObjectID(selectedEntry )
+ from salome.smesh.smeshstudytools import SMeshStudyTools
+ monSMeshStudyTools=SMeshStudyTools(self.editor)
+ meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
+ if meshSO == None : return name, msgError
+
+ # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
+ tGroup = ""
+ groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
+ if not groupObject :
+ logger.debug("selectedMeshEntry: An error occurs")
+
+ import SMESH
+ aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
+ if aGroup: tGroup = aGroup.GetType()
+
+ if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
+ msgError = self.tr("GROUP_NO attend un groupe de noeud")
+ return name, msgError
+ elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
+ msgError = self.tr("GROUP_MA attend un point goupe de maille")
+ return name, msgError
+
+ # on cherche la shape associee
+ #PN PN mesh_Object est un SOject
+ meshObject = meshSO.GetObject()
+ mesh = meshObject._narrow( SMESH.SMESH_Mesh )
+ if mesh: #c'est bien un objet maillage
+ shape = mesh.GetShapeToMesh()
+ if shape:
+ ior = salome.orb.object_to_string( shape )
+ if ior:
+ sObject = self.editor.study.FindObjectIOR( ior )
+ mainShapeID = sObject.GetID()
+ else :
+ mainShapeID=0
+ else :
+ return name, self.tr("Type d objet non permis")
+
+ # on cherche si la shape associee est la bonne
+ #print "------------- mainShapeID" , mainShapeID
+ if self.mainShapeNames.has_key( editor ):
+ #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
+ if self.mainShapeNames[editor] == mainShapeID:
+ name=mySO.GetName()
+ else :
+ msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
+ else :
+ self.mainShapeNames[editor] = mainShapeID
+ name=mySO.GetName()
+
+ #print "------------------------------ name :", name
+ #print "------------------------------ name :", name
+ #print "------------------------------ name :", name
+ return name,msgError
+
+
+ def displayMeshGroups(self, meshGroupName):
"""
- Récupère tous les GROUPE_NO dans le JDC courant
+ visualisation group de maille de nom meshGroupName dans salome
"""
- groupNo = ()
+ ok, msgError = False, ''
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
- if type( itemValue ) == str:
- groupNo += ( itemValue , )
- elif type( itemValue ) == tuple:
- groupNo += itemValue
- else:
- children = item.GetSubList()
- for child in children:
- groupNo += self.__getAllGroupeNo( child )
- except: # à cause de GetSubList()...
- pass
- return groupNo
-
- #----------------------- LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
- def selectGroupFromSalome( self ):
+ #if 1 :
+ sg = salome.ImportComponentGUI('SMESH')
+ meshGroupEntries = []
+ selMeshEntry = None
+ selMeshGroupEntry = None
+
+ # liste des groupes de maille de nom meshGroupName
+ listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
+ #print listSO
+ #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
+
+ if len(listSO)>1:
+ return 0,self.tr('Plusieurs objets portent ce nom')
+ if len(listSO) ==0 :
+ return 0,self.tr('Aucun objet ne porte ce nom')
+ SObjet=listSO[0]
+ groupEntry = SObjet.GetID()
+ myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
+ SCom = self.editor.study.FindComponent("SMESH")
+ myBuilder = self.editor.study.NewBuilder()
+ myBuilder.LoadWith( SCom , myComponent )
+ sg.CreateAndDisplayActor(groupEntry)
+ #color = COLORS[ self.icolor % LEN_COLORS ]
+ #self.icolor = self.icolor + 1
+ #sg.SetColor(groupEntry, color[0], color[1], color[2])
+ salome.sg.Display(groupEntry)
+ salome.sg.FitAll()
+ ok = True
+
+ except:
+ #else :
+ msgError = self.tr("Impossible d afficher ")+shapeName
+ logger.debug(50*'=')
+ return ok, msgError
+
+# ___________________________ Methodes appelees par EFICAS __________________________________
+ #----------------------------------------------------------------
+ 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
+ Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(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: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
"""
- print 'CS_pbruno selectGroupFromSalome'
names, msg = [], ''
- try:
- # récupère toutes les sélections de l'utilsateur dans l'arbre Salome
+ try:
+ atLeastOneStudy = self.editor.study
+ if not atLeastOneStudy:
+ return names, msg
+
+ # recupere toutes les selections 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()
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 self.isMeshGroup(entry): # selection d 'un sous maillage
+ name, msg = self.selectMeshGroup( editor, entry, kwType )
+ elif self.isShape(entry): # selection d'une sous-geometrie
+ name, msg = self.selectShape( editor, entry, kwType )
else:
- name, msg = '', msgUnAuthorizedSelecion
+ name, msg = None,self.tr("Selection SALOME non autorisee.")
if name:
- names.append( name )
+ names.append( name )
- if names and len( names ) < nbEntries:
- msg = msgIncompleteSelection
- except:
- pass
- salome.sg.EraseAll()
- print 'CS_pbruno selectGroupFromSalome names = ',names
+ except:
+ logger.debug("selectGroupFromSalome: An error occurs")
+ #print "=================== selectGroupFromSalome ", names, msg
+ #print "=================== selectGroupFromSalome ", names, msg
+ #print "=================== selectGroupFromSalome ", names, msg
return names, msg
+
+ #----------------------------------------------------------------
+ def selectMeshFile( self, editor=None):
+ #----------------------------------------------------------------
+ """
+ """
+ try :
+ atLeastOneStudy = self.editor.study
+ if not atLeastOneStudy: return "", 'Pas d etude'
+
+ # recupere toutes les selections de l'utilsateur dans l'arbre Salome
+ entries = salome.sg.getAllSelected()
+ nbEntries = len( entries )
+ if nbEntries != 1 : return "", 'select a Mesh'
+ entry = entries[0]
+ if not self.isMesh(entry): return "", 'select a Mesh'
+ mySO=self.editor.study.FindObjectID(entry)
+ print mySO
+ ok, anAttr = mySO.FindAttribute("AttributeName")
+ if not ok : return "" ,'Pb de nommage'
+ meshFile="/tmp/"+str(anAttr.Value())+'.med'
+ myMesh=self.getMesh(entry)
+ if myMesh==None : return "" ,'Pb dans la selection '
+ myMesh.ExportMED( meshFile, 0)
+ return meshFile ,""
+ except :
+ return "", "Pb dans la selection "
+
+ #----------------------------------------------------------------
+ def importMedFile( self,fileName, editor=None):
+ #----------------------------------------------------------------
+ try :
+ theStudy = self.editor.study
+ if not theStudy: return (0, 'Pas d etude')
+ from salome.smesh import smeshBuilder
+ smesh = smeshBuilder.New(theStudy)
+ aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
+ salome.sg.updateObjBrowser(1)
+ return 1,""
+ except :
+ return (O,"Pb a l import")
+
+ #----------------------------------------------------------------
+ def selectEntryFromSalome( self, kwType = None, editor=None):
+ #----------------------------------------------------------------
+ """
+ Selection d'element a partir de l'arbre salome
+ Ne verifie que l unicite de la selection
+ retourne ( la liste avec le nom du groupe, message d'erreur )
+
+ retourne une liste pour etre coherent avec selectGroupFromSalome
+ Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
+ """
+ try:
+ if self.editor.study._non_existent():
+ raise Exception(self.tr(u"L'etude Salome n'existe plus"))
+ entries = salome.sg.getAllSelected()
+ nbEntries = len( entries )
+ if nbEntries < 1:
+ raise Exception(self.tr(u"Veuillez selectionner une entree de l'arbre d'etude de Salome"))
+ elif nbEntries > 1 :
+ raise Exception(self.tr(u"Une seule entree doit être selectionnee dans l'arbre d'etude de Salome"))
+
+ value = kwType.get_selected_value(entries[0], self.editor)
+ msg = self.tr(u"L'entree de l'arbre d'etude de Salome a ete selectionnee")
+ return [value], msg
+ except Exception, e:
+ QMessageBox.information(self, self.tr(u"Selection depuis Salome"), unicode(e))
+ return [], unicode(e)
+
-
+ #---------------------------------------------
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 dans l'arbre d'etude Salome dans la rubrique EFICAS
+ Revu pour QT4
"""
- 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
- 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.
- """
-
- jdcID = self.bureau.nb.getcurselection()
-
- groupeMaNames = self.__getAllGroupeMa( self.bureau.JDCDisplay_courant.tree.item )
- groupeNoNames = self.__getAllGroupeNo( self.bureau.JDCDisplay_courant.tree.item )
-
- print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
- print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
+ msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
+ if jdcPath == "" or jdcPath == None : return
+ ok = False
+ try:
+ atLeastOneStudy = self.editor.study
+ if not atLeastOneStudy:
+ return ok, msgError
- # mise à jours de la liste des sous-géométrie ( self.subShapes )
- self.__updateSubShapes( jdcID, groupeMaNames )
- self.__updateSubShapes( jdcID, groupeNoNames )
-
-
- # recupération des identifiants( entries ) associés aux noms des groupes
- groupeMaEntries = []
- groupeNoEntries = []
+ fileType = { 'TELEMAC' : "FICHIER_EFICAS_TELEMAC",
+ 'ADAO' : "FICHIER_EFICAS_ADAO",
+ 'SEP' : "FICHIER_EFICAS_SEP",
+ 'SPECA' : "FICHIER_EFICAS_SPECA",
+ 'MT' : "FICHIER_EFICAS_MT",
+ 'CF' : "FICHIER_EFICAS_CF",
+ 'MAP' : "FICHIER_EFICAS_MAP",
+ 'CARMEL3D' : "FICHIER_EFICAS_CARMEL3D",
+ }
+
+
+ folderName = { 'TELEMAC' : "TelemacFiles",
+ 'ADAO' : "AdaoFiles",
+ 'SEP' : "SepFiles",
+ 'SPECA' : "SpecaFiles",
+ 'MT' : "MTFiles",
+ 'CF' : "CFFiles",
+ 'CARMEL3D' : 'CARMEL3DFiles' ,
+ 'MAP' : 'MapFiles' ,
+ }
+
+
+ folderType = { 'TELEMAC' : "TELEMAC_FILE_FOLDER",
+ 'ADAO' : "ADAO_FILE_FOLDER",
+ 'SEP' : "SEP_FILE_FOLDER",
+ 'SPECA' : "SPECA_FILE_FOLDER",
+ 'MT' : "MT_FILE_FOLDER",
+ 'CF' : "CF_FILE_FOLDER",
+ 'SEP' : "SEP_FILE_FOLDER",
+ 'MAP' : "MAP_FILE_FOLDER",
+ 'CARMEL3D' : "CARMEL3D_FILE_FOLDER",
+ }
+
+
+ moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
+ itemName = re.split("/",jdcPath)[-1]
- 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 folderName.has_key(self.code) :
+ monFolderName=folderName[ self.code ]
+ else :
+ monFolderName=str(self.code)+"Files"
+
+ if folderType.has_key(self.code) :
+ monFolderType=fileType[ self.code ]
+ else :
+ monFolderType=str(self.code)+"_FILE_FOLDER"
+
+ if fileType.has_key(self.code) :
+ monFileType=fileType[ self.code ]
+ else :
+ monFileType="FICHIER_EFICAS_"+str(self.code)
+
+ fatherEntry = self.editor.findOrCreateItem(
+ moduleEntry,
+ name = monFolderName,
+ #icon = "ICON_COMM_FOLDER",
+ fileType = monFolderType)
+
+ commEntry = self.editor.findOrCreateItem( fatherEntry ,
+ name = itemName,
+ fileType = monFileType,
+ fileName = jdcPath,
+ #icon = "ICON_COMM_FILE",
+ comment = str( jdcPath ))
+
+ salome.sg.updateObjBrowser(1)
+
+ #print 'addJdcInSalome commEntry->', commEntry
+ if commEntry:
+ ok, msgError = True, ''
+ except Exception, exc:
+ msgError = "Can't add Eficas file to Salome study tree"
+ logger.debug(msgError, exc_info = True)
+ QMessageBox.warning(self, self.tr("Warning"),
+ self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de details " % (msgError, exc)))
+ return ok, msgError
-
+
+ #---------------------------------------
def displayShape( self, shapeName ):
+ #---------------------------------------
"""
- visualisation géométrie de nom shapeName dans salome
+ visualisation 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:
+ #if 1 :
+ import SalomePyQt
+ sgPyQt = SalomePyQt.SalomePyQt()
+ myActiveView=sgPyQt.getActiveView()
+ if myActiveView < 0 :
+ return ok, 'pas de vue courante'
+
+ currentViewType=sgPyQt.getViewType(myActiveView)
+ if str(currentViewType) != "OCCViewer" : # maillage
+ ok, msgError = self.displayMeshGroups(shapeName)
+ else: #geometrie
+ current_color = COLORS[ self.icolor % LEN_COLORS ]
+ from salome.geom.geomtools import GeomStudyTools
+ myGeomTools=GeomStudyTools(self.editor)
+ ok = myGeomTools.displayShapeByName( shapeName, current_color )
+ salome.sg.FitAll()
+ self.icolor = self.icolor + 1
+ if not ok:
+ msgError =self.tr("Impossible d afficher ")+shapeName
+ except:
+ #else :
+ logger.debug(50*'=')
return ok, msgError
+
+ #---------------------------------------
+ def ChercheGrpMeshInSalome(self):
+ #---------------------------------------
+ print "je passe par la"
+ import SMESH
+ names, msg = [], ''
+ try :
+ #if 1 :
+ entries = salome.sg.getAllSelected()
+ nbEntries = len( entries )
+ names, msg = None, self.tr("Selection SALOME non autorisee.")
+ if nbEntries == 1:
+ for entry in entries:
+ names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
+ except :
+ #else :
+ print "bim bam boum"
+ return(msg,names)
+
+ #---------------------------------------
+ def ChercheGrpMailleInSalome(self):
+ #---------------------------------------
+ import SMESH
+ names, msg = [], ''
+ try :
+ #if 1:
+ entries = salome.sg.getAllSelected()
+ nbEntries = len( entries )
+ names, msg = None, self.tr("Selection SALOME non autorisee.")
+ if nbEntries == 1:
+ for entry in entries:
+ print entry
+ names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
+ print names
+ except :
+ #else:
+ print "bim bam boum"
+ return(msg,names)
+
+
- def creeConfigTxt(self,fichier,dico):
- """
- sauvegarde = asksaveasfilename(title="fichier config.txt",
- defaultextension='.txt',
- 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.write(ligne)
- f.close()
- self.rangeInStudy(sauvegarde)
- print "==============================="
- print "fin crreConfigTxt"
- """
- pass #CS_pbruno à implémenter
-
-
-
-
-
-
-
-
-#def runEficas( palStudyManager, code="ASTER", fichier=None, studyId=None):
-def runEficas( parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.study, code="ASTER", fichier=None ):
- global appli
- if not appli: #une seul instance possible!
- appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
-
-
-def runHomard( parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.study, 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.study, code="ASTER", fichier=None ) :
- global appli
- if not appli: #une seul instance possible!
- appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
-"""
-
-
-
-# Init globale du module
-root = Tkinter.Tk()
-root.withdraw()
-
-appli = None
-
-
-
-
-
+#-------------------------------------------------------------------------------------------------------
+# Pilotage de la Visu des elements de structures
+#
+ def envoievisu(self,liste_commandes):
+ try:
+ from salome.geom.structelem import StructuralElementManager, InvalidParameterError
+ except ImportError:
+ QMessageBox.critical(self, self.tr("Error"),
+ self.tr("Impossible d'afficher les elements de structure: "
+ "module GEOM n est pas installe."))
+ return
+ try:
+ atLeastOneStudy = self.editor.study
+ if not atLeastOneStudy:
+ return
+ logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
+ structElemManager = StructuralElementManager()
+ elem = structElemManager.createElement(liste_commandes)
+ elem.display()
+ salome.sg.updateObjBrowser(True)
+ except InvalidParameterError, err:
+ trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
+ "greater than %(minval)g (actual value is %(value)g)")
+ msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
+ "minval": err.minValue, "value": err.value}
+ QMessageBox.warning(self, self.tr("Error"), msg)
+ except:
+ traceback.print_exc()
+ logger.debug(10*'#'+":pb dans envoievisu")
+
+
+class SalomeEntry:
+ """
+ This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
+ when Eficas is launched in Salome context. It handles the objects that can
+ be selected from Salome object browser.
+ By default, the selected value is the entry of the selected item in the
+ object browser. This class can be subclassed to provide more advanced
+ functions.
+ """
+
+ help_message = u"Une entree de l'arbre d'etude de Salome est attendue"
+
+ def __init__(self, entryStr):
+ self._entry = entryStr
+
+ @staticmethod
+ def __convert__(entryStr):
+ return SalomeEntry(entryStr)
+
+ @staticmethod
+ def get_selected_value(selected_entry, study_editor):
+ return selected_entry
+
+
+#-------------------------------------------------------------------------------------------------------
+# Point d'entree lancement EFICAS
+#
+def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
+ 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, componentName = componentName,multi=multi )
+ #if not appli: #une seul instance possible!
+ # appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
+ # module = module, componentName = componentName, version=version )
+ logger.debug(10*'#'+":runEficas: END")
-"""
- #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
