src/EFICASGUI/eficasSalome.py

   1 # -*- coding: utf-8 -*-
   2
   3 from Logger import ExtLogger
   4
   5 import qt
   6 import notifqt
   7 # -----------------------------------------------------------------------------
   8 import sys, os, re,types
   9
  10
  11
  12 """
  13 # Remplacement de la fonction exit standard par une fonction
  14 # qui n'interrompt pas l'execution
  15
  16 sys._exit=sys.exit
  17
  18 def exit(ier):
  19    print "appel de exit: ",ier
  20
  21
  22 # Fin remplacement
  23 """
  24
  25
  26 import eficasConfig
  27
  28 sys.path[:0]=[os.path.join( eficasConfig.eficasPath,'Aster'),
  29               os.path.join( eficasConfig.eficasPath,'Homard'),
  30               os.path.join( eficasConfig.eficasPath,'InterfaceTK'),
  31               os.path.join( eficasConfig.eficasPath,'Editeur'),
  32               eficasConfig.eficasPath,
  33              ]
  34
  35
  36 import Tkinter
  37
  38
  39 # mode de lancement Eficas
  40 ASTER  = "ASTER"
  41 HOMARD = "HOMARD"
  42
  43
  44 import Editeur
  45 try :
  46    from Editeur import eficas
  47    from Editeur import splash
  48 except :
  49    from InterfaceTK import eficas
  50    from InterfaceTK import splash
  51
  52 import salome
  53 import meshGui
  54 import visuDriver
  55 import PALGUI_API
  56 import studyManager
  57
  58 #from qxembed import QXEmbed
  59
  60 import SalomePyQt
  61
  62
  63 from SelectMainShapeDiag_ui import SelectMainShapeDiag
  64 from SelectMeshDiag_ui import SelectMeshDiag
  65
  66
  67
  68 # message utilisateur
  69 msgWarning                 = "Attention"
  70 msgMainShapeSelection      = "On travaille sur la géométrie principale : "
  71 msgSubShapeBadMainShape    = "La sélection géométrique SALOME ne correspond pas à une sous-géométrie de la géométrie principale : "
  72 msgMeshGroupBadMainShape   = "Le groupe de maillage sélectionné dans SALOME ne référence pas la bonne géométrie principale : "
  73 msgIncompleteSelection     = "Tous les éléments de la sélection SALOME n'ont pu étre ajoutée"
  74 msgUnAuthorizedSelecion    = "Sélection SALOME non authorisé. Autorisé : sous-géométrie, groupe de maille"
  75 msgErrorAddJdcInSalome     = "Erreur dans l'export du fichier de commande dans l'arbre d'étude Salome"
  76 msgErrorDisplayShape       = "Erreur dans l'affichage de la forme géométrique sélectionnée"
  77 msgErrorDisplayMeshGroup   = "Erreur dans l'affichage du groupe de maillage sélectionné"
  78 msgErrorNeedSubShape       = "Sélection d'un élément sous géométrique seulement"
  79
  80
  81 msgErrorGroupMaSelection    = "Sélection GROUP_MA ne peut pas prendre un point ou un noeud"
  82 msgWarningGroupNoSelection  = "Attention, GROUP_NO devrait prendre un point ou un noeud"
  83
  84
  85
  86
  87 # couleur pour visualisation des géometrie CS_CBO
  88 COLORS = ( studyManager.RED,
  89          studyManager.GREEN,
  90          studyManager.BLUE,
  91          studyManager.SANDY,
  92          studyManager.ORANGE,
  93          studyManager.PURPLE,
  94          studyManager.DARK_RED,
  95          studyManager.DARK_GREEN,
  96          studyManager.DARK_BLUE,
  97          studyManager.YELLOW,
  98          studyManager.PINK,
  99          studyManager.CYAN )
 100
 101 LEN_COLORS = len( COLORS )
 102
 103
 104
 105
 106 class SelectMainShapeDiagImpl( SelectMainShapeDiag ):
 107     def __init__( self, mainShapeEntries, parent = None,name = None,modal = 1,fl = 0 ):
 108         SelectMainShapeDiag.__init__( self,parent,name,modal,fl )
 109
 110         self.mainShapes = {} # ( entry, value )
 111         for entry in mainShapeEntries:
 112             name = studyManager.palStudy.getName( entry )
 113             self.mainShapes[entry] = name
 114
 115         self.lbMainShapes.clear()
 116         for entry,name in self.mainShapes.items():
 117             self.lbMainShapes.insertItem( name )
 118         self.lbMainShapes.setCurrentItem( 0 )
 119
 120
 121     def getUserSelection( self ):
 122         mainShapeEntry = None
 123
 124         item = self.lbMainShapes.selectedItem()
 125         mainShapeName = str( item.text() )
 126
 127         for entry, name in self.mainShapes.items():
 128             if mainShapeName == name:
 129                 mainShapeEntry = entry
 130                 break
 131
 132         return mainShapeEntry
 133
 134
 135 class SelectMeshDiagImpl( SelectMeshDiag ):
 136     def __init__( self, meshGroupEntries, parent = None,name = None,modal = 1,fl = 0 ):
 137         SelectMeshDiag.__init__( self,parent,name,modal,fl )
 138
 139         self.meshes = {} # ( entry, value )
 140
 141         for meshGroupEntry in meshGroupEntries:
 142             meshEntry = studyManager.palStudy.getMesh(meshGroupEntry)
 143             meshName  = studyManager.palStudy.getName(meshEntry)
 144             self.meshes[meshEntry] = meshName
 145
 146         self.lbMeshes.clear()
 147         for entry,name in self.meshes .items():
 148             self.lbMeshes.insertItem( name )
 149         self.lbMeshes.setCurrentItem( 0 )
 150
 151     def getUserSelection( self ):
 152         selMeshEntry, keep = None, False
 153
 154         item = self.lbMeshes.selectedItem()
 155         meshName = str( item.text() )
 156         for entry, name in self.meshes.items():
 157             if meshName == name:
 158                 selMeshEntry = entry
 159                 break
 160
 161         keep = self.cbAgain.isChecked()
 162
 163         return selMeshEntry, keep
 164
 165
 166
 167
 168 #class MyEficas( Tkinter.Toplevel, eficas.EFICAS, QXEmbed ):
 169 class MyEficas( Tkinter.Toplevel, eficas.EFICAS ):
 170     """
 171     Classe de lancement du logiciel EFICAS dans SALOME.
 172     Cette classe spécialise le logiciel Eficas par l'ajout de:
 173     a)la création de groupes de mailles dans le composant SMESH de SALOME
 174     b)la visualisation d'éléments géométrique dans le coposant GEOM de SALOME par sélection dans EFICAS
 175     """
 176     def __init__( self, parent, code = None, fichier = None, module = studyManager.SEficas, version=None):
 177         """
 178         Constructeur.
 179
 180         @type   parent:
 181         @param  parent: widget Qt parent
 182
 183
 184         @type   code: string
 185         @param  code: catalogue à lancer ( ASTER, HOMARD ). optionnel ( défaut = ASTER ).
 186
 187         @type   fichier: string
 188         @param  fichier: chemin absolu du fichier eficas à ouvrir à dès le lancement. optionnel
 189         """
 190         #QXEmbed.__init__( self, parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 191         Tkinter.Toplevel.__init__( self )
 192
 193         if Editeur.__dict__.has_key( 'session' ):
 194             from Editeur import session
 195             eficasArg = []
 196             eficasArg += sys.argv
 197             if fichier:
 198                 eficasArg += [ fichier ]
 199             if version:
 200                 eficasArg += [ "-c", version ]
 201             session.parse( eficasArg )
 202
 203
 204         #----------------------------------------  initialisation EFICAS  --------------------------
 205         splash.init_splash( self, code = code, titre = "Lancement d'EFICAS pour %s" %code )
 206         splash._splash.configure( text="Chargement d'EFICAS en cours.\n Veuillez patienter ..." )
 207         # différence eficas 1.7 et 1.8
 208
 209         # compatibilite 1.12
 210         V112=0
 211         try :
 212           from Editeur import appli
 213           V112=1
 214         except :
 215           pass
 216
 217         if V112 :
 218             eficas.EFICAS.__init__( self, self, code = code )
 219         else :
 220             eficas.EFICAS.__init__( self, self, code = code , salome = 1)
 221
 222
 223         #---------------------------------------------------------------------------------------------
 224
 225
 226         """
 227         #------  embarcation dans une fenêtre qt pour mise au premier plan  ---
 228         #embedded = QXEmbed( parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 229         embedded = QXEmbed( parent, "" )
 230         #embedded.initialize()
 231         embedded.show()
 232         embedded.embedTk( self.winfo_id() )
 233         size = embedded.sizeHint()
 234         #print 'CS_pbruno size (%s, %s )'%( size.width(), size.height () )
 235         embedded.resize( size.width(), size.height () )
 236         embedded.setWFlags(  qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 237         #---------------------------------------------------------------------------------------------
 238         """
 239
 240         #--------------- spécialisation EFICAS dans SALOME  -------------------
 241         self.parent = parent
 242         self.salome = True      #active les parties de code spécifique dans Salome( pour le logiciel Eficas )
 243         self.module = module    #indique sous quel module dans l'arbre d'étude ajouter le JDC.
 244
 245
 246         # donnée pour la création de groupe de maille
 247         self.mainShapeNames   = {} #dictionnaire pour gérer les multiples fichiers possibles ouverts par
 248         self.mainShapeEntries = {} #eficas ( clé = identifiant du JDC ), une mainshape par fichier ouvert.
 249         self.subShapes        = {} #dictionnaire des sous-géométrie de la géométrie principale ( clé = entry, valeur = name )
 250         #----------------------------------------------------------------------
 251
 252         # visualisation groupes de mailles
 253         self.workingMesh = {} #dictionnaire clé = identifiant JDC / valeur = entry Mesh
 254         #----------------------------------------------------------------------
 255
 256         self.icolor = 0  # compteur pour mémoriser la couleur courante
 257
 258
 259     def quit(self):
 260         global appli
 261         appli = None
 262         self.destroy()
 263
 264     def destroy(self):
 265         global appli
 266         appli = None
 267         Tkinter.Toplevel.destroy(self)
 268
 269     def __studySync( self ):
 270         """
 271         IMPORTANT( à appeler préalablement à chaque appel du gestionnaire d'étude ) : spécifique au lancement de Eficas dans Salome,
 272         permet au gestionnaire d'étude ( studyManager.palStudy ) de pointer sur la bonne étude.
 273
 274         Un retour à False indique qu'il n'y a aucune étude active, dans ce cas ne faire aucune opération avec le gestionnaire d'étude(
 275         gros plantage sinon )
 276         """
 277         activeStudyId = salome.sg.getActiveStudyId()
 278
 279         if activeStudyId == 0: # pas d'étude active
 280             return False
 281
 282         if activeStudyId != salome.myStudyId:
 283             studyManager.palStudy.setCurrentStudyID( activeStudyId )
 284
 285         return True
 286
 287
 288     def __createOCCView( self ):
 289         """
 290         Création vue Occ
 291         """
 292         #salome.salome_init()
 293         import iparameters
 294
 295         # On détermine le nombre de GUI states déjà présents dans l'arbre d'étude
 296         GUIStateID = 1
 297
 298         ipar = iparameters.IParameters(salome.myStudy.GetCommonParameters("Interface Applicative", GUIStateID))
 299         properties = ipar.getProperties()
 300
 301         while properties != []:
 302             GUIStateID += 1
 303             ipar = iparameters.IParameters(salome.myStudy.GetCommonParameters("Interface Applicative", GUIStateID))
 304             properties = ipar.getProperties()
 305
 306         print "GUIStateID: ", GUIStateID
 307
 308         #Set up visual properties:
 309         ipar.setProperty("AP_ACTIVE_VIEW", "OCCViewer_0_0")
 310         ipar.setProperty("AP_WORKSTACK_INFO", "(splitter orientation=0 sizes=1045 (views active='OCCViewer_0_0' 'OCCViewer_0_0'))")
 311         ipar.setProperty("AP_SAVEPOINT_NAME", "GUI state: %i"%(GUIStateID))
 312
 313         #Set up lists:
 314         # fill list AP_VIEWERS_LIST
 315         ipar.append("AP_VIEWERS_LIST", "OCCViewer_1")
 316         # fill list OCCViewer_1
 317         ipar.append("OCCViewer_1", "OCC scene:1 - viewer:1")
 318         ipar.append("OCCViewer_1", "1.000000000000e+00*0.000000000000e+00*0.000000000000e+00*5.773502588272e-01*-5.773502588272e-01*5.773502588272e-01*0.000000000000e+00*0.000000000000e+00*0.000000000000e+00*0.000000000000e+00*2.886751294136e+02*-2.886751294136e+02*2.886751294136e+02")
 319
 320         if salome.sg.hasDesktop():
 321             salome.sg.updateObjBrowser(1)
 322             iparameters.getSession().restoreVisualState(GUIStateID)
 323
 324
 325     def __selectWorkingMesh( self, meshGroupEntries ):
 326         """
 327         Sélection intéractive du maillage sur lequel on travail
 328         """
 329         selMeshEntry, keep = None, False
 330         diag = SelectMeshDiagImpl( meshGroupEntries, self.parent  )
 331
 332         if diag.exec_loop() == qt.QDialog.Accepted:
 333             selMeshEntry, keep = diag.getUserSelection()
 334         return selMeshEntry, keep
 335
 336
 337
 338     def __selectMainShape( self, groupeMaNamesIn, groupeNoNamesIn, jdcID ):
 339         """
 340         Sélection intéractive de la main shape
 341         """
 342         groupeMaNamesOut, groupeNoNamesOut = [], []
 343         selectedMainShape  =  None
 344         mainShapes = {}
 345         mainShapeEntries = []
 346
 347         # liste des main shape possibles
 348         for groups in ( groupeMaNamesIn, groupeNoNamesIn ):
 349             for subShapeName in groups:
 350                 entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, subShapeName )
 351                 for entry in entries:
 352                     mainShapeEntry = studyManager.palStudy.getMainShapeEntry( entry )
 353                     if mainShapeEntry != entry:
 354                         if mainShapes.has_key(subShapeName):
 355                             mainShapes[ subShapeName ].append( mainShapeEntry )
 356                         else:
 357                             mainShapes[ subShapeName ] = [ mainShapeEntry ]
 358                         if not mainShapeEntry in mainShapeEntries:
 359                             mainShapeEntries += [ mainShapeEntry ]
 360
 361         if mainShapes:
 362             if len(mainShapeEntries)>1:
 363                 diag = SelectMainShapeDiagImpl( mainShapeEntries, self.parent  )
 364
 365                 if diag.exec_loop() == qt.QDialog.Accepted:
 366                     selectedMainShape = diag.getUserSelection()
 367                     print 'main shape user selection ->',selectedMainShape
 368
 369             else:
 370                 selectedMainShape = mainShapeEntries[0]
 371
 372             self.mainShapeEntries[ jdcID ] = selectedMainShape
 373
 374             # filtre sur la main shape sélectionnée
 375             for name in groupeMaNamesIn:
 376                 try:
 377                     if selectedMainShape in mainShapes[ name ] :
 378                         groupeMaNamesOut += [ name ]
 379                 except:
 380                     pass
 381
 382             for name in groupeNoNamesIn:
 383                 try:
 384                     if selectedMainShape in mainShapes[ name ] :
 385                         groupeNoNamesOut += [ name ]
 386                 except:
 387                     pass
 388
 389         return groupeMaNamesOut, groupeNoNamesOut
 390
 391
 392
 393
 394     def __selectShape( self, jdcID, selectedEntry, kwType = None ):
 395         """
 396         sélection sous-géométrie dans Salome:
 397         -test1) si c'est un élément sous-géométrique .
 398         -test2) si appartient à la géométrie principale.
 399
 400         met à jours la liste self.subShapes si test ok
 401         """
 402         name, msgError = '',''
 403
 404         selectedMainShapeEntry = studyManager.palStudy.getMainShapeEntry( selectedEntry )
 405
 406         if selectedMainShapeEntry and selectedMainShapeEntry != selectedEntry: #ok test1)
 407
 408             tGeo = studyManager.palStudy.getRealShapeType( selectedEntry )
 409             if kwType == "GROUP_NO" and tGeo != studyManager.VERTEX:
 410                 msgError = msgWarningGroupNoSelection
 411             elif kwType == "GROUP_MA" and tGeo == studyManager.VERTEX:
 412                 name, msgError = '', msgErrorGroupMaSelection
 413                 return name, msgError
 414
 415             if not self.mainShapeEntries.has_key( jdcID ):
 416                 self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
 417                 name = studyManager.palStudy.getName( selectedMainShapeEntry )
 418                 msgError = msgMainShapeSelection + name
 419             if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
 420                 name = studyManager.palStudy.getName( selectedEntry )
 421                 self.subShapes[ selectedEntry ] = name
 422             else:
 423                 if not self.mainShapeNames.has_key( jdcID ):
 424                     self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName( self.mainShapeEntries[ jdcID ] )
 425                 msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
 426         else:
 427             name, msgError = '', msgErrorNeedSubShape
 428
 429         return name, msgError
 430
 431
 432
 433     def __selectMeshGroup( self, jdcID, selectedEntry, kwType = None ):
 434         """
 435         sélection groupe de maille dans Salome:
 436         -test 1) si c'est un groupe de maille
 437         -test 2) si le maillage fait référence à la géométrie principale
 438         """
 439         name, msgError = '',''
 440
 441         selectedMeshEntry = studyManager.palStudy.getMesh( selectedEntry )
 442
 443         if selectedMeshEntry: # ok test 1)
 444             tGroup = studyManager.palStudy.getGroupType( selectedEntry )
 445             if kwType == "GROUP_NO" and tGroup != studyManager.NodeGroups:
 446                 msgError = msgWarningGroupNoSelection
 447             elif kwType == "GROUP_MA" and tGroup == studyManager.NodeGroups:
 448                 name, msgError = '', msgErrorGroupMaSelection
 449                 return name, msgError
 450
 451             selectedMainShapeEntry = studyManager.palStudy.getShapeFromMesh( selectedMeshEntry )
 452
 453             if selectedMainShapeEntry: #test 2)
 454                 if not self.mainShapeEntries.has_key( jdcID ):
 455                     self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
 456                     name = studyManager.palStudy.getName( selectedMainShapeEntry )
 457                     msgError = msgMainShapeSelection + name
 458                 if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
 459                     name = studyManager.palStudy.getName( selectedEntry  )  #ok test 2)
 460                 else:
 461                     if not self.mainShapeNames.has_key( jdcID ):
 462                         self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName(
 463                                                             self.mainShapeEntries[ jdcID ] )
 464                     msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
 465             else:
 466                 # on authorise quand même les groupes de maillage ne faisant
 467                 # pas référence à une géométrie principale (dixit CS_CBO )
 468                 name = studyManager.palStudy.getName( selectedEntry )
 469
 470         return name, msgError
 471
 472
 473
 474
 475     def __updateSubShapes( self, jdcID, groupeNames ):
 476         """
 477         mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
 478         """
 479         for name in groupeNames:
 480             entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, name )
 481             for entry in entries:
 482                 if not self.subShapes.has_key( entry ):
 483                     ok, msgError = self.__selectShape( jdcID, entry ) # filtre
 484                     if ok:
 485                         self.subShapes[ entry ] = name
 486
 487     def __getAllGroupeMa(self, item ):
 488         """
 489         Récupère tous les GROUPE_MA dans le JDC courant
 490         """
 491         groupMa = ()
 492         try:
 493             itemName  = item.get_nom()
 494             if 'GROUP_MA' in itemName:
 495                 #print 'CS_pbruno itemName',itemName
 496                 itemValue = item.get_valeur()
 497                 if type( itemValue ) == str:
 498                     groupMa += ( itemValue , )
 499                 elif type( itemValue ) == tuple:
 500                     groupMa += itemValue
 501                 elif type( itemValue ) == list:
 502                     groupMa += tuple(itemValue)
 503                 elif type( itemValue ) == types.InstanceType and itemValue.has_key('GROUP_MA'):
 504                     # pour créer le groupe de mailles dans DEFI_GROUP> CREA_GROUP_MA> GROUP_MA
 505                     groupMa += ( itemValue['GROUP_MA'], )
 506             else:
 507                 children = item._GetSubList()
 508                 for child in children:
 509                     groupMa +=  self.__getAllGroupeMa( child )
 510         except:
 511         # traitement des MCLIST Pour CREA_GROUP_MA
 512             try:
 513                 itemName  = item.get_nom()
 514                 if 'GROUP_MA' in itemName:
 515                     children = item._GetSubList()
 516                     for child in children:
 517                         groupMa +=  self.__getAllGroupeMa( child )
 518             except:
 519                 pass
 520         return groupMa
 521
 522
 523     def __getAllGroupeNo(self, item ):
 524         """
 525         Récupère tous les GROUPE_NO dans le JDC courant
 526         """
 527         groupNo = ()
 528         try:
 529             itemName  = item.get_nom()
 530             if 'GROUP_NO' in itemName:
 531                 itemValue = item.get_valeur()
 532                 if type( itemValue ) == str:
 533                     groupNo += ( itemValue , )
 534                 elif type( itemValue ) == tuple:
 535                     groupNo += itemValue
 536                 elif type( itemValue ) == list:
 537                     groupNo += tuple(itemValue)
 538                 elif type( itemValue ) == types.InstanceType and itemValue.has_key('GROUP_NO'):
 539                     # pour créer le groupe de Noeuds dans DEFI_GROUP> CREA_GROUP_NO> GROUP_NO
 540                     groupNo += ( itemValue['GROUP_NO'], )
 541             else:
 542                 children = item._GetSubList()
 543                 for child in children:
 544                     groupNo += self.__getAllGroupeNo( child )
 545         except:
 546         # traitement des MCLIST Pour CREA_GROUP_NO dans DEFI_GROUP
 547             try:
 548                 itemName  = item.get_nom()
 549                 if 'GROUP_NO' in itemName:
 550                     children = item._GetSubList()
 551                     for child in children:
 552                         groupNo +=  self.__getAllGroupeNo( child )
 553             except:
 554                 pass
 555         return groupNo
 556
 557
 558     #-----------------------  LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
 559     def selectGroupFromSalome( self, kwType = None):
 560         """
 561         Sélection d'élément(s) d'une géométrie ( sub-shape ) ou d'élément(s) de maillage ( groupe de maille) à partir de l'arbre salome
 562         retourne ( la liste des noms des groupes, message d'erreur )
 563
 564         Note: Appelé par EFICAS lorsqu'on clique sur le bouton ajouter à la liste du panel AFF_CHAR_MECA
 565         """
 566         names, msg = [], ''
 567         try:
 568             atLeastOneStudy = self.__studySync()
 569             if not atLeastOneStudy:
 570                 return names, msg
 571             # récupère toutes les sélections de l'utilsateur dans l'arbre Salome
 572             entries = salome.sg.getAllSelected()
 573             nbEntries = len( entries )
 574             if nbEntries >= 1:
 575 #                 jdcID = self.bureau.nb.getcurselection()
 576                 jdcID = self.bureau.JDCDisplay_courant
 577                 for entry in entries:
 578                     if studyManager.palStudy.isMeshGroup( entry ): #sélection d'un groupe de maille
 579                         name, msg = self.__selectMeshGroup( jdcID, entry, kwType )
 580                     elif studyManager.palStudy.isShape( entry ): #sélection d'une sous-géométrie
 581                         name, msg = self.__selectShape( jdcID, entry, kwType )
 582                     else:
 583                         name, msg = '', msgUnAuthorizedSelecion
 584                     if name:
 585                         names.append( name )
 586
 587             if names and len( names ) < nbEntries:
 588                 msg = msgIncompleteSelection
 589             salome.sg.EraseAll()
 590         except:
 591             logger.debug(50*'=')
 592         return names, msg
 593
 594
 595     def addJdcInSalome(  self, jdcPath ):
 596         """
 597         Ajoute le Jeu De Commande ASTER ou HOMARD dans l'arbre d'étude Salome dans la rubrique EFICAS
 598         """
 599         ok, msgError = False, msgErrorAddJdcInSalome
 600         try:
 601             atLeastOneStudy = self.__studySync()
 602             if not atLeastOneStudy:
 603                 return ok, msgError
 604
 605             fileType = { 'ASTER':  studyManager.FICHIER_EFICAS_ASTER,
 606                         'HOMARD': studyManager.FICHIER_EFICAS_HOMARD }
 607
 608             folderName = {  'ASTER':  'AsterFiles',
 609                             'HOMARD': 'HomardFiles' }
 610
 611             moduleEntry = studyManager.palStudy.addComponent(self.module)
 612             itemName    = re.split("/",jdcPath)[-1]
 613
 614             fatherEntry = studyManager.palStudy.addItem(
 615                                     moduleEntry,
 616                                     itemName = folderName[self.bureau.code],
 617                                     itemIcon = "ICON_COMM_FOLDER",
 618                                     itemType = studyManager.ASTER_FILE_FOLDER,
 619                                     bDoublonCheck = True  )
 620
 621             commEntry = studyManager.palStudy.addItem( fatherEntry ,
 622                                                         itemName = itemName,
 623                                                         itemType = fileType[ self.bureau.code ],
 624                                                         itemValue = jdcPath,
 625                                                         itemComment = str( jdcPath ),
 626                                                         itemIcon    = "ICON_COMM_FILE",
 627                                                         bDoublonCheck = True )
 628             studyManager.palStudy.refresh()
 629             print 'addJdcInSalome commEntry->', commEntry
 630             if commEntry:
 631                 ok, msgError = True, ''
 632         except:
 633             logger.debug(50*'=')
 634         return ok, msgError
 635
 636
 637     def createOrUpdateMesh( self ):
 638         """
 639             Ouverture d'une boite de dialogue : Creation de groupes de mailles dans un maillage existant ou un nouveau maillage.
 640             Note: Appelé par EFICAS à la sauvegarde du JDC.
 641         """
 642         try:
 643             atLeastOneStudy = self.__studySync()
 644             if not atLeastOneStudy:
 645                 return
 646
 647 #             jdcID = self.bureau.nb.getcurselection()
 648             jdcID = self.bureau.JDCDisplay_courant
 649
 650             groupeMaNames = self.__getAllGroupeMa( self.bureau.JDCDisplay_courant.tree.item )
 651             groupeNoNames = self.__getAllGroupeNo( self.bureau.JDCDisplay_courant.tree.item )
 652
 653             # on elimine les doublons de la liste
 654             groupeMaNames = dict.fromkeys(groupeMaNames).keys()
 655             groupeNoNames = dict.fromkeys(groupeNoNames).keys()
 656
 657             print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
 658             print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
 659
 660             # mise à jours de la liste des sous-géométrie ( self.subShapes )
 661             if not self.mainShapeEntries.has_key( jdcID ):
 662                 # l'utilisateur n'a sélectionné aucune sous-géométrie et donc pas de géométrie principale
 663                 groupeMaNames, groupeNoNames  = self.__selectMainShape( groupeMaNames, groupeNoNames, jdcID )
 664
 665             if groupeMaNames or groupeNoNames:
 666                 print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
 667                 print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
 668                 self.__updateSubShapes( jdcID, groupeMaNames + groupeNoNames )
 669
 670                 # recupération des identifiants( entries ) associés aux noms des groupes
 671                 groupeMaEntries = []
 672                 groupeNoEntries = []
 673
 674                 for entry, name in self.subShapes.items():
 675                     if name in groupeMaNames:
 676                         groupeMaEntries.append( entry )
 677                     if name in groupeNoNames:
 678                         groupeNoEntries.append( entry )
 679
 680                 if groupeMaEntries or groupeNoEntries:
 681                     diag = meshGui.MeshUpdateDialogImpl(
 682                                 self.mainShapeEntries[jdcID],
 683                                 groupeMaEntries,
 684                                 groupeNoEntries,
 685                                 studyManager.palStudy,
 686                                 self.parent )
 687                     diag.show()
 688
 689             self.subShapes.clear()
 690             self.mainShapeNames.clear()
 691             self.mainShapeEntries.clear()
 692         except:
 693             logger.debug(50*'=')
 694
 695
 696     def displayMeshGroups(self, meshGroupName):
 697         """
 698         visualisation group de maille de nom meshGroupName dans salome
 699         """
 700         ok, msgError = False, ''
 701         try:
 702             sg = salome.ImportComponentGUI('SMESH')
 703             currentjdcID = self.bureau.nb.getcurselection()
 704             meshGroupEntries = []
 705             selMeshEntry = None
 706             selMeshGroupEntry = None
 707
 708             # liste des groupes de maille de nom meshGroupName
 709             listSO = studyManager.palStudy._myStudy.FindObjectByName(meshGroupName, "SMESH")
 710             print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
 711
 712             if len(listSO)>0:
 713                 for SObjet in listSO:
 714                     groupEntry = SObjet.GetID()
 715                     meshGroupEntries += [groupEntry]
 716
 717                 if len(meshGroupEntries)>1:
 718
 719                     # choix d'un maillage
 720                     if not self.workingMesh.has_key(currentjdcID): # aucun maillage de défini par défaut encore
 721                         #selMeshEntry = "0:1:3:5" #CS_pbruno todo : choix maillage + test si c un maillage
 722                         selMeshEntry, keep = self.__selectWorkingMesh(meshGroupEntries)
 723                         if keep:
 724                             self.workingMesh[currentjdcID] = selMeshEntry
 725                     else: # déja un de défini par défaut
 726                         selMeshEntry = self.workingMesh[currentjdcID]
 727
 728                     # le groupe de maille est il ds ce maillage?
 729                     lselMeshEntry = len(selMeshEntry)
 730                     for groupEntry in meshGroupEntries:
 731                         if selMeshEntry == groupEntry[0:lselMeshEntry]:
 732                             selMeshGroupEntry = groupEntry
 733                             break
 734
 735                 else:
 736                     selMeshGroupEntry = meshGroupEntries[0]
 737
 738                 # on affiche le groupe ds la vue VTK
 739                 if selMeshGroupEntry:
 740                     #CS_pbruno: marche QUE si le module SMESH est activé
 741                     myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
 742                     SCom        = studyManager.palStudy._myStudy.FindComponent("SMESH")
 743                     studyManager.palStudy._myBuilder.LoadWith( SCom , myComponent  )
 744                     sg.CreateAndDisplayActor(selMeshGroupEntry)
 745                     salome.sg.Display(selMeshGroupEntry)
 746                     salome.sg.FitAll()
 747                     ok = True
 748         except:
 749             msgError = msgErrorDisplayMeshGroup
 750             logger.debug(50*'=')
 751         return ok, msgError
 752
 753
 754     def displayShape(  self, shapeName ):
 755         """
 756         visualisation géométrie de nom shapeName dans salome
 757         """
 758         ok, msgError = False, ''
 759         try:
 760             import VISU
 761             import visu_gui
 762             currentViewType = None
 763             m = visu_gui.myVisu.GetViewManager()
 764             v = m.GetCurrentView()
 765             if v:
 766                 currentViewType = v.GetType()
 767
 768             atLeastOneStudy = self.__studySync()
 769             if not atLeastOneStudy:
 770                 return ok, msgError
 771
 772             #salome.sg.EraseAll()
 773             print 'displayShapestrGeomShape shapeName -> ', shapeName
 774
 775             if currentViewType == VISU.TVIEW3D: # maillage
 776                 print 'Vue courante = VTK : affichage groupe de maille'
 777                 ok, msgError = self.displayMeshGroups(shapeName)
 778             else: #geometrie
 779                 print 'Vue courante = OCC : affichage element geometrique'
 780                 #self.__createOCCView()
 781                 current_color = COLORS[ self.icolor % LEN_COLORS ]
 782                 ok = studyManager.palStudy.displayShapeByName( shapeName, current_color )
 783                 salome.sg.FitAll()
 784                 self.icolor = self.icolor + 1
 785                 if not ok:
 786                     msgError = msgErrorDisplayShape
 787         except:
 788             logger.debug(50*'=')
 789         return ok, msgError
 790
 791
 792     def creeConfigTxt(self,fichier,dico):
 793         """
 794            sauvegarde = asksaveasfilename(title="fichier config.txt",
 795                                      defaultextension='.txt',
 796                                      initialdir = fichier)
 797            f=open(sauvegarde,'w+')
 798            for unite in dico.keys():
 799                 print unite
 800                 type=dico[unite][0]
 801                 fic=dico[unite][1:]
 802                 ligne="fort."+str(unite)+" "+type+" "+fic
 803                 f.write(ligne)
 804            f.close()
 805            self.rangeInStudy(sauvegarde)
 806            print "==============================="
 807            print "fin crreConfigTxt"
 808         """
 809         pass #CS_pbruno à implémenter
 810
 811
 812     def buildCabriGeom( self, name, **param ):
 813         """
 814         visualisation dans GEOM d'une géométrie CABRI
 815         """
 816         import cabri
 817         qt.QApplication.setOverrideCursor( qt.QCursor.waitCursor )
 818         cabri.tetra( name, **param )
 819         qt.QApplication.restoreOverrideCursor()
 820
 821
 822
 823 #-------------------------------------------------------------------------------------------------------
 824 #    Pilotage de la Visu des elements de structures
 825 #
 826
 827     def envoievisu(self,liste_commandes):
 828         #try:
 829         if ( 1 == 1 ):
 830             atLeastOneStudy = self.__studySync()
 831             if not atLeastOneStudy:
 832                 return
 833             monDriver=visuDriver.visuDriver(studyManager.palStudy,liste_commandes)
 834             monId = monDriver.analyse()
 835             PALGUI_API.displaySE(monId)
 836
 837         else:
 838         #except:
 839             print "boum dans envoievisu"
 840
 841
 842
 843 #-------------------------------------------------------------------------------------------------------
 844 #           Point d'entree lancement EFICAS
 845 #
 846 def runEficas( code="ASTER", fichier=None, module = studyManager.SEficas, version=None ):
 847     global appli
 848     if not appli: #une seul instance possible!
 849         appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier, module = module, version=version )
 850
 851
 852
 853 # pour compatibilitee
 854 def runHomard( code="HOMARD", fichier=None ):
 855     global appli
 856     if not appli: #une seul instance possible!
 857         appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier )
 858
 859
 860
 861
 862 """
 863 def runAster(parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.palStudy, code="ASTER", fichier=None ) :
 864     global appli
 865     if not appli: #une seul instance possible!
 866         appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
 867 """
 868
 869
 870
 871 # Init globale du module
 872 root = Tkinter.Tk()
 873 root.withdraw()
 874
 875
 876 appli = None
 877
 878
 879
 880 logger=ExtLogger( "eficasSalome.py" )
 881
 882
 883
 884