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