src/EFICASGUI/eficasSalome.py

   1 # -*- coding: utf-8 -*-
   2 #_____________________________________
   3
   4 import sys, os, re,types
   5 import traceback
   6 from PyQt4.QtGui import QMessageBox
   7 from PyQt4.QtGui import QApplication
   8
   9 from salome.kernel.logger import Logger
  10 logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
  11
  12 import eficasConfig
  13 # eficasConfig definit le EFICAS_ROOT
  14 # lignes de path ajoutees pour acceder aux packages python du
  15 # logiciel Eficas. Le package Aster est ajoute explicitement pour
  16 # acceder au module prefs.py. A
  17 # ajout de InterfaceQT4 pour permettre l acces a la fenetre Option
  18 sys.path[:0]=[eficasConfig.eficasPath,
  19               os.path.join( eficasConfig.eficasPath,'Editeur'),
  20               os.path.join( eficasConfig.eficasPath,'UiQT4'),
  21               os.path.join( eficasConfig.eficasPath,'InterfaceQT4'),
  22               os.path.join( eficasConfig.eficasPath,'Extensions'),
  23               eficasConfig.eficasPath,
  24              ]
  25
  26
  27 import Editeur
  28 from InterfaceQT4 import qtEficas
  29
  30 import salome
  31 import SalomePyQt
  32 sgPyQt = SalomePyQt.SalomePyQt()
  33 langue=str(sgPyQt.stringSetting("language","language"))
  34
  35
  36 from salome.kernel.studyedit import getStudyEditor
  37
  38
  39 # couleur pour visualisation des geometries
  40 import colors
  41 COLORS = colors.ListeColors
  42 LEN_COLORS = len( COLORS )
  43
  44 from Extensions import localisation
  45 localisation.localise(None,langue)
  46
  47
  48
  49 class MyEficas( qtEficas.Appli ):
  50     """
  51     Classe de lancement du logiciel EFICAS dans SALOME
  52     Cette classe specialise le logiciel Eficas par l'ajout de:
  53     a)la creation de groupes de mailles dans le composant SMESH de SALOME
  54     b)la visualisation d'elements geometrique dans le coposant GEOM de SALOME par selection dans EFICAS
  55     """
  56     def __init__( self, parent, code = "ASTER", fichier = None, module = "EFICAS",
  57                   version = None, componentName = "Eficas",multi=False):
  58         """
  59         Constructeur.
  60         @type   parent:
  61         @param  parent: widget Qt parent
  62         @type   code: string
  63         @param  code: catalogue a lancer ( ASTER, HOMARD OPENTURNS ). optionnel ( defaut = ASTER ).
  64         @type   fichier: string
  65         @param  fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
  66         """
  67
  68         dictPathCode={'ASTER':'Aster','OPENTURNS_STUDY':'Openturns_Study','CARMEL3D':'Carmel3D',
  69                       'OPENTURNS_WRAPPER':'Openturns_Wrapper','MAP':'MAP','SEP':'Sep', 'ZCRACKS':'ZCracks'}
  70         if code in dictPathCode.keys():
  71             pathCode=dictPathCode[code]
  72             sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)]
  73
  74         if Editeur.__dict__.has_key( 'session' ):
  75             from Editeur import session
  76             eficasArg = []
  77             eficasArg += sys.argv
  78             if fichier:
  79                 eficasArg += [ fichier ]
  80             if version:
  81                 eficasArg += [ "-c", version ]
  82             else :
  83                 print "noversion"
  84             session.parse( eficasArg )
  85
  86         self.editor = getStudyEditor()    # Editeur de l'arbre d'etude
  87
  88         qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
  89
  90         #--------------- specialisation EFICAS dans SALOME  -------------------
  91         self.parent = parent
  92         self.salome = True      #active les parties de code specifique dans Salome( pour le logiciel Eficas )
  93         self.module = module    #indique sous quel module dans l'arbre d'etude ajouter le JDC.
  94         self.componentName = componentName
  95
  96         # donnee pour la creation de groupe de maille
  97         self.mainShapeNames   = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par
  98                                    #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.
  99                                    #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name )
 100         #----------------------------------------------------------------------
 101
 102         self.icolor = 0  # compteur pour memoriser la couleur courante
 103         self.show()
 104
 105
 106     def closeEvent(self,event):
 107         res=self.fileExit()
 108         if res==2 :
 109           event.ignore()
 110           return
 111         if hasattr(self,'readercata') :
 112            del self.readercata
 113         global appli
 114         appli = None
 115         event.accept()
 116
 117
 118 # ___________________________ Methodes de l ex Pal __________________________________
 119
 120     #----------------------------------------------------------------
 121     def getCORBAObjectInComponent( self,  entry, composant ):
 122     #----------------------------------------------------------------
 123        object = None
 124        mySO = self.editor.study.FindObjectID(entry)
 125        if mySO:
 126           object = mySO.GetObject()
 127           if not object:
 128              myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
 129              SCom        = self.editor.study.FindComponent( composant )
 130              print myComponent , SCom
 131              self.editor.builder.LoadWith( SCom , myComponent  )
 132              object      = mySO.GetObject()
 133        if not object :
 134              logger.debug("selectedEntry: An error occurs")
 135        return object
 136
 137
 138     #----------------------------------------------
 139     def giveMeshGroups( self,entry,label1,typeMesh):
 140     #----------------------------------------------
 141        msg=None
 142        names=[]
 143        import SMESH
 144        try:
 145          monMaillage =self.getCORBAObjectInComponent(entry,"SMESH")
 146          if monMaillage != None :                                    # selection d'un groupe de SMESH
 147             if  monMaillage._narrow(SMESH.SMESH_Mesh):
 148                 mailSO = self.editor.study.FindObjectID(entry)
 149                 if mailSO == None : return names, msg
 150
 151
 152                 subIt = self.editor.study.NewChildIterator(mailSO)
 153                 while subIt.More():
 154                       subSO = subIt.Value()
 155                       subIt.Next()
 156
 157                       if (subSO.GetName()[0:9]!=label1) : continue
 158                       subSSMeshit=self.editor.study.NewChildIterator(subSO)
 159                       while subSSMeshit.More():
 160                            subSSMeshSO = subSSMeshit.Value()
 161                            subSSMeshit.Next()
 162                            if  subSSMeshSO.GetObject()._narrow(typeMesh):
 163                                names.append(subSSMeshSO.GetName())
 164             else :
 165                 msg=entry + self.tr(" n est pas un maillage")
 166        except :
 167          logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )
 168          msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry
 169        return names, msg
 170
 171     #-------------------------------------
 172     def isMeshGroup( self,entry):
 173     #-------------------------------------
 174        result=False
 175        import SMESH
 176        try:
 177          monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
 178          if monObjet != None :                                    # selection d'un groupe de SMESH
 179             if  monObjet._narrow(SMESH.SMESH_GroupBase):
 180                 result = True
 181        except :
 182          logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )
 183        return result
 184
 185     #-------------------------------------
 186     def isMesh( self,entry):
 187     #-------------------------------------
 188        result=False
 189        import SMESH
 190        try:
 191          monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
 192          if monObjet != None :                                    # selection d'un groupe de SMESH
 193             if  monObjet._narrow(SMESH.SMESH_Mesh):
 194                 result = True
 195        except :
 196          logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )
 197        return result
 198
 199     #-------------------------------------
 200     def getMesh( self,entry):
 201     #-------------------------------------
 202        meshObject=None
 203        import SMESH
 204        try:
 205        #if 1 :
 206          monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
 207          if monObjet != None :                                    # selection d'un groupe de SMESH
 208             meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
 209        except :
 210        #  logger.debug('  pb avec ( entry = %s ) ' %entry )
 211        return meshObject
 212
 213     #-------------------------------------
 214
 215     #-------------------------------------
 216     def isShape( self,entry):
 217     #-------------------------------------
 218        result=False
 219        import GEOM
 220        try:
 221          monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
 222          if monObjet != None :                                    # selection d'un objet GEOM
 223             if  monObjet._narrow(GEOM.GEOM_Object ):
 224                 result = True
 225        except :
 226          logger.debug(' isShape pb avec ( entry = %s ) ' %entry )
 227        return result
 228
 229     #-----------------------------------------------------------------
 230     def getMainShapeEntry(self,entry):
 231     #-----------------------------------------------------------------
 232         result=None
 233         try:
 234            mainShapeEntry = entry.split(':')[:4]
 235            if len(mainShapeEntry) == 4:
 236                 strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
 237                 if self.isMainShape(strMainShapeEntry):
 238                     result = strMainShapeEntry
 239         except:
 240             logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
 241             result = None
 242         return result
 243
 244     #-----------------------------------------------------------------
 245     def isMainShape(self,entry):
 246     #-----------------------------------------------------------------
 247         result = False
 248         try:
 249             monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
 250             import GEOM
 251             shape    = monObjet._narrow( GEOM.GEOM_Object )
 252             if shape.IsMainShape():
 253                 result = True
 254         except:
 255             logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
 256             result = False
 257         return result
 258
 259
 260     #-----------------------------------------------------------------
 261     def ChercheType( self, shape ):
 262     #-----------------------------------------------------------------
 263         tgeo =  shape.GetShapeType()
 264         geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
 265         #print dir(self.editor.study)
 266         groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
 267         if tgeo != "COMPOUND" : return tgeo
 268
 269         strInfo =  groupIMeasureOp.WhatIs( shape )
 270         dictInfo = {}
 271         l = strInfo.split('\n')
 272
 273         for couple in l:
 274              nom, valeur = couple.split(':')
 275              dictInfo[ nom.strip() ] = valeur.strip()
 276
 277         ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
 278         for t in ordre:
 279             if dictInfo[ t ] != '0':
 280                tgeo = t
 281                return tgeo
 282         return None
 283
 284
 285     #-----------------------------------------------------------------
 286     def selectShape( self, editor, entry, kwType = None ):
 287     #-----------------------------------------------------------------
 288         """
 289         selection sous-geometrie dans Salome:
 290         -test1) si c'est un element sous-geometrique .
 291         -test2) si appartient a la geometrie principale.
 292         """
 293         name, msgError = '',''
 294         mySO = self.editor.study.FindObjectID(entry)
 295         if mySO == None :
 296            return name, msgError
 297         object = mySO.GetObject()
 298         if object == None :
 299            return name, msgError
 300
 301         import GEOM
 302         shape  = object._narrow( GEOM.GEOM_Object )
 303         if not shape :
 304            return name, msgError
 305
 306         tGeo=self.ChercheType(shape)
 307         if not tGeo :
 308            return name, msgError
 309         #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
 310         #    name,msgError = '',"la selection n est pas un Vertex"
 311         #    return name, msgError
 312         if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
 313             name, msgError = '', "la selection n est pas un groupe de maille"
 314             return name, msgError
 315
 316         mainShapeEntry = self.getMainShapeEntry( entry )
 317         if self.mainShapeNames.has_key( editor ):
 318           #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
 319           if self.mainShapeNames[editor] == mainShapeEntry:
 320              name=mySO.GetName()
 321           else :
 322              msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
 323         else :
 324           self.mainShapeNames[editor] = mainShapeEntry
 325           name=mySO.GetName()
 326
 327         return name, msgError
 328
 329
 330     #-----------------------------------------------------------------
 331     def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
 332     #-----------------------------------------------------------------
 333         """
 334         selection groupe de maille dans Salome:
 335         -test 1) si c'est un groupe de maille
 336         -test 2) si le maillage fait reference a la geometrie principale
 337         """
 338         name, msgError = '',''
 339
 340         mySO=self.editor.study.FindObjectID(selectedEntry )
 341         from salome.smesh.smeshstudytools import SMeshStudyTools
 342         monSMeshStudyTools=SMeshStudyTools(self.editor)
 343         meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
 344         if meshSO == None : return name, msgError
 345
 346        # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
 347         tGroup = ""
 348         groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
 349         if not groupObject :
 350            logger.debug("selectedMeshEntry: An error occurs")
 351
 352         import SMESH
 353         aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
 354         if aGroup: tGroup = aGroup.GetType()
 355
 356         if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
 357              msgError = self.tr("GROUP_NO attend un groupe de noeud")
 358              return name, msgError
 359         elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
 360              msgError = self.tr("GROUP_MA attend un point goupe de maille")
 361              return name, msgError
 362
 363         # on cherche la shape associee
 364         #PN PN mesh_Object est un SOject
 365         meshObject = meshSO.GetObject()
 366         mesh     = meshObject._narrow( SMESH.SMESH_Mesh  )
 367         if mesh:         #c'est bien un objet maillage
 368              shape = mesh.GetShapeToMesh()
 369              if shape:
 370                 ior = salome.orb.object_to_string( shape )
 371                 if ior:
 372                    sObject   = self.editor.study.FindObjectIOR(  ior )
 373                    mainShapeID = sObject.GetID()
 374              else :
 375                 mainShapeID=0
 376         else :
 377              return name, self.tr("Type d objet non permis")
 378
 379         # on cherche si la shape associee est la bonne
 380         #print "------------- mainShapeID" , mainShapeID
 381         if self.mainShapeNames.has_key( editor ):
 382           #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
 383           if self.mainShapeNames[editor] == mainShapeID:
 384              name=mySO.GetName()
 385           else :
 386              msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
 387         else :
 388           self.mainShapeNames[editor] = mainShapeID
 389           name=mySO.GetName()
 390
 391         #print "------------------------------ name :", name
 392         #print "------------------------------ name :", name
 393         #print "------------------------------ name :", name
 394         return name,msgError
 395
 396
 397     def displayMeshGroups(self, meshGroupName):
 398         """
 399         visualisation group de maille de nom meshGroupName dans salome
 400         """
 401         ok, msgError = False, ''
 402         try:
 403         #if 1 :
 404             sg = salome.ImportComponentGUI('SMESH')
 405             meshGroupEntries = []
 406             selMeshEntry = None
 407             selMeshGroupEntry = None
 408
 409             # liste des groupes de maille de nom meshGroupName
 410             listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
 411             #print listSO
 412             #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
 413
 414             if len(listSO)>1:
 415                return 0,self.tr('Plusieurs objets  portent ce nom')
 416             if len(listSO) ==0 :
 417                return 0,self.tr('Aucun objet ne porte ce nom')
 418             SObjet=listSO[0]
 419             groupEntry = SObjet.GetID()
 420             myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
 421             SCom        = self.editor.study.FindComponent("SMESH")
 422             myBuilder   = self.editor.study.NewBuilder()
 423             myBuilder.LoadWith( SCom , myComponent  )
 424             sg.CreateAndDisplayActor(groupEntry)
 425             #color = COLORS[ self.icolor % LEN_COLORS ]
 426             #self.icolor = self.icolor + 1
 427             #sg.SetColor(groupEntry, color[0], color[1], color[2])
 428             salome.sg.Display(groupEntry)
 429             salome.sg.FitAll()
 430             ok = True
 431
 432         except:
 433         #else :
 434             msgError = self.tr("Impossible d afficher ")+shapeName
 435             logger.debug(50*'=')
 436         return ok, msgError
 437
 438 # ___________________________ Methodes appelees par EFICAS  __________________________________
 439     #----------------------------------------------------------------
 440     def selectGroupFromSalome( self, kwType = None, editor=None):
 441     #----------------------------------------------------------------
 442         """
 443         Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille)  partir de l'arbre salome
 444         retourne ( la liste des noms des groupes, message d'erreur )
 445
 446         Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
 447         """
 448         names, msg = [], ''
 449         try:
 450             atLeastOneStudy = self.editor.study
 451             if not atLeastOneStudy:
 452                 return names, msg
 453
 454            # recupere toutes les selections de l'utilsateur dans l'arbre Salome
 455             entries = salome.sg.getAllSelected()
 456             nbEntries = len( entries )
 457             if nbEntries >= 1:
 458                 for entry in entries:
 459                     if self.isMeshGroup(entry):               # selection d 'un sous maillage
 460                        name, msg = self.selectMeshGroup( editor, entry, kwType )
 461                     elif self.isShape(entry):               # selection d'une sous-geometrie
 462                        name, msg = self.selectShape( editor, entry, kwType )
 463                     else:
 464                        name, msg = None,self.tr("Selection SALOME non autorisee.")
 465                     if name:
 466                        names.append( name )
 467
 468         except:
 469             logger.debug("selectGroupFromSalome: An error occurs")
 470         #print "=================== selectGroupFromSalome ", names, msg
 471         #print "=================== selectGroupFromSalome ", names, msg
 472         #print "=================== selectGroupFromSalome ", names, msg
 473         return names, msg
 474
 475     #----------------------------------------------------------------
 476     def selectMeshFile( self,  editor=None):
 477     #----------------------------------------------------------------
 478         """
 479         """
 480         try :
 481             atLeastOneStudy = self.editor.study
 482             if not atLeastOneStudy: return "", 'Pas d etude'
 483
 484            # recupere toutes les selections de l'utilsateur dans l'arbre Salome
 485             entries = salome.sg.getAllSelected()
 486             nbEntries = len( entries )
 487             if nbEntries != 1 : return "", 'select a Mesh'
 488             entry = entries[0]
 489             if not self.isMesh(entry): return "", 'select a Mesh'
 490             mySO=self.editor.study.FindObjectID(entry)
 491             print mySO
 492             ok, anAttr = mySO.FindAttribute("AttributeName")
 493             if not ok :  return "" ,'Pb de nommage'
 494             meshFile="/tmp/"+str(anAttr.Value())+'.med'
 495             myMesh=self.getMesh(entry)
 496             if myMesh==None : return "" ,'Pb dans la selection '
 497             myMesh.ExportMED( meshFile, 0)
 498             return meshFile ,""
 499         except :
 500            return "", "Pb dans la selection "
 501
 502     #----------------------------------------------------------------
 503     def importMedFile( self,fileName,  editor=None):
 504     #----------------------------------------------------------------
 505         try :
 506             theStudy = self.editor.study
 507             if not theStudy: return (0, 'Pas d etude')
 508             from salome.smesh import smeshBuilder
 509             smesh = smeshBuilder.New(theStudy)
 510             aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
 511             salome.sg.updateObjBrowser(1)
 512             return 1,""
 513         except :
 514             return (O,"Pb a l import")
 515
 516     #----------------------------------------------------------------
 517     def selectEntryFromSalome( self, kwType = None, editor=None):
 518     #----------------------------------------------------------------
 519         """
 520         Selection d'element a partir de l'arbre salome
 521         Ne verifie que l unicite de la selection
 522         retourne ( la liste avec le  nom du groupe, message d'erreur )
 523
 524         retourne une liste pour etre coherent avec selectGroupFromSalome
 525         Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
 526         """
 527         try:
 528             if self.editor.study._non_existent():
 529                raise Exception(self.tr(u"L'étude Salome n'existe plus"))
 530             entries = salome.sg.getAllSelected()
 531             nbEntries = len( entries )
 532             if nbEntries < 1:
 533                raise Exception(self.tr(u"Veuillez sélectionner une entrée de l'arbre d'étude de Salome"))
 534             elif nbEntries > 1 :
 535                raise Exception(self.tr(u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"))
 536
 537             value = kwType.get_selected_value(entries[0], self.editor)
 538             msg = self.tr(u"L'entrée de l'arbre d'étude de Salome a été sélectionnée")
 539             return [value], msg
 540         except Exception, e:
 541             QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), unicode(e))
 542             return [], unicode(e)
 543
 544
 545     #---------------------------------------------
 546     def addJdcInSalome(  self, jdcPath ):
 547     #---------------------------------------------
 548         """
 549         Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
 550         Revu pour QT4
 551         """
 552         msgError    = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
 553         ok = False
 554         try:
 555             atLeastOneStudy = self.editor.study
 556             if not atLeastOneStudy:
 557                 return ok, msgError
 558
 559             fileType = { 'ASTER'    : "FICHIER_EFICAS_ASTER",
 560                          'SEP'      : "FICHIER_EFICAS_SEP",
 561                          'MAP'      : "FICHIER_EFICAS_MAP",
 562                          'OPENTURNS': "FICHIER_EFICAS_OPENTURNS",
 563                          'OPENTURNS_STUDY': "FICHIER_EFICAS_OPENTURNS_STUDY",
 564                          'OPENTURNS_WRAPPER': "FICHIER_EFICAS_OPENTURNS_WRAPPER",
 565                          'CARMEL3D': "FICHIER_EFICAS_CARMEL3D",
 566                         }
 567
 568             folderName = {  'ASTER'    :  'AsterFiles',
 569                             'SEP'       : 'OMFiles' ,
 570                             'CARMEL3D'  : 'CARMEL3DFiles' ,
 571                             'MAP'       : 'MapFiles' ,
 572                             'OPENTURNS_STUDY': 'OpenturnsFiles',
 573                             'OPENTURNS_WRAPPER': 'OpenturnsFiles'}
 574
 575             folderType = { 'ASTER':    "ASTER_FILE_FOLDER",
 576                            'SEP':      "SEP_FILE_FOLDER",
 577                            'MAP':      "MAP_FILE_FOLDER",
 578                            'CARMEL3D': "CARMEL3D_FILE_FOLDER",
 579                            'OPENTURNS_STUDY':"OPENTURNS_FILE_FOLDER",
 580                            'OPENTURNS_WRAPPER': "OPENTURNS_FILE_FOLDER"}
 581
 582
 583             moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
 584             itemName    = re.split("/",jdcPath)[-1]
 585
 586             if folderName.has_key(self.code) :
 587                monFolderName=folderName[ self.code ]
 588             else :
 589                monFolderName=str(self.code)+"Files"
 590
 591             if folderType.has_key(self.code) :
 592                monFolderType=fileType[ self.code ]
 593             else :
 594                monFolderType=str(self.code)+"_FILE_FOLDER"
 595
 596             if fileType.has_key(self.code) :
 597                monFileType=fileType[ self.code ]
 598             else :
 599                monFileType="FICHIER_EFICAS_"+str(self.code)
 600
 601             fatherEntry = self.editor.findOrCreateItem(
 602                                     moduleEntry,
 603                                     name = monFolderName,
 604                                     #icon = "ICON_COMM_FOLDER",
 605                                     fileType = monFolderType)
 606
 607             commEntry = self.editor.findOrCreateItem( fatherEntry ,
 608                                            name = itemName,
 609                                            fileType = monFileType,
 610                                            fileName = jdcPath,
 611                                            #icon    = "ICON_COMM_FILE",
 612                                            comment = str( jdcPath ))
 613
 614             salome.sg.updateObjBrowser(1)
 615
 616             #print 'addJdcInSalome commEntry->', commEntry
 617             if commEntry:
 618                 ok, msgError = True, ''
 619         except Exception, exc:
 620             msgError = "Can't add Eficas file to Salome study tree"
 621             logger.debug(msgError, exc_info = True)
 622             QMessageBox.warning(self, self.tr("Warning"),
 623                                 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de détails " % (msgError, exc)))
 624         return ok, msgError
 625
 626
 627     #---------------------------------------
 628     def displayShape(  self, shapeName ):
 629     #---------------------------------------
 630         """
 631         visualisation de nom shapeName dans salome
 632         """
 633         ok, msgError = False, ''
 634         try:
 635         #if 1 :
 636             import SalomePyQt
 637             sgPyQt = SalomePyQt.SalomePyQt()
 638             myActiveView=sgPyQt.getActiveView()
 639             if myActiveView < 0 :
 640                return ok, 'pas de vue courante'
 641
 642             currentViewType=sgPyQt.getViewType(myActiveView)
 643             if str(currentViewType) != "OCCViewer" : # maillage
 644                 ok, msgError = self.displayMeshGroups(shapeName)
 645             else: #geometrie
 646                 current_color = COLORS[ self.icolor % LEN_COLORS ]
 647                 from salome.geom.geomtools import GeomStudyTools
 648                 myGeomTools=GeomStudyTools(self.editor)
 649                 ok = myGeomTools.displayShapeByName( shapeName, current_color )
 650                 salome.sg.FitAll()
 651                 self.icolor = self.icolor + 1
 652                 if not ok:
 653                     msgError =self.tr("Impossible d afficher ")+shapeName
 654         except:
 655         #else :
 656             logger.debug(50*'=')
 657         return ok, msgError
 658
 659     #---------------------------------------
 660     def ChercheGrpMeshInSalome(self):
 661     #---------------------------------------
 662         print "je passe par la"
 663         import SMESH
 664         names, msg = [], ''
 665         try :
 666         #if 1 :
 667            entries = salome.sg.getAllSelected()
 668            nbEntries = len( entries )
 669            names, msg = None, self.tr("Selection SALOME non autorisee.")
 670            if nbEntries == 1:
 671                 for entry in entries:
 672                     names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
 673         except :
 674         #else :
 675            print "bim bam boum"
 676         return(msg,names)
 677
 678     #---------------------------------------
 679     def ChercheGrpMailleInSalome(self):
 680     #---------------------------------------
 681         import SMESH
 682         names, msg = [], ''
 683         try :
 684         #if 1:
 685            entries = salome.sg.getAllSelected()
 686            nbEntries = len( entries )
 687            names, msg = None, self.tr("Selection SALOME non autorisee.")
 688            if nbEntries == 1:
 689                 for entry in entries:
 690                     print entry
 691                     names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
 692                     print names
 693         except :
 694         #else:
 695            print "bim bam boum"
 696         return(msg,names)
 697
 698
 699
 700
 701
 702 #-------------------------------------------------------------------------------------------------------
 703 #    Pilotage de la Visu des elements de structures
 704 #
 705
 706
 707     def envoievisu(self,liste_commandes):
 708         try:
 709             from salome.geom.structelem import StructuralElementManager, InvalidParameterError
 710         except ImportError:
 711             QMessageBox.critical(self, self.tr("Error"),
 712                                  self.tr("Impossible d'afficher les elements de structure: "
 713                                          "module GEOM n est pas  installe."))
 714             return
 715         try:
 716             atLeastOneStudy = self.editor.study
 717             if not atLeastOneStudy:
 718                 return
 719             logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
 720             structElemManager = StructuralElementManager()
 721             elem = structElemManager.createElement(liste_commandes)
 722             elem.display()
 723             salome.sg.updateObjBrowser(True)
 724         except InvalidParameterError, err:
 725             trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
 726                             "greater than %(minval)g (actual value is %(value)g)")
 727             msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
 728                                 "minval": err.minValue, "value": err.value}
 729             QMessageBox.warning(self, self.tr("Error"), msg)
 730         except:
 731             traceback.print_exc()
 732             logger.debug(10*'#'+":pb dans envoievisu")
 733
 734
 735 class SalomeEntry:
 736   """
 737   This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
 738   when Eficas is launched in Salome context. It handles the objects that can
 739   be selected from Salome object browser.
 740   By default, the selected value is the entry of the selected item in the
 741   object browser. This class can be subclassed to provide more advanced
 742   functions.
 743   """
 744
 745   help_message = u"Une entrée de l'arbre d'étude de Salome est attendue"
 746
 747   def __init__(self, entryStr):
 748     self._entry = entryStr
 749
 750   @staticmethod
 751   def __convert__(entryStr):
 752     return SalomeEntry(entryStr)
 753
 754   @staticmethod
 755   def get_selected_value(selected_entry, study_editor):
 756     return selected_entry
 757
 758
 759 #-------------------------------------------------------------------------------------------------------
 760 #           Point d'entree lancement EFICAS
 761 #
 762 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
 763     logger.debug(10*'#'+":runEficas: START")
 764     #global appli
 765     logger.debug(10*'#'+":runEficas: code="+str(code))
 766     logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
 767     logger.debug(10*'#'+":runEficas: module="+str(module))
 768     logger.debug(10*'#'+":runEficas: version="+str(version))
 769
 770     #if not appli: #une seul instance possible!
 771     appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
 772                        module = module, version = version, componentName = componentName,multi=multi )
 773     #if not appli: #une seul instance possible!
 774     #    appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
 775     #                      module = module, componentName = componentName, version=version )
 776     logger.debug(10*'#'+":runEficas: END")
 777
 778