--- /dev/null
+# -*- coding: utf-8 -*-
+#_____________________________________
+
+import sys, os, re,types
+import traceback
+from PyQt4.QtGui import QMessageBox
+from PyQt4.QtGui import QApplication
+
+from salome.kernel.logger import Logger
+logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
+
+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,'UiQT4'),
+ os.path.join( eficasConfig.eficasPath,'InterfaceQT4'),
+ #os.path.join( eficasConfig.eficasPath,'Extensions'),
+ eficasConfig.eficasPath,
+ ]
+
+
+import Editeur
+from InterfaceQT4 import qtEficas
+
+import salome
+import SalomePyQt
+sgPyQt = SalomePyQt.SalomePyQt()
+langue=str(sgPyQt.stringSetting("language","language"))
+
+
+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( qtEficas.Appli ):
+ """
+ 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, code = "ASTER", fichier = None, module = "EFICAS",
+ version = None, componentName = "Eficas",multi=False):
+ """
+ Constructeur.
+ @type parent:
+ @param parent: widget Qt parent
+ @type code: string
+ @param code: catalogue a lancer ( ASTER, HOMARD OPENTURNS ). optionnel ( defaut = ASTER ).
+ @type fichier: string
+ @param fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
+ """
+
+ dictPathCode={'ASTER':'Aster','OPENTURNS_STUDY':'Openturns_Study','CARMEL3D':'Carmel3D', 'CARMELCND':'CarmelCND',
+ 'OPENTURNS_WRAPPER':'Openturns_Wrapper','MAP':'MAP','SEP':'Sep', 'ZCRACKS':'ZCracks', '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' ):
+ from Editeur import session
+ eficasArg = []
+ eficasArg += sys.argv
+ if fichier:
+ eficasArg += [ fichier ]
+ if version:
+ eficasArg += [ "-c", version ]
+ else :
+ print "noversion"
+ session.parse( eficasArg )
+
+ self.editor = getStudyEditor() # Editeur de l'arbre d'etude
+
+ qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
+
+ #--------------- specialisation EFICAS dans SALOME -------------------
+ self.parent = parent
+ 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 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 ):
+ #-----------------------------------------------------------------
+ """
+ selection sous-geometrie dans Salome:
+ -test1) si c'est un element sous-geometrique .
+ -test2) si appartient a la geometrie principale.
+ """
+ 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 ):
+ #-----------------------------------------------------------------
+ """
+ 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
+ """
+ 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):
+ """
+ visualisation group de maille de nom meshGroupName dans salome
+ """
+ ok, msgError = False, ''
+ try:
+ #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):
+ #----------------------------------------------------------------
+ """
+ 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: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
+ """
+ names, msg = [], ''
+ 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()
+ nbEntries = len( entries )
+ if nbEntries >= 1:
+ for entry in entries:
+ 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 = None,self.tr("Selection SALOME non autorisee.")
+ if name:
+ names.append( name )
+
+ 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'étude Salome n'existe plus"))
+ entries = salome.sg.getAllSelected()
+ nbEntries = len( entries )
+ if nbEntries < 1:
+ raise Exception(self.tr(u"Veuillez sélectionner une entrée de l'arbre d'étude de Salome"))
+ elif nbEntries > 1 :
+ raise Exception(self.tr(u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"))
+
+ value = kwType.get_selected_value(entries[0], self.editor)
+ msg = self.tr(u"L'entrée de l'arbre d'étude de Salome a été sélectionnée")
+ return [value], msg
+ except Exception, e:
+ QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), unicode(e))
+ return [], unicode(e)
+
+
+ #---------------------------------------------
+ def addJdcInSalome( self, jdcPath ):
+ #---------------------------------------------
+ """
+ Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
+ Revu pour QT4
+ """
+ msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
+ ok = False
+ try:
+ atLeastOneStudy = self.editor.study
+ if not atLeastOneStudy:
+ return ok, msgError
+
+ fileType = { 'ASTER' : "FICHIER_EFICAS_ASTER",
+ 'SEP' : "FICHIER_EFICAS_SEP",
+ 'MAP' : "FICHIER_EFICAS_MAP",
+ 'OPENTURNS': "FICHIER_EFICAS_OPENTURNS",
+ 'OPENTURNS_STUDY': "FICHIER_EFICAS_OPENTURNS_STUDY",
+ 'OPENTURNS_WRAPPER': "FICHIER_EFICAS_OPENTURNS_WRAPPER",
+ 'CARMEL3D': "FICHIER_EFICAS_CARMEL3D",
+ 'CARMELCND': "FICHIER_EFICAS_CARMELCND",
+ }
+
+ folderName = { 'ASTER' : 'AsterFiles',
+ 'SEP' : 'OMFiles' ,
+ 'CARMEL3D' : 'CARMEL3DFiles' ,
+ 'CARMELCND' : 'CARMELCNDFiles' ,
+ 'MAP' : 'MapFiles' ,
+ 'OPENTURNS_STUDY': 'OpenturnsFiles',
+ 'OPENTURNS_WRAPPER': 'OpenturnsFiles'}
+
+ folderType = { 'ASTER': "ASTER_FILE_FOLDER",
+ 'SEP': "SEP_FILE_FOLDER",
+ 'MAP': "MAP_FILE_FOLDER",
+ 'CARMEL3D': "CARMEL3D_FILE_FOLDER",
+ 'CARMELCND': "CARMELCND_FILE_FOLDER",
+ 'OPENTURNS_STUDY':"OPENTURNS_FILE_FOLDER",
+ 'OPENTURNS_WRAPPER': "OPENTURNS_FILE_FOLDER"}
+
+
+ moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
+ itemName = re.split("/",jdcPath)[-1]
+
+ 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 détails " % (msgError, exc)))
+ return ok, msgError
+
+
+ #---------------------------------------
+ def displayShape( self, shapeName ):
+ #---------------------------------------
+ """
+ visualisation de nom shapeName dans salome
+ """
+ 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)
+
+
+
+
+
+#-------------------------------------------------------------------------------------------------------
+# 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 entrée de l'arbre d'étude 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")
+
+
