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