src/EFICASGUI/eficasSalome.py

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