src/EFICASGUI/eficasSalome.py

   1 from Logger import ExtLogger
   2
   3 import qt
   4 import notifqt
   5 # -----------------------------------------------------------------------------
   6 import sys, os
   7
   8
   9
  10 """
  11 # Remplacement de la fonction exit standard par une fonction
  12 # qui n'interrompt pas l'execution
  13
  14 sys._exit=sys.exit
  15
  16 def exit(ier):
  17    print "appel de exit: ",ier
  18
  19
  20 # Fin remplacement
  21 """
  22
  23
  24 import eficasConfig
  25
  26 sys.path[:0]=[os.path.join( eficasConfig.eficasPath,'Aster'),
  27               os.path.join( eficasConfig.eficasPath,'Homard'),
  28               os.path.join( eficasConfig.eficasPath,'Editeur'),
  29               eficasConfig.eficasPath,
  30              ]
  31
  32
  33 import Tkinter
  34
  35
  36 # mode de lancement Eficas
  37 ASTER  = "ASTER"
  38 HOMARD = "HOMARD"
  39
  40
  41 import Editeur
  42 from Editeur import eficas
  43 from Editeur import splash
  44
  45 import salome
  46 import meshGui
  47 import studyManager
  48
  49 #from qxembed import QXEmbed
  50
  51 import SalomePyQt
  52
  53
  54
  55 # message utilisateur
  56 msgWarning                 = "Attention"
  57 msgSubShapeBadMainShape    = "La sélection géométrique SALOME ne correspond pas à une sous-géométrie de la géométrie principale : "
  58 msgMeshGroupBadMainShape   = "Le groupe de maillage sélectionné dans SALOME ne référence pas la bonne géométrie principale : "
  59 msgIncompleteSelection     = "Tous les éléments de la sélection SALOME n'ont pu étre ajoutée"
  60 msgUnAuthorizedSelecion    = "Sélection SALOME non authorisé. Autorisé : sous-géométrie, groupe de maille"
  61 msgErrorAddJdcInSalome     = "Erreur dans l'export du fichier de commande dans l'arbre d'étude Salome"
  62 msgErrorDisplayShape       = "Erreur dans l'affichage de la forme géométrique sélectionnée"
  63
  64
  65 # couleur pour visualisation des géometrie CS_CBO
  66 COLORS = ( studyManager.RED,
  67          studyManager.GREEN,
  68          studyManager.BLUE,
  69          studyManager.SANDY,
  70          studyManager.ORANGE,
  71          studyManager.PURPLE,
  72          studyManager.DARK_RED,
  73          studyManager.DARK_GREEN,
  74          studyManager.DARK_BLUE,
  75          studyManager.YELLOW,
  76          studyManager.PINK,
  77          studyManager.CYAN )
  78
  79 LEN_COLORS = len( COLORS )
  80
  81
  82
  83 #class MyEficas( Tkinter.Toplevel, eficas.EFICAS, QXEmbed ):
  84 class MyEficas( Tkinter.Toplevel, eficas.EFICAS ):
  85     """
  86     Classe de lancement du logiciel EFICAS dans SALOME.
  87     Cette classe spécialise le logiciel Eficas par l'ajout de:
  88     a)la création de groupes de mailles dans le composant SMESH de SALOME
  89     b)la visualisation d'éléments géométrique dans le coposant GEOM de SALOME par sélection dans EFICAS
  90     """
  91     def __init__(self, parent, code = None, fichier = None ):
  92         """
  93         Constructeur.
  94
  95         @type   parent:
  96         @param  parent: widget Qt parent
  97
  98
  99         @type   code: string
 100         @param  code: catalogue à lancer ( ASTER, HOMARD ). optionnel ( défaut = ASTER ).
 101
 102         @type   fichier: string
 103         @param  fichier: chemin absolu du fichier eficas à ouvrir à dès le lancement. optionnel
 104         """
 105         #QXEmbed.__init__( self, parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 106         Tkinter.Toplevel.__init__( self )
 107
 108         if Editeur.__dict__.has_key( 'session' ):
 109             print 'CS_pbruno has_key session'
 110             from Editeur import session
 111             eficasArg = []
 112             eficasArg += sys.argv
 113             if fichier:
 114                 eficasArg += [ fichier ]
 115             session.parse( eficasArg )
 116
 117
 118         #----------------------------  initialisation EFICAS  -----------------
 119         splash.init_splash( self, code = code, titre = "Lancement d'EFICAS pour %s" %code )
 120         splash._splash.configure( text="Chargement d'EFICAS en cours.\n Veuillez patienter ..." )
 121         # différence eficas 1.7 et 1.8
 122
 123
 124         eficas.EFICAS.__init__( self, self, code = code )
 125
 126
 127         #----------------------------------------------------------------------
 128
 129
 130         """
 131         #------  embarcation dans une fenêtre qt pour mise au premier plan  ---
 132         #embedded = QXEmbed( parent, "", qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 133         embedded = QXEmbed( parent, "" )
 134         #embedded.initialize()
 135         embedded.show()
 136         embedded.embedTk( self.winfo_id() )
 137         size = embedded.sizeHint()
 138         print 'CS_pbruno size (%s, %s )'%( size.width(), size.height () )
 139         embedded.resize( size.width(), size.height () )
 140         embedded.setWFlags(  qt.Qt.WDestructiveClose | qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 141         #----------------------------------------------------------------------
 142         """
 143
 144         #--------------- spécialisation EFICAS dans SALOME  -------------------
 145         self.parent = parent
 146         self.salome = True      #active les parties de code spécifique dans Salome( pour le logiciel Eficas )
 147
 148
 149         # donnée pour la création de groupe de maille
 150         self.mainShapeNames   = {} #dictionnaire pour gérer les multiples fichiers possibles ouverts par
 151         self.mainShapeEntries = {} #eficas ( clé = identifiant du JDC ), une mainshape par fichier ouvert.
 152         self.subShapes        = {} #dictionnaire des sous-géométrie de la géométrie principale ( clé = entry, valeur = name )
 153         #----------------------------------------------------------------------
 154
 155
 156         self.icolor = 0  # compteur pour mémoriser la couleur courante
 157
 158
 159     def quit(self):
 160         global appli
 161         self.destroy()
 162         appli = None
 163
 164
 165     def __studySync( self ):
 166         """
 167         IMPORTANT( à appeler préalablement à chaque appel du gestionnaire d'étude ) : spécifique au lancement de Eficas dans Salome,
 168         permet au gestionnaire d'étude ( studyManager.palStudy ) de pointer sur la bonne étude.
 169
 170         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(
 171         gros plantage sinon )
 172         """
 173         activeStudyId = salome.sg.getActiveStudyId()
 174         #print 50*'='
 175         #print 'activeStudyId->',activeStudyId
 176         #print 'salome.myStudyId->',salome.myStudyId
 177         #print 50*'='
 178
 179         if activeStudyId == 0: # pas d'étude active
 180             return False
 181
 182         if activeStudyId != salome.myStudyId:
 183             studyManager.palStudy.setCurrentStudyID( activeStudyId )
 184
 185         return True
 186
 187
 188
 189
 190     def __selectShape( self, jdcID, selectedEntry ):
 191         """
 192         sélection sous-géométrie dans Salome:
 193         -test1) si c'est un élément géométrique.
 194         -test2) si appartient à la géométrie principale.
 195
 196         met à jours la liste self.subShapes si test ok
 197         """
 198         print 'CS_pbruno __selectShape'
 199         name, msgError = '',''
 200
 201         selectedMainShapeEntry = studyManager.palStudy.getMainShapeEntry( selectedEntry )
 202
 203         if selectedMainShapeEntry: #ok test1)
 204             if not self.mainShapeEntries.has_key( jdcID ):
 205                 self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
 206             if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
 207                 name = studyManager.palStudy.getName( selectedEntry )
 208                 self.subShapes[ selectedEntry ] = name
 209             else:
 210                 print 'CS_pbruno pas la même mainshape selectedEntry->',selectedEntry
 211                 if not self.mainShapeNames.has_key( jdcID ):
 212                     self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName( self.mainShapeEntries[ jdcID ] )
 213                 msgError = msgSubShapeBadMainShape + self.mainShapeNames[ jdcID ]
 214
 215         return name, msgError
 216
 217
 218
 219     def __selectMeshGroup( self, jdcID, selectedEntry ):
 220         """
 221         sélection groupe de maille dans Salome:
 222         -test 1) si c'est un groupe de maille
 223         -test 2) si le maillage fait référence à la géométrie principale
 224         """
 225         print 'CS_pbruno __selectMeshGroup'
 226         name, msgError = '',''
 227
 228         selectedMeshEntry = studyManager.palStudy.getMesh( selectedEntry )
 229
 230         if selectedMeshEntry: # ok test 1)
 231             print 'CS_pbruno __selectMeshGroup selectedMeshEntry',selectedMeshEntry
 232             selectedMainShapeEntry = studyManager.palStudy.getShapeFromMesh( selectedMeshEntry )
 233
 234             if selectedMainShapeEntry: #test 2)
 235                 print 'CS_pbruno __selectMeshGroup selectedMainShapeEntry',selectedMainShapeEntry
 236                 if not self.mainShapeEntries.has_key( jdcID ):
 237                     self.mainShapeEntries[ jdcID ] = selectedMainShapeEntry
 238                 if selectedMainShapeEntry == self.mainShapeEntries[ jdcID ]:
 239                     name = studyManager.palStudy.getName( selectedEntry  )  #ok test 2)
 240                 else:
 241                     print 'CS_pbruno pas la même mainshape selectedEntry ->',selectedEntry
 242                     if not self.mainShapeNames.has_key( jdcID ):
 243                         self.mainShapeNames[ jdcID ] = studyManager.palStudy.getName( self.mainShapeEntries[ jdcID ] )
 244                     msgError = msgMeshGroupBadMainShape + self.mainShapeNames[ jdcID ]
 245
 246         return name, msgError
 247
 248
 249
 250
 251     def __updateSubShapes( self, jdcID, groupeNames ):
 252         """
 253         mise à jours de la liste self.subShapes à partir de la liste des noms de groupe fourni en entré
 254         """
 255         for name in groupeNames:
 256             entries = studyManager.palStudy.getEntriesFromName( studyManager.SGeom, name )
 257             for entry in entries:
 258                 ok, msgError = self.__selectShape( jdcID, entry ) # filtre
 259                 if ok:
 260                     self.subShapes[ entry ] = name
 261
 262
 263     def __getAllGroupeMa(self, item ):
 264         """
 265         Récupère tous les GROUPE_MA dans le JDC courant
 266         """
 267         groupMa = ()
 268         try:
 269             itemName  = item.get_nom()
 270             #print 'CS_pbruno itemName',itemName
 271             if itemName == 'GROUP_MA':
 272                 itemValue = item.get_valeur()
 273                 print 'CS_pbruno trouvé! GROUP_MA->', itemValue
 274                 if type( itemValue ) == str:
 275                     groupMa += ( itemValue , )
 276                 elif type( itemValue ) == tuple:
 277                     groupMa += itemValue
 278             else:
 279                 children = item.GetSubList()
 280                 for child in children:
 281                     groupMa +=  self.__getAllGroupeMa( child )
 282         except: # à cause de GetSubList()...
 283             pass
 284         print 'CS_pbruno groupMa',groupMa
 285         return groupMa
 286
 287
 288     def __getAllGroupeNo(self, item ):
 289         """
 290         Récupère tous les GROUPE_NO dans le JDC courant
 291         """
 292         groupNo = ()
 293         try:
 294             itemName  = item.get_nom()
 295             print 'CS_pbruno itemName',itemName
 296             if itemName == 'GROUP_NO':
 297                 itemValue = item.get_valeur()
 298                 print 'CS_pbruno trouvé! GROUP_NO->', itemValue
 299                 if type( itemValue ) == str:
 300                     groupNo += ( itemValue , )
 301                 elif type( itemValue ) == tuple:
 302                     groupNo += itemValue
 303             else:
 304                 children = item.GetSubList()
 305                 for child in children:
 306                     groupNo += self.__getAllGroupeNo( child )
 307         except: # à cause de GetSubList()...
 308             pass
 309         return groupNo
 310
 311     #-----------------------  LISTE DES NOUVEAUX CAS D'UTILISATIONS -----------
 312     def selectGroupFromSalome( self ):
 313         """
 314         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
 315         retourne ( la liste des noms des groupes, message d'erreur )
 316
 317         Note: Appelé par EFICAS lorsqu'on clique sur le bouton ajouter à la liste du panel AFF_CHAR_MECA
 318         """
 319         names, msg = [], ''
 320         try:
 321             atLeastOneStudy = self.__studySync()
 322             if not atLeastOneStudy:
 323                 return names, msg
 324             # récupère toutes les sélections de l'utilsateur dans l'arbre Salome
 325             entries = salome.sg.getAllSelected()
 326             print 'CS_pbruno entries->',entries
 327             nbEntries = len( entries )
 328             if nbEntries >= 1:
 329                 print 'CS_pbruno len( entries ) >= 1:'
 330                 jdcID = self.bureau.nb.getcurselection()
 331                 for entry in entries:
 332                     if studyManager.palStudy.isMeshGroup( entry ): #sélection d'un groupe de maille
 333                         name, msg = self.__selectMeshGroup( jdcID, entry )
 334                     elif studyManager.palStudy.isShape( entry ): #sélection d'une sous-géométrie
 335                         name, msg = self.__selectShape( jdcID, entry )
 336                     else:
 337                         name, msg = '', msgUnAuthorizedSelecion
 338                     if name:
 339                         names.append( name )
 340
 341             if names and len( names ) < nbEntries:
 342                 msg = msgIncompleteSelection
 343             salome.sg.EraseAll()
 344         except:
 345             logger.debug(50*'=')
 346         print 'CS_pbruno selectGroupFromSalome names = ',names
 347         return names, msg
 348
 349
 350     def addJdcInSalome(  self, jdcPath ):
 351         """
 352         Ajoute le Jeu De Commande ASTER ou HOMARD dans l'arbre d'étude Salome dans la rubrique EFICAS
 353         """
 354         ok, msgError = False, ''
 355         try:
 356             atLeastOneStudy = self.__studySync()
 357             if not atLeastOneStudy:
 358                 return ok, msgError
 359             if self.bureau.code == 'ASTER':
 360                 ok = studyManager.palStudy.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_ASTER )
 361             elif self.bureau.code == 'HOMARD':
 362                 ok = studyManager.palStudy.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_HOMARD )
 363                 #ok = studyManager.palStudy.addEficasItem( jdcPath, studyManager.FICHIER_EFICAS_HOMARD_CONF ) CS_pbruno ?????
 364             if not ok:
 365                 msgError = msgErrorAddJdcInSalome
 366         except:
 367             logger.debug(50*'=')
 368         return ok, msgError
 369
 370
 371     def createOrUpdateMesh( self ):
 372         """
 373             Ouverture d'une boite de dialogue : Creation de groupes de mailles dans un maillage existant ou un nouveau maillage.
 374             Note: Appelé par EFICAS à la sauvegarde du JDC.
 375         """
 376         try:
 377             atLeastOneStudy = self.__studySync()
 378             if not atLeastOneStudy:
 379                 return
 380
 381             jdcID   = self.bureau.nb.getcurselection()
 382
 383             groupeMaNames = self.__getAllGroupeMa( self.bureau.JDCDisplay_courant.tree.item )
 384             groupeNoNames = self.__getAllGroupeNo( self.bureau.JDCDisplay_courant.tree.item )
 385
 386             print 'CS_pbruno createOrUpdateMesh groupeMaNames', groupeMaNames
 387             print 'CS_pbruno createOrUpdateMesh groupeNoNames', groupeNoNames
 388
 389             # mise à jours de la liste des sous-géométrie ( self.subShapes )
 390             self.__updateSubShapes( jdcID, groupeMaNames )
 391             self.__updateSubShapes( jdcID, groupeNoNames )
 392
 393
 394             # recupération des identifiants( entries ) associés aux noms des groupes
 395             groupeMaEntries = []
 396             groupeNoEntries = []
 397
 398             for entry, name in self.subShapes.items():
 399                 if name in groupeMaNames:
 400                     groupeMaEntries.append( entry )
 401                 if name in groupeNoNames:
 402                     groupeNoEntries.append( entry )
 403
 404             print 'CS_pbruno groupeMaEntries ->',groupeMaEntries
 405             print 'CS_pbruno groupeNoEntries ->',groupeNoEntries
 406             if groupeMaEntries or groupeNoEntries:
 407                 print 'if groupeMaEntries or groupeNoEntries:'
 408                 diag = meshGui.MeshUpdateDialogImpl( self.mainShapeEntries[jdcID], groupeMaEntries, groupeNoEntries, studyManager.palStudy,
 409                                                      self.parent )
 410                 diag.show()
 411         except:
 412             logger.debug(50*'=')
 413
 414
 415     def displayShape(  self, shapeName ):
 416         """
 417         visualisation géométrie de nom shapeName dans salome
 418         """
 419         ok, msgError = False, ''
 420         try:
 421             atLeastOneStudy = self.__studySync()
 422             if not atLeastOneStudy:
 423                 return ok, msgError
 424
 425
 426             #salome.sg.EraseAll()
 427             print 'displayShapestrGeomShape shapeName -> ', shapeName
 428             current_color = COLORS[ self.icolor % LEN_COLORS ]
 429             ok = studyManager.palStudy.displayShapeByName( shapeName, current_color )
 430             self.icolor = self.icolor + 1
 431
 432             if not ok:
 433                 msgError = msgErrorDisplayShape
 434         except:
 435             logger.debug(50*'=')
 436         return ok, msgError
 437
 438
 439     def creeConfigTxt(self,fichier,dico):
 440         """
 441            sauvegarde = asksaveasfilename(title="fichier config.txt",
 442                                      defaultextension='.txt',
 443                                      initialdir = fichier)
 444            f=open(sauvegarde,'w+')
 445            for unite in dico.keys():
 446                 print unite
 447                 type=dico[unite][0]
 448                 fic=dico[unite][1:]
 449                 ligne="fort."+str(unite)+" "+type+" "+fic
 450                 f.write(ligne)
 451            f.close()
 452            self.rangeInStudy(sauvegarde)
 453            print "==============================="
 454            print "fin crreConfigTxt"
 455         """
 456         pass #CS_pbruno à implémenter
 457
 458
 459
 460
 461
 462
 463 #-------------------------------------------------------------------------------------------------------
 464 #           Point d'entré lancement EFICAS
 465 #
 466 def runEficas( code="ASTER", fichier=None ):
 467     global appli
 468     if not appli: #une seul instance possible!
 469         appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier )
 470
 471
 472
 473 # pour compatibilité
 474 def runHomard( code="HOMARD", fichier=None ):
 475     global appli
 476     if not appli: #une seul instance possible!
 477         appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier )
 478
 479
 480
 481
 482 """
 483 def runAster(parent = SalomePyQt.SalomePyQt().getDesktop(), palStudyManager = studyManager.palStudy, code="ASTER", fichier=None ) :
 484     global appli
 485     if not appli: #une seul instance possible!
 486         appli = MyEficas( parent, palStudyManager, code = code, fichier = fichier )
 487 """
 488
 489
 490
 491 # Init globale du module
 492 root = Tkinter.Tk()
 493 root.withdraw()
 494
 495
 496 appli = None
 497
 498
 499
 500 logger=ExtLogger( "eficasSalome.py" )
 501
 502
 503
 504
 505 """
 506         #embedded.showMaximized()
 507         #embedded.embed( appli.winfo_id() )
 508
 509         embedded.setWFlags( qt.Qt.WStyle_Customize | qt.Qt.WStyle_StaysOnTop )
 510         embedded.setFocus()
 511
 512         if embedded.hasFocus () :
 513             print 'hasfocus'
 514         else:
 515             print 'pas  focus'
 516
 517
 518         if embedded.isFocusEnabled():
 519             print 'isFocusEnabled()'
 520         else:
 521             print 'not isFocusEnabled()'
 522
 523         focusP = embedded.focusPolicy()
 524
 525         if focusP == qt.QWidget.TabFocus:
 526             print 'qt.QWidgetTabFocus'
 527         elif focusP == qt.QWidget.ClickFocus:
 528             print 'qt.ClickFocus'
 529         elif focusP == qt.QWidget.StrongFocus:
 530             print 'qt.StrongFocus'
 531         elif focusP == qt.QWidget.WheelFocus:
 532             print 'qt.WheelFocus'
 533         elif focusP == qt.QWidget.NoFocus:
 534             print 'qt.NoFocus'
 535         else:
 536             print 'bizarre'
 537
 538         embedded.grabKeyboard()
 539         """