]> SALOME platform Git repositories - modules/eficas.git/blob - src/EFICASGUI/eficasSalome.py
Salome HOME
9a7e19ffa0d4f30b334290a8a5ae631417a42301
[modules/eficas.git] / 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         """