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