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