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