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