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