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