src/EFICASGUI/eficasSalome.py

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