src/EFICASGUI/eficasSalome.py

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