]> SALOME platform Git repositories - modules/eficas.git/blob - src/EFICASGUI/eficasSalome.py
Salome HOME
79a0d9462778d2ac19a5c433fdbdaf6352d935d8
[modules/eficas.git] / src / EFICASGUI / eficasSalome.py
1 # -*- coding: utf-8 -*-
2 #_____________________________________
3
4 import sys, os, re,types
5 import traceback
6 from PyQt5.QtWidgets import QMessageBox
7 from PyQt5.QtWidgets import QApplication
8
9
10 from salome.kernel.logger import Logger
11 logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
12
13 import eficasConfig 
14 # eficasConfig definit le EFICAS_ROOT
15 # lignes de path ajoutees pour acceder aux packages python du
16 # logiciel Eficas. Le package Aster est ajoute explicitement pour
17 # acceder au module prefs.py. A
18 # ajout de InterfaceQT4 pour permettre l acces a la fenetre Option
19 sys.path[:0]=[eficasConfig.eficasPath,
20               os.path.join( eficasConfig.eficasPath,'Editeur'),
21               os.path.join( eficasConfig.eficasPath,'UiQT5'),
22               os.path.join( eficasConfig.eficasPath,'InterfaceQT4'),
23               #os.path.join( eficasConfig.eficasPath,'Extensions'),
24               eficasConfig.eficasPath,
25              ]
26
27
28 import Editeur    
29 from InterfaceQT4 import qtEficas
30
31 import salome
32 import SalomePyQt
33 sgPyQt = SalomePyQt.SalomePyQt()
34 langue=str(sgPyQt.stringSetting("language","language"))
35
36
37 from salome.kernel.studyedit import getStudyEditor
38
39
40 # couleur pour visualisation des geometries 
41 import colors
42 COLORS = colors.ListeColors
43 LEN_COLORS = len( COLORS )
44
45 from Extensions import localisation
46 localisation.localise(None,langue)
47
48
49 class MyEficas( qtEficas.Appli ):
50     """
51     Classe de lancement du logiciel EFICAS dans SALOME
52     Cette classe specialise le logiciel Eficas par l'ajout de:        
53     a)la creation de groupes de mailles dans le composant SMESH de SALOME
54     b)la visualisation d'elements geometrique dans le coposant GEOM de SALOME par selection dans EFICAS
55     """
56     def __init__( self, parent, code = None, fichier = None, module = "EFICAS",
57                   version = None, componentName = "Eficas",multi=False):
58         """
59         Constructeur.
60         @type   parent: 
61         @param  parent: widget Qt parent
62         @type   code: string
63         @param  code: catalogue a lancer 
64         @type   fichier: string
65         @param  fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
66         """
67
68         dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF',
69                       'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac3'}
70         if code in dictPathCode.keys():
71             pathCode=dictPathCode[code]
72             sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)]
73
74         if Editeur.__dict__.has_key( 'session' ):
75             from Editeur import session
76             eficasArg = []
77             eficasArg += sys.argv            
78             if fichier:
79                 eficasArg += [ fichier ]
80             if version:
81                 eficasArg += [ "-c", version ]
82             else :
83                 print "noversion"
84             session.parse( eficasArg )
85                         
86         self.editor = getStudyEditor()    # Editeur de l'arbre d'etude
87
88         qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
89         
90         #--------------- specialisation EFICAS dans SALOME  -------------------                
91         self.parent = parent        
92         self.salome = True      #active les parties de code specifique dans Salome( pour le logiciel Eficas )
93         self.module = module    #indique sous quel module dans l'arbre d'etude ajouter le JDC.
94         self.componentName = componentName
95         
96         # donnee pour la creation de groupe de maille
97         self.mainShapeNames   = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par 
98                                    #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.    
99                                    #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name ) 
100         #----------------------------------------------------------------------    
101         
102         self.icolor = 0  # compteur pour memoriser la couleur courante
103         self.show()
104         
105         
106     def closeEvent(self,event):
107         res=self.fileExit()
108         if res==2 : 
109           event.ignore()
110           return
111         if hasattr(self,'readercata') :
112            del self.readercata
113         import math
114         try:
115           import Numeric
116         except:
117           import numpy
118           Numeric = numpy
119
120         from Extensions.param2 import originalMath
121         #Numeric.cos=originalMath.numeric_ncos
122         #Numeric.sin=originalMath.numeric_nsin
123         #Numeric.array=originalMath.numeric_narray
124         #math.sin=originalMath.sin
125         #math.cos=originalMath.cos
126         #math.sqrt=originalMath.sqrt
127         #math.ceil=originalMath.ceil
128         #math.pi=originalMath.pi
129         originalMath.toOriginal()
130
131         global appli
132         appli = None
133         event.accept()
134      
135  
136 # ___________________________ Methodes de l ex Pal __________________________________
137
138     #----------------------------------------------------------------
139     def getCORBAObjectInComponent( self,  entry, composant ):
140     #----------------------------------------------------------------
141        object = None
142        mySO = self.editor.study.FindObjectID(entry)
143        if mySO:
144           object = mySO.GetObject()
145           if not object:
146              myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
147              SCom        = self.editor.study.FindComponent( composant )
148              print myComponent , SCom
149              self.editor.builder.LoadWith( SCom , myComponent  )
150              object      = mySO.GetObject()
151        if not object :
152              logger.debug("selectedEntry: An error occurs")
153        return object
154
155
156     #----------------------------------------------
157     def giveMeshGroups( self,entry,label1,typeMesh):
158     #----------------------------------------------
159        msg=None
160        names=[]
161        import SMESH
162        try:
163          monMaillage =self.getCORBAObjectInComponent(entry,"SMESH") 
164          if monMaillage != None :                                    # selection d'un groupe de SMESH
165             if  monMaillage._narrow(SMESH.SMESH_Mesh):
166                 mailSO = self.editor.study.FindObjectID(entry)
167                 if mailSO == None : return names, msg
168
169
170                 subIt = self.editor.study.NewChildIterator(mailSO)
171                 while subIt.More():
172                       subSO = subIt.Value()
173                       subIt.Next()
174
175                       if (subSO.GetName()[0:9]!=label1) : continue
176                       subSSMeshit=self.editor.study.NewChildIterator(subSO)
177                       while subSSMeshit.More():
178                            subSSMeshSO = subSSMeshit.Value()
179                            subSSMeshit.Next()
180                            if  subSSMeshSO.GetObject()._narrow(typeMesh):
181                                names.append(subSSMeshSO.GetName())
182             else :
183                 msg=entry + self.tr(" n est pas un maillage")
184        except :
185          logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )          
186          msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry          
187        return names, msg
188
189     #-------------------------------------
190     def isMeshGroup( self,entry):
191     #-------------------------------------
192        result=False
193        import SMESH
194        try:
195          monObjet =self.getCORBAObjectInComponent(entry,"SMESH") 
196          if monObjet != None :                                    # selection d'un groupe de SMESH
197             if  monObjet._narrow(SMESH.SMESH_GroupBase):
198                 result = True 
199        except :
200          logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )          
201        return result
202
203     #-------------------------------------
204     def isMesh( self,entry):
205     #-------------------------------------
206        result=False
207        import SMESH
208        try:
209          monObjet =self.getCORBAObjectInComponent(entry,"SMESH") 
210          if monObjet != None :                                    # selection d'un groupe de SMESH
211             if  monObjet._narrow(SMESH.SMESH_Mesh):
212                 result = True 
213        except :
214          logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )          
215        return result
216
217     #-------------------------------------
218     def getMesh( self,entry):
219     #-------------------------------------
220        meshObject=None
221        import SMESH
222        try:
223        #if 1 :
224          monObjet =self.getCORBAObjectInComponent(entry,"SMESH") 
225          if monObjet != None :                                    # selection d'un groupe de SMESH
226             meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
227        except :
228          logger.debug('  pb avec ( entry = %s ) ' %entry )          
229        return meshObject
230
231     #-------------------------------------
232
233     #-------------------------------------
234     def isShape( self,entry):
235     #-------------------------------------
236        result=False
237        import GEOM
238        try:
239          monObjet =self.getCORBAObjectInComponent(entry,"GEOM") 
240          if monObjet != None :                                    # selection d'un objet GEOM
241             if  monObjet._narrow(GEOM.GEOM_Object ):
242                 result = True 
243        except :
244          logger.debug(' isShape pb avec ( entry = %s ) ' %entry )          
245        return result
246
247     #-----------------------------------------------------------------
248     def getMainShapeEntry(self,entry):
249     #-----------------------------------------------------------------
250         result=None
251         try:
252            mainShapeEntry = entry.split(':')[:4]
253            if len(mainShapeEntry) == 4:
254                 strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
255                 if self.isMainShape(strMainShapeEntry):
256                     result = strMainShapeEntry
257         except:
258             logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
259             result = None
260         return result
261
262     #-----------------------------------------------------------------
263     def isMainShape(self,entry):
264     #-----------------------------------------------------------------
265         result = False
266         try:
267             monObjet =self.getCORBAObjectInComponent(entry,"GEOM") 
268             import GEOM
269             shape    = monObjet._narrow( GEOM.GEOM_Object )
270             if shape.IsMainShape():
271                 result = True
272         except:
273             logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
274             result = False
275         return result
276
277     
278     #-----------------------------------------------------------------
279     def ChercheType( self, shape ):
280     #-----------------------------------------------------------------
281         tgeo =  shape.GetShapeType() 
282         geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
283         #print dir(self.editor.study)
284         groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
285         if tgeo != "COMPOUND" : return tgeo
286
287         strInfo =  groupIMeasureOp.WhatIs( shape )
288         dictInfo = {}
289         l = strInfo.split('\n')
290
291         for couple in l:
292              nom, valeur = couple.split(':')
293              dictInfo[ nom.strip() ] = valeur.strip()
294
295         ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
296         for t in ordre:
297             if dictInfo[ t ] != '0':
298                tgeo = t
299                return tgeo
300         return None
301
302
303     #-----------------------------------------------------------------
304     def selectShape( self, editor, entry, kwType = None ):
305     #-----------------------------------------------------------------
306         """
307         selection sous-geometrie dans Salome:
308         -test1) si c'est un element sous-geometrique .
309         -test2) si appartient a la geometrie principale.
310         """
311         name, msgError = '',''
312         mySO = self.editor.study.FindObjectID(entry)
313         if mySO == None :
314            return name, msgError
315         object = mySO.GetObject()
316         if object == None :
317            return name, msgError
318
319         import GEOM
320         shape  = object._narrow( GEOM.GEOM_Object )
321         if not shape :
322            return name, msgError
323
324         tGeo=self.ChercheType(shape)
325         if not tGeo :
326            return name, msgError
327         #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
328         #    name,msgError = '',"la selection n est pas un Vertex"
329         #    return name, msgError
330         if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
331             name, msgError = '', "la selection n est pas un groupe de maille"
332             return name, msgError
333
334         mainShapeEntry = self.getMainShapeEntry( entry )
335         if self.mainShapeNames.has_key( editor ):
336           #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
337           if self.mainShapeNames[editor] == mainShapeEntry:
338              name=mySO.GetName()
339           else :
340              msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
341         else :
342           self.mainShapeNames[editor] = mainShapeEntry
343           name=mySO.GetName()
344        
345         return name, msgError
346         
347
348     #-----------------------------------------------------------------
349     def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
350     #-----------------------------------------------------------------
351         """
352         selection groupe de maille dans Salome:
353         -test 1) si c'est un groupe de maille
354         -test 2) si le maillage fait reference a la geometrie principale
355         """
356         name, msgError = '',''
357
358         mySO=self.editor.study.FindObjectID(selectedEntry )
359         from salome.smesh.smeshstudytools import SMeshStudyTools
360         monSMeshStudyTools=SMeshStudyTools(self.editor)
361         meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
362         if meshSO == None : return name, msgError    
363
364        # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
365         tGroup = ""
366         groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
367         if not groupObject :
368            logger.debug("selectedMeshEntry: An error occurs")
369
370         import SMESH
371         aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
372         if aGroup: tGroup = aGroup.GetType()
373
374         if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
375              msgError = self.tr("GROUP_NO attend un groupe de noeud")
376              return name, msgError
377         elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
378              msgError = self.tr("GROUP_MA attend un point goupe de maille")
379              return name, msgError
380
381         # on cherche la shape associee
382         #PN PN mesh_Object est un SOject
383         meshObject = meshSO.GetObject()
384         mesh     = meshObject._narrow( SMESH.SMESH_Mesh  )
385         if mesh:         #c'est bien un objet maillage
386              shape = mesh.GetShapeToMesh()
387              if shape:
388                 ior = salome.orb.object_to_string( shape )
389                 if ior:
390                    sObject   = self.editor.study.FindObjectIOR(  ior )
391                    mainShapeID = sObject.GetID()
392              else :
393                 mainShapeID=0
394         else :
395              return name, self.tr("Type d objet non permis")
396
397         # on cherche si la shape associee est la bonne
398         #print "------------- mainShapeID" , mainShapeID
399         if self.mainShapeNames.has_key( editor ):
400           #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
401           if self.mainShapeNames[editor] == mainShapeID:
402              name=mySO.GetName()
403           else :
404              msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
405         else :
406           self.mainShapeNames[editor] = mainShapeID
407           name=mySO.GetName()
408
409         #print "------------------------------ name :", name
410         #print "------------------------------ name :", name
411         #print "------------------------------ name :", name
412         return name,msgError
413
414
415     def displayMeshGroups(self, meshGroupName):
416         """
417         visualisation group de maille de nom meshGroupName dans salome
418         """
419         ok, msgError = False, ''
420         try:
421         #if 1 :
422             sg = salome.ImportComponentGUI('SMESH')
423             meshGroupEntries = []
424             selMeshEntry = None
425             selMeshGroupEntry = None
426             
427             # liste des groupes de maille de nom meshGroupName
428             listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
429             #print listSO
430             #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
431             
432             if len(listSO)>1:
433                return 0,self.tr('Plusieurs objets  portent ce nom')
434             if len(listSO) ==0 :
435                return 0,self.tr('Aucun objet ne porte ce nom')
436             SObjet=listSO[0]
437             groupEntry = SObjet.GetID()                
438             myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
439             SCom        = self.editor.study.FindComponent("SMESH")
440             myBuilder   = self.editor.study.NewBuilder()
441             myBuilder.LoadWith( SCom , myComponent  )                             
442             sg.CreateAndDisplayActor(groupEntry)
443             #color = COLORS[ self.icolor % LEN_COLORS ]                
444             #self.icolor = self.icolor + 1
445             #sg.SetColor(groupEntry, color[0], color[1], color[2])
446             salome.sg.Display(groupEntry)
447             salome.sg.FitAll()                
448             ok = True                
449
450         except:
451         #else :
452             msgError = self.tr("Impossible d afficher ")+shapeName
453             logger.debug(50*'=')
454         return ok, msgError
455
456 # ___________________________ Methodes appelees par EFICAS  __________________________________
457     #----------------------------------------------------------------
458     def selectGroupFromSalome( self, kwType = None, editor=None):
459     #----------------------------------------------------------------
460         """
461         Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille)  partir de l'arbre salome
462         retourne ( la liste des noms des groupes, message d'erreur )
463       
464         Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA        
465         """
466         names, msg = [], ''
467         try:            
468             atLeastOneStudy = self.editor.study
469             if not atLeastOneStudy:
470                 return names, msg
471
472            # recupere toutes les selections de l'utilsateur dans l'arbre Salome
473             entries = salome.sg.getAllSelected()
474             nbEntries = len( entries )
475             if nbEntries >= 1:
476                 for entry in entries:
477                     if self.isMeshGroup(entry):               # selection d 'un sous maillage
478                        name, msg = self.selectMeshGroup( editor, entry, kwType )
479                     elif self.isShape(entry):               # selection d'une sous-geometrie
480                        name, msg = self.selectShape( editor, entry, kwType )
481                     else:
482                        name, msg = None,self.tr("Selection SALOME non autorisee.")
483                     if name:
484                        names.append( name )                    
485                         
486         except:            
487             logger.debug("selectGroupFromSalome: An error occurs")
488         #print "=================== selectGroupFromSalome ", names, msg
489         #print "=================== selectGroupFromSalome ", names, msg
490         #print "=================== selectGroupFromSalome ", names, msg
491         return names, msg                
492
493     #----------------------------------------------------------------
494     def selectMeshFile( self,  editor=None):
495     #----------------------------------------------------------------
496         """
497         """
498         try :            
499             atLeastOneStudy = self.editor.study
500             if not atLeastOneStudy: return "", 'Pas d etude'
501
502            # recupere toutes les selections de l'utilsateur dans l'arbre Salome
503             entries = salome.sg.getAllSelected()
504             nbEntries = len( entries )
505             if nbEntries != 1 : return "", 'select a Mesh'
506             entry = entries[0]
507             if not self.isMesh(entry): return "", 'select a Mesh'
508             mySO=self.editor.study.FindObjectID(entry)
509             print mySO
510             ok, anAttr = mySO.FindAttribute("AttributeName")
511             if not ok :  return "" ,'Pb de nommage'
512             meshFile="/tmp/"+str(anAttr.Value())+'.med'
513             myMesh=self.getMesh(entry) 
514             if myMesh==None : return "" ,'Pb dans la selection '
515             myMesh.ExportMED( meshFile, 0)
516             return meshFile ,""
517         except :
518            return "", "Pb dans la selection "
519
520     #----------------------------------------------------------------
521     def importMedFile( self,fileName,  editor=None):
522     #----------------------------------------------------------------
523         try :            
524             theStudy = self.editor.study
525             if not theStudy: return (0, 'Pas d etude')
526             from salome.smesh import smeshBuilder
527             smesh = smeshBuilder.New(theStudy)
528             aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
529             salome.sg.updateObjBrowser(1)
530             return 1,"" 
531         except :
532             return (O,"Pb a l import")
533                      
534     #----------------------------------------------------------------
535     def selectEntryFromSalome( self, kwType = None, editor=None):
536     #----------------------------------------------------------------
537         """
538         Selection d'element a partir de l'arbre salome
539         Ne verifie que l unicite de la selection
540         retourne ( la liste avec le  nom du groupe, message d'erreur )
541       
542         retourne une liste pour etre coherent avec selectGroupFromSalome
543         Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry        
544         """
545         try:            
546             if self.editor.study._non_existent():
547                raise Exception(self.tr(u"L'etude Salome n'existe plus"))
548             entries = salome.sg.getAllSelected()
549             nbEntries = len( entries )
550             if nbEntries < 1:
551                raise Exception(self.tr(u"Veuillez selectionner une entree de l'arbre d'etude de Salome"))
552             elif nbEntries > 1 :
553                raise Exception(self.tr(u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"))
554
555             value = kwType.get_selected_value(entries[0], self.editor)
556             msg = self.tr(u"L'entree de l'arbre d'etude de Salome a ete sélectionnee")
557             return [value], msg
558         except Exception, e:
559             QMessageBox.information(self, self.tr(u"Selection depuis Salome"), unicode(e))
560             return [], unicode(e)
561
562         
563     #---------------------------------------------
564     def addJdcInSalome(  self, jdcPath ):
565     #---------------------------------------------
566         """
567         Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
568         Revu pour QT4
569         """
570         msgError    = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
571         ok = False
572         try:            
573             atLeastOneStudy = self.editor.study
574             if not atLeastOneStudy:
575                 return ok, msgError
576                         
577             fileType = { 'TELEMAC'    : "FICHIER_EFICAS_TELEMAC",
578                          'ADAO'       : "FICHIER_EFICAS_ADAO",
579                          'SEP'        : "FICHIER_EFICAS_SEP",
580                          'SPECA'      : "FICHIER_EFICAS_SPECA",
581                          'MT'         : "FICHIER_EFICAS_MT",
582                          'CF'         : "FICHIER_EFICAS_CF",
583                          'MAP'        : "FICHIER_EFICAS_MAP",
584                          'CARMEL3D'   : "FICHIER_EFICAS_CARMEL3D",
585                         }
586                         
587                         
588             folderName = { 'TELEMAC'  : "TelemacFiles",
589                          'ADAO'       : "AdaoFiles",
590                          'SEP'        : "SepFiles",
591                          'SPECA'      : "SpecaFiles",
592                          'MT'         : "MTFiles",
593                          'CF'         : "CFFiles",
594                          'CARMEL3D'   : 'CARMEL3DFiles' ,
595                          'MAP'        : 'MapFiles' ,
596                         }
597
598                         
599             folderType = { 'TELEMAC'    : "TELEMAC_FILE_FOLDER",
600                          'ADAO'       : "ADAO_FILE_FOLDER",
601                          'SEP'        : "SEP_FILE_FOLDER",
602                          'SPECA'      : "SPECA_FILE_FOLDER",
603                          'MT'         : "MT_FILE_FOLDER",
604                          'CF'         : "CF_FILE_FOLDER",
605                          'SEP'        : "SEP_FILE_FOLDER",
606                          'MAP'        : "MAP_FILE_FOLDER",
607                          'CARMEL3D'   : "CARMEL3D_FILE_FOLDER",
608                         }
609
610                         
611             moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
612             itemName    = re.split("/",jdcPath)[-1]
613             
614             if folderName.has_key(self.code) :
615                monFolderName=folderName[ self.code ]
616             else :
617                monFolderName=str(self.code)+"Files"
618
619             if folderType.has_key(self.code) :
620                monFolderType=fileType[ self.code ]
621             else :
622                monFolderType=str(self.code)+"_FILE_FOLDER"
623
624             if fileType.has_key(self.code) :
625                monFileType=fileType[ self.code ]
626             else :
627                monFileType="FICHIER_EFICAS_"+str(self.code)
628
629             fatherEntry = self.editor.findOrCreateItem(
630                                     moduleEntry,
631                                     name = monFolderName,
632                                     #icon = "ICON_COMM_FOLDER",
633                                     fileType = monFolderType)
634                                                                         
635             commEntry = self.editor.findOrCreateItem( fatherEntry ,
636                                            name = itemName,
637                                            fileType = monFileType,
638                                            fileName = jdcPath,
639                                            #icon    = "ICON_COMM_FILE",
640                                            comment = str( jdcPath ))
641
642             salome.sg.updateObjBrowser(1)
643
644             #print 'addJdcInSalome commEntry->', commEntry            
645             if commEntry:
646                 ok, msgError = True, ''        
647         except Exception, exc:
648             msgError = "Can't add Eficas file to Salome study tree"
649             logger.debug(msgError, exc_info = True)
650             QMessageBox.warning(self, self.tr("Warning"),
651                                 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de détails " % (msgError, exc)))
652         return ok, msgError        
653         
654            
655     #---------------------------------------
656     def displayShape(  self, shapeName ):
657     #---------------------------------------
658         """
659         visualisation de nom shapeName dans salome
660         """
661         ok, msgError = False, ''
662         try:
663         #if 1 :
664             import SalomePyQt
665             sgPyQt = SalomePyQt.SalomePyQt()
666             myActiveView=sgPyQt.getActiveView() 
667             if myActiveView < 0 :
668                return ok, 'pas de vue courante'
669                                      
670             currentViewType=sgPyQt.getViewType(myActiveView)
671             if str(currentViewType) != "OCCViewer" : # maillage
672                 ok, msgError = self.displayMeshGroups(shapeName)
673             else: #geometrie
674                 current_color = COLORS[ self.icolor % LEN_COLORS ]                
675                 from salome.geom.geomtools import GeomStudyTools
676                 myGeomTools=GeomStudyTools(self.editor)
677                 ok = myGeomTools.displayShapeByName( shapeName, current_color )
678                 salome.sg.FitAll()
679                 self.icolor = self.icolor + 1             
680                 if not ok:
681                     msgError =self.tr("Impossible d afficher ")+shapeName
682         except:            
683         #else :
684             logger.debug(50*'=')
685         return ok, msgError    
686                 
687     #---------------------------------------
688     def ChercheGrpMeshInSalome(self):
689     #---------------------------------------
690         print "je passe par la"
691         import SMESH
692         names, msg = [], ''
693         try :
694         #if 1 :
695            entries = salome.sg.getAllSelected()
696            nbEntries = len( entries )
697            names, msg = None, self.tr("Selection SALOME non autorisee.")
698            if nbEntries == 1:
699                 for entry in entries:
700                     names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
701         except :
702         #else :
703            print "bim bam boum"
704         return(msg,names)
705
706     #---------------------------------------
707     def ChercheGrpMailleInSalome(self):
708     #---------------------------------------
709         import SMESH
710         names, msg = [], ''
711         try :
712         #if 1:
713            entries = salome.sg.getAllSelected()
714            nbEntries = len( entries )
715            names, msg = None, self.tr("Selection SALOME non autorisee.")
716            if nbEntries == 1:
717                 for entry in entries:
718                     print entry
719                     names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
720                     print names
721         except :
722         #else:
723            print "bim bam boum"
724         return(msg,names)
725
726
727         
728         
729         
730 #-------------------------------------------------------------------------------------------------------
731 #    Pilotage de la Visu des elements de structures
732 #
733
734
735     def envoievisu(self,liste_commandes):
736         try:
737             from salome.geom.structelem import StructuralElementManager, InvalidParameterError
738         except ImportError:
739             QMessageBox.critical(self, self.tr("Error"),
740                                  self.tr("Impossible d'afficher les elements de structure: "
741                                          "module GEOM n est pas  installe."))
742             return
743         try:
744             atLeastOneStudy = self.editor.study
745             if not atLeastOneStudy:
746                 return
747             logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
748             structElemManager = StructuralElementManager()
749             elem = structElemManager.createElement(liste_commandes)
750             elem.display()
751             salome.sg.updateObjBrowser(True)
752         except InvalidParameterError, err:
753             trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
754                             "greater than %(minval)g (actual value is %(value)g)")
755             msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
756                                 "minval": err.minValue, "value": err.value}
757             QMessageBox.warning(self, self.tr("Error"), msg)
758         except:
759             traceback.print_exc()
760             logger.debug(10*'#'+":pb dans envoievisu")
761
762
763 class SalomeEntry:
764   """
765   This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
766   when Eficas is launched in Salome context. It handles the objects that can
767   be selected from Salome object browser.
768   By default, the selected value is the entry of the selected item in the
769   object browser. This class can be subclassed to provide more advanced
770   functions.
771   """
772   
773   help_message = u"Une entrée de l'arbre d'étude de Salome est attendue"
774   
775   def __init__(self, entryStr):
776     self._entry = entryStr
777   
778   @staticmethod
779   def __convert__(entryStr):
780     return SalomeEntry(entryStr)
781   
782   @staticmethod
783   def get_selected_value(selected_entry, study_editor):
784     return selected_entry
785
786         
787 #-------------------------------------------------------------------------------------------------------        
788 #           Point d'entree lancement EFICAS
789 #
790 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
791     logger.debug(10*'#'+":runEficas: START")
792     #global appli    
793     logger.debug(10*'#'+":runEficas: code="+str(code))
794     logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
795     logger.debug(10*'#'+":runEficas: module="+str(module))
796     logger.debug(10*'#'+":runEficas: version="+str(version))
797
798     #if not appli: #une seul instance possible!        
799     appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
800                        module = module, version = version, componentName = componentName,multi=multi )
801     #if not appli: #une seul instance possible!        
802     #    appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
803     #                      module = module, componentName = componentName, version=version )
804     logger.debug(10*'#'+":runEficas: END")
805
806