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 selectEntryFromSalome( self, kwType = None, editor=None):
 504     #----------------------------------------------------------------
 505         """
 506         Selection d'element a partir de l'arbre salome
 507         Ne verifie que l unicite de la selection
 508         retourne ( la liste avec le  nom du groupe, message d'erreur )
 509
 510         retourne une liste pour etre coherent avec selectGroupFromSalome
 511         Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
 512         """
 513         try:
 514             if self.editor.study._non_existent():
 515                raise Exception(self.tr(u"L'étude Salome n'existe plus"))
 516             entries = salome.sg.getAllSelected()
 517             nbEntries = len( entries )
 518             if nbEntries < 1:
 519                raise Exception(self.tr(u"Veuillez sélectionner une entrée de l'arbre d'étude de Salome"))
 520             elif nbEntries > 1 :
 521                raise Exception(self.tr(u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"))
 522
 523             value = kwType.get_selected_value(entries[0], self.editor)
 524             msg = self.tr(u"L'entrée de l'arbre d'étude de Salome a été sélectionnée")
 525             return [value], msg
 526         except Exception, e:
 527             QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), unicode(e))
 528             return [], unicode(e)
 529
 530
 531     #---------------------------------------------
 532     def addJdcInSalome(  self, jdcPath ):
 533     #---------------------------------------------
 534         """
 535         Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
 536         Revu pour QT4
 537         """
 538         msgError    = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
 539         ok = False
 540         try:
 541             atLeastOneStudy = self.editor.study
 542             if not atLeastOneStudy:
 543                 return ok, msgError
 544
 545             fileType = { 'ASTER'    : "FICHIER_EFICAS_ASTER",
 546                          'SEP'      : "FICHIER_EFICAS_SEP",
 547                          'MAP'      : "FICHIER_EFICAS_MAP",
 548                          'OPENTURNS': "FICHIER_EFICAS_OPENTURNS",
 549                          'OPENTURNS_STUDY': "FICHIER_EFICAS_OPENTURNS_STUDY",
 550                          'OPENTURNS_WRAPPER': "FICHIER_EFICAS_OPENTURNS_WRAPPER",
 551                          'CARMEL3D': "FICHIER_EFICAS_CARMEL3D",
 552                         }
 553
 554             folderName = {  'ASTER'    :  'AsterFiles',
 555                             'SEP'       : 'OMFiles' ,
 556                             'CARMEL3D'  : 'CARMEL3DFiles' ,
 557                             'MAP'       : 'MapFiles' ,
 558                             'OPENTURNS_STUDY': 'OpenturnsFiles',
 559                             'OPENTURNS_WRAPPER': 'OpenturnsFiles'}
 560
 561             folderType = { 'ASTER':    "ASTER_FILE_FOLDER",
 562                            'SEP':      "SEP_FILE_FOLDER",
 563                            'MAP':      "MAP_FILE_FOLDER",
 564                            'CARMEL3D': "CARMEL3D_FILE_FOLDER",
 565                            'OPENTURNS_STUDY':"OPENTURNS_FILE_FOLDER",
 566                            'OPENTURNS_WRAPPER': "OPENTURNS_FILE_FOLDER"}
 567
 568
 569             moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
 570             itemName    = re.split("/",jdcPath)[-1]
 571
 572             if folderName.has_key(self.code) :
 573                monFolderName=folderName[ self.code ]
 574             else :
 575                monFolderName=str(self.code)+"Files"
 576
 577             if folderType.has_key(self.code) :
 578                monFolderType=fileType[ self.code ]
 579             else :
 580                monFolderType=str(self.code)+"_FILE_FOLDER"
 581
 582             if fileType.has_key(self.code) :
 583                monFileType=fileType[ self.code ]
 584             else :
 585                monFileType="FICHIER_EFICAS_"+str(self.code)
 586
 587             fatherEntry = self.editor.findOrCreateItem(
 588                                     moduleEntry,
 589                                     name = monFolderName,
 590                                     #icon = "ICON_COMM_FOLDER",
 591                                     fileType = monFolderType)
 592
 593             commEntry = self.editor.findOrCreateItem( fatherEntry ,
 594                                            name = itemName,
 595                                            fileType = monFileType,
 596                                            fileName = jdcPath,
 597                                            #icon    = "ICON_COMM_FILE",
 598                                            comment = str( jdcPath ))
 599
 600             salome.sg.updateObjBrowser(1)
 601
 602             #print 'addJdcInSalome commEntry->', commEntry
 603             if commEntry:
 604                 ok, msgError = True, ''
 605         except Exception, exc:
 606             msgError = "Can't add Eficas file to Salome study tree"
 607             logger.debug(msgError, exc_info = True)
 608             QMessageBox.warning(self, self.tr("Warning"),
 609                                 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de détails " % (msgError, exc)))
 610         return ok, msgError
 611
 612
 613     #---------------------------------------
 614     def displayShape(  self, shapeName ):
 615     #---------------------------------------
 616         """
 617         visualisation de nom shapeName dans salome
 618         """
 619         ok, msgError = False, ''
 620         #try:
 621         if 1 :
 622             import SalomePyQt
 623             sgPyQt = SalomePyQt.SalomePyQt()
 624             myActiveView=sgPyQt.getActiveView()
 625             if myActiveView < 0 :
 626                return ok, 'pas de vue courante'
 627
 628             currentViewType=sgPyQt.getViewType(myActiveView)
 629             if str(currentViewType) != "OCCViewer" : # maillage
 630                 ok, msgError = self.displayMeshGroups(shapeName)
 631             else: #geometrie
 632                 current_color = COLORS[ self.icolor % LEN_COLORS ]
 633                 from salome.geom.geomtools import GeomStudyTools
 634                 myGeomTools=GeomStudyTools(self.editor)
 635                 ok = myGeomTools.displayShapeByName( shapeName, current_color )
 636                 salome.sg.FitAll()
 637                 self.icolor = self.icolor + 1
 638                 if not ok:
 639                     msgError =self.tr("Impossible d afficher ")+shapeName
 640         #except:
 641         else :
 642             logger.debug(50*'=')
 643         return ok, msgError
 644
 645     #---------------------------------------
 646     def ChercheGrpMeshInSalome(self):
 647     #---------------------------------------
 648         #print "je passe par la"
 649         import SMESH
 650         names, msg = [], ''
 651         try :
 652            entries = salome.sg.getAllSelected()
 653            nbEntries = len( entries )
 654            names, msg = None, self.tr("Selection SALOME non autorisee.")
 655            if nbEntries == 1:
 656                 for entry in entries:
 657                     names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
 658         except :
 659            print "bim bam boum"
 660         return(msg,names)
 661
 662     #---------------------------------------
 663     def ChercheGrpMailleInSalome(self):
 664     #---------------------------------------
 665         import SMESH
 666         names, msg = [], ''
 667         try :
 668         #if 1:
 669            entries = salome.sg.getAllSelected()
 670            nbEntries = len( entries )
 671            names, msg = None, self.tr("Selection SALOME non autorisee.")
 672            if nbEntries == 1:
 673                 for entry in entries:
 674                     print entry
 675                     names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
 676                     print names
 677         except :
 678         #else:
 679            print "bim bam boum"
 680         return(msg,names)
 681
 682
 683
 684
 685
 686 #-------------------------------------------------------------------------------------------------------
 687 #    Pilotage de la Visu des elements de structures
 688 #
 689
 690
 691     def envoievisu(self,liste_commandes):
 692         try:
 693             from salome.geom.structelem import StructuralElementManager, InvalidParameterError
 694         except ImportError:
 695             QMessageBox.critical(self, self.tr("Error"),
 696                                  self.tr("Impossible d'afficher les elements de structure: "
 697                                          "module GEOM n est pas  installe."))
 698             return
 699         try:
 700             atLeastOneStudy = self.editor.study
 701             if not atLeastOneStudy:
 702                 return
 703             logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
 704             structElemManager = StructuralElementManager()
 705             elem = structElemManager.createElement(liste_commandes)
 706             elem.display()
 707             salome.sg.updateObjBrowser(True)
 708         except InvalidParameterError, err:
 709             trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
 710                             "greater than %(minval)g (actual value is %(value)g)")
 711             msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
 712                                 "minval": err.minValue, "value": err.value}
 713             QMessageBox.warning(self, self.tr("Error"), msg)
 714         except:
 715             traceback.print_exc()
 716             logger.debug(10*'#'+":pb dans envoievisu")
 717
 718
 719 class SalomeEntry:
 720   """
 721   This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
 722   when Eficas is launched in Salome context. It handles the objects that can
 723   be selected from Salome object browser.
 724   By default, the selected value is the entry of the selected item in the
 725   object browser. This class can be subclassed to provide more advanced
 726   functions.
 727   """
 728
 729   help_message = u"Une entrée de l'arbre d'étude de Salome est attendue"
 730
 731   def __init__(self, entryStr):
 732     self._entry = entryStr
 733
 734   @staticmethod
 735   def __convert__(entryStr):
 736     return SalomeEntry(entryStr)
 737
 738   @staticmethod
 739   def get_selected_value(selected_entry, study_editor):
 740     return selected_entry
 741
 742
 743 #-------------------------------------------------------------------------------------------------------
 744 #           Point d'entree lancement EFICAS
 745 #
 746 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
 747     logger.debug(10*'#'+":runEficas: START")
 748     #global appli
 749     logger.debug(10*'#'+":runEficas: code="+str(code))
 750     logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
 751     logger.debug(10*'#'+":runEficas: module="+str(module))
 752     logger.debug(10*'#'+":runEficas: version="+str(version))
 753
 754     #if not appli: #une seul instance possible!
 755     appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
 756                        module = module, version = version, componentName = componentName,multi=multi )
 757     #if not appli: #une seul instance possible!
 758     #    appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
 759     #                      module = module, componentName = componentName, version=version )
 760     logger.debug(10*'#'+":runEficas: END")
 761
 762