1 # -*- coding: utf-8 -*-
2 #_____________________________________
4 import sys, os, re,types
6 from PyQt5.QtWidgets import QMessageBox
7 from PyQt5.QtWidgets import QApplication
9 from salome.kernel.logger import Logger
10 logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
13 # eficasConfig definit le EFICAS_ROOT
14 # lignes de path ajoutees pour acceder aux packages python du
15 # logiciel Eficas. Le package Aster est ajoute explicitement pour
16 # acceder au module prefs.py. A
17 # ajout de InterfaceQT4 pour permettre l acces a la fenetre Option
18 sys.path[:0]=[eficasConfig.eficasPath,
19 os.path.join( eficasConfig.eficasPath,'Editeur'),
20 os.path.join( eficasConfig.eficasPath,'UiQT5'),
21 os.path.join( eficasConfig.eficasPath,'InterfaceQT4'),
22 #os.path.join( eficasConfig.eficasPath,'Extensions'),
23 eficasConfig.eficasPath,
28 from InterfaceQT4 import qtEficas
32 sgPyQt = SalomePyQt.SalomePyQt()
33 langue=str(sgPyQt.stringSetting("language","language"))
36 from salome.kernel.studyedit import getStudyEditor
39 # couleur pour visualisation des geometries
41 COLORS = colors.ListeColors
42 LEN_COLORS = len( COLORS )
44 from Extensions import localisation
45 localisation.localise(None,langue)
48 class MyEficas( qtEficas.Appli ):
50 Classe de lancement du logiciel EFICAS dans SALOME
51 Cette classe specialise le logiciel Eficas par l'ajout de:
52 a)la creation de groupes de mailles dans le composant SMESH de SALOME
53 b)la visualisation d'elements geometrique dans le coposant GEOM de SALOME par selection dans EFICAS
55 def __init__( self, parent, code = "ASTER", fichier = None, module = "EFICAS",
56 version = None, componentName = "Eficas",multi=False):
60 @param parent: widget Qt parent
62 @param code: catalogue a lancer ( ASTER, HOMARD OPENTURNS ). optionnel ( defaut = ASTER ).
64 @param fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
67 dictPathCode={'ASTER':'Aster','OPENTURNS_STUDY':'Openturns_Study','CARMEL3D':'Carmel3D', 'CARMELCND':'CarmelCND',
68 'OPENTURNS_WRAPPER':'Openturns_Wrapper','MAP':'MAP','SEP':'Sep', 'ZCRACKS':'ZCracks'}
69 if code in dictPathCode.keys():
70 pathCode=dictPathCode[code]
71 sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)]
73 if Editeur.__dict__.has_key( 'session' ):
74 from Editeur import session
78 eficasArg += [ fichier ]
80 eficasArg += [ "-c", version ]
83 session.parse( eficasArg )
85 self.editor = getStudyEditor() # Editeur de l'arbre d'etude
87 qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
89 #--------------- specialisation EFICAS dans SALOME -------------------
91 self.salome = True #active les parties de code specifique dans Salome( pour le logiciel Eficas )
92 self.module = module #indique sous quel module dans l'arbre d'etude ajouter le JDC.
93 self.componentName = componentName
95 # donnee pour la creation de groupe de maille
96 self.mainShapeNames = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par
97 #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.
98 #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name )
99 #----------------------------------------------------------------------
101 self.icolor = 0 # compteur pour memoriser la couleur courante
105 def closeEvent(self,event):
110 if hasattr(self,'readercata') :
119 from Extensions.param2 import originalMath
120 #Numeric.cos=originalMath.numeric_ncos
121 #Numeric.sin=originalMath.numeric_nsin
122 #Numeric.array=originalMath.numeric_narray
123 #math.sin=originalMath.sin
124 #math.cos=originalMath.cos
125 #math.sqrt=originalMath.sqrt
126 #math.ceil=originalMath.ceil
127 #math.pi=originalMath.pi
128 originalMath.toOriginal()
135 # ___________________________ Methodes de l ex Pal __________________________________
137 #----------------------------------------------------------------
138 def getCORBAObjectInComponent( self, entry, composant ):
139 #----------------------------------------------------------------
141 mySO = self.editor.study.FindObjectID(entry)
143 object = mySO.GetObject()
145 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
146 SCom = self.editor.study.FindComponent( composant )
147 print myComponent , SCom
148 self.editor.builder.LoadWith( SCom , myComponent )
149 object = mySO.GetObject()
151 logger.debug("selectedEntry: An error occurs")
155 #----------------------------------------------
156 def giveMeshGroups( self,entry,label1,typeMesh):
157 #----------------------------------------------
162 monMaillage =self.getCORBAObjectInComponent(entry,"SMESH")
163 if monMaillage != None : # selection d'un groupe de SMESH
164 if monMaillage._narrow(SMESH.SMESH_Mesh):
165 mailSO = self.editor.study.FindObjectID(entry)
166 if mailSO == None : return names, msg
169 subIt = self.editor.study.NewChildIterator(mailSO)
171 subSO = subIt.Value()
174 if (subSO.GetName()[0:9]!=label1) : continue
175 subSSMeshit=self.editor.study.NewChildIterator(subSO)
176 while subSSMeshit.More():
177 subSSMeshSO = subSSMeshit.Value()
179 if subSSMeshSO.GetObject()._narrow(typeMesh):
180 names.append(subSSMeshSO.GetName())
182 msg=entry + self.tr(" n est pas un maillage")
184 logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )
185 msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry
188 #-------------------------------------
189 def isMeshGroup( self,entry):
190 #-------------------------------------
194 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
195 if monObjet != None : # selection d'un groupe de SMESH
196 if monObjet._narrow(SMESH.SMESH_GroupBase):
199 logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )
202 #-------------------------------------
203 def isMesh( self,entry):
204 #-------------------------------------
208 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
209 if monObjet != None : # selection d'un groupe de SMESH
210 if monObjet._narrow(SMESH.SMESH_Mesh):
213 logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )
216 #-------------------------------------
217 def getMesh( self,entry):
218 #-------------------------------------
223 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
224 if monObjet != None : # selection d'un groupe de SMESH
225 meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
227 logger.debug(' pb avec ( entry = %s ) ' %entry )
230 #-------------------------------------
232 #-------------------------------------
233 def isShape( self,entry):
234 #-------------------------------------
238 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
239 if monObjet != None : # selection d'un objet GEOM
240 if monObjet._narrow(GEOM.GEOM_Object ):
243 logger.debug(' isShape pb avec ( entry = %s ) ' %entry )
246 #-----------------------------------------------------------------
247 def getMainShapeEntry(self,entry):
248 #-----------------------------------------------------------------
251 mainShapeEntry = entry.split(':')[:4]
252 if len(mainShapeEntry) == 4:
253 strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
254 if self.isMainShape(strMainShapeEntry):
255 result = strMainShapeEntry
257 logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
261 #-----------------------------------------------------------------
262 def isMainShape(self,entry):
263 #-----------------------------------------------------------------
266 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
268 shape = monObjet._narrow( GEOM.GEOM_Object )
269 if shape.IsMainShape():
272 logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
277 #-----------------------------------------------------------------
278 def ChercheType( self, shape ):
279 #-----------------------------------------------------------------
280 tgeo = shape.GetShapeType()
281 geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
282 #print dir(self.editor.study)
283 groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
284 if tgeo != "COMPOUND" : return tgeo
286 strInfo = groupIMeasureOp.WhatIs( shape )
288 l = strInfo.split('\n')
291 nom, valeur = couple.split(':')
292 dictInfo[ nom.strip() ] = valeur.strip()
294 ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
296 if dictInfo[ t ] != '0':
302 #-----------------------------------------------------------------
303 def selectShape( self, editor, entry, kwType = None ):
304 #-----------------------------------------------------------------
306 selection sous-geometrie dans Salome:
307 -test1) si c'est un element sous-geometrique .
308 -test2) si appartient a la geometrie principale.
310 name, msgError = '',''
311 mySO = self.editor.study.FindObjectID(entry)
313 return name, msgError
314 object = mySO.GetObject()
316 return name, msgError
319 shape = object._narrow( GEOM.GEOM_Object )
321 return name, msgError
323 tGeo=self.ChercheType(shape)
325 return name, msgError
326 #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
327 # name,msgError = '',"la selection n est pas un Vertex"
328 # return name, msgError
329 if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
330 name, msgError = '', "la selection n est pas un groupe de maille"
331 return name, msgError
333 mainShapeEntry = self.getMainShapeEntry( entry )
334 if self.mainShapeNames.has_key( editor ):
335 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
336 if self.mainShapeNames[editor] == mainShapeEntry:
339 msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
341 self.mainShapeNames[editor] = mainShapeEntry
344 return name, msgError
347 #-----------------------------------------------------------------
348 def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
349 #-----------------------------------------------------------------
351 selection groupe de maille dans Salome:
352 -test 1) si c'est un groupe de maille
353 -test 2) si le maillage fait reference a la geometrie principale
355 name, msgError = '',''
357 mySO=self.editor.study.FindObjectID(selectedEntry )
358 from salome.smesh.smeshstudytools import SMeshStudyTools
359 monSMeshStudyTools=SMeshStudyTools(self.editor)
360 meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
361 if meshSO == None : return name, msgError
363 # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
365 groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
367 logger.debug("selectedMeshEntry: An error occurs")
370 aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
371 if aGroup: tGroup = aGroup.GetType()
373 if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
374 msgError = self.tr("GROUP_NO attend un groupe de noeud")
375 return name, msgError
376 elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
377 msgError = self.tr("GROUP_MA attend un point goupe de maille")
378 return name, msgError
380 # on cherche la shape associee
381 #PN PN mesh_Object est un SOject
382 meshObject = meshSO.GetObject()
383 mesh = meshObject._narrow( SMESH.SMESH_Mesh )
384 if mesh: #c'est bien un objet maillage
385 shape = mesh.GetShapeToMesh()
387 ior = salome.orb.object_to_string( shape )
389 sObject = self.editor.study.FindObjectIOR( ior )
390 mainShapeID = sObject.GetID()
394 return name, self.tr("Type d objet non permis")
396 # on cherche si la shape associee est la bonne
397 #print "------------- mainShapeID" , mainShapeID
398 if self.mainShapeNames.has_key( editor ):
399 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
400 if self.mainShapeNames[editor] == mainShapeID:
403 msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
405 self.mainShapeNames[editor] = mainShapeID
408 #print "------------------------------ name :", name
409 #print "------------------------------ name :", name
410 #print "------------------------------ name :", name
414 def displayMeshGroups(self, meshGroupName):
416 visualisation group de maille de nom meshGroupName dans salome
418 ok, msgError = False, ''
421 sg = salome.ImportComponentGUI('SMESH')
422 meshGroupEntries = []
424 selMeshGroupEntry = None
426 # liste des groupes de maille de nom meshGroupName
427 listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
429 #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
432 return 0,self.tr('Plusieurs objets portent ce nom')
434 return 0,self.tr('Aucun objet ne porte ce nom')
436 groupEntry = SObjet.GetID()
437 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
438 SCom = self.editor.study.FindComponent("SMESH")
439 myBuilder = self.editor.study.NewBuilder()
440 myBuilder.LoadWith( SCom , myComponent )
441 sg.CreateAndDisplayActor(groupEntry)
442 #color = COLORS[ self.icolor % LEN_COLORS ]
443 #self.icolor = self.icolor + 1
444 #sg.SetColor(groupEntry, color[0], color[1], color[2])
445 salome.sg.Display(groupEntry)
451 msgError = self.tr("Impossible d afficher ")+shapeName
455 # ___________________________ Methodes appelees par EFICAS __________________________________
456 #----------------------------------------------------------------
457 def selectGroupFromSalome( self, kwType = None, editor=None):
458 #----------------------------------------------------------------
460 Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille) partir de l'arbre salome
461 retourne ( la liste des noms des groupes, message d'erreur )
463 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
467 atLeastOneStudy = self.editor.study
468 if not atLeastOneStudy:
471 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
472 entries = salome.sg.getAllSelected()
473 nbEntries = len( entries )
475 for entry in entries:
476 if self.isMeshGroup(entry): # selection d 'un sous maillage
477 name, msg = self.selectMeshGroup( editor, entry, kwType )
478 elif self.isShape(entry): # selection d'une sous-geometrie
479 name, msg = self.selectShape( editor, entry, kwType )
481 name, msg = None,self.tr("Selection SALOME non autorisee.")
486 logger.debug("selectGroupFromSalome: An error occurs")
487 #print "=================== selectGroupFromSalome ", names, msg
488 #print "=================== selectGroupFromSalome ", names, msg
489 #print "=================== selectGroupFromSalome ", names, msg
492 #----------------------------------------------------------------
493 def selectMeshFile( self, editor=None):
494 #----------------------------------------------------------------
498 atLeastOneStudy = self.editor.study
499 if not atLeastOneStudy: return "", 'Pas d etude'
501 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
502 entries = salome.sg.getAllSelected()
503 nbEntries = len( entries )
504 if nbEntries != 1 : return "", 'select a Mesh'
506 if not self.isMesh(entry): return "", 'select a Mesh'
507 mySO=self.editor.study.FindObjectID(entry)
509 ok, anAttr = mySO.FindAttribute("AttributeName")
510 if not ok : return "" ,'Pb de nommage'
511 meshFile="/tmp/"+str(anAttr.Value())+'.med'
512 myMesh=self.getMesh(entry)
513 if myMesh==None : return "" ,'Pb dans la selection '
514 myMesh.ExportMED( meshFile, 0)
517 return "", "Pb dans la selection "
519 #----------------------------------------------------------------
520 def importMedFile( self,fileName, editor=None):
521 #----------------------------------------------------------------
523 theStudy = self.editor.study
524 if not theStudy: return (0, 'Pas d etude')
525 from salome.smesh import smeshBuilder
526 smesh = smeshBuilder.New(theStudy)
527 aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
528 salome.sg.updateObjBrowser(1)
531 return (O,"Pb a l import")
533 #----------------------------------------------------------------
534 def selectEntryFromSalome( self, kwType = None, editor=None):
535 #----------------------------------------------------------------
537 Selection d'element a partir de l'arbre salome
538 Ne verifie que l unicite de la selection
539 retourne ( la liste avec le nom du groupe, message d'erreur )
541 retourne une liste pour etre coherent avec selectGroupFromSalome
542 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
545 if self.editor.study._non_existent():
546 raise Exception(self.tr(u"L'étude Salome n'existe plus"))
547 entries = salome.sg.getAllSelected()
548 nbEntries = len( entries )
550 raise Exception(self.tr(u"Veuillez sélectionner une entrée de l'arbre d'étude de Salome"))
552 raise Exception(self.tr(u"Une seule entrée doit être sélectionnée dans l'arbre d'étude de Salome"))
554 value = kwType.get_selected_value(entries[0], self.editor)
555 msg = self.tr(u"L'entrée de l'arbre d'étude de Salome a été sélectionnée")
558 QMessageBox.information(self, self.tr(u"Sélection depuis Salome"), unicode(e))
559 return [], unicode(e)
562 #---------------------------------------------
563 def addJdcInSalome( self, jdcPath ):
564 #---------------------------------------------
566 Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
569 msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
572 atLeastOneStudy = self.editor.study
573 if not atLeastOneStudy:
576 fileType = { 'ASTER' : "FICHIER_EFICAS_ASTER",
577 'SEP' : "FICHIER_EFICAS_SEP",
578 'MAP' : "FICHIER_EFICAS_MAP",
579 'OPENTURNS': "FICHIER_EFICAS_OPENTURNS",
580 'OPENTURNS_STUDY': "FICHIER_EFICAS_OPENTURNS_STUDY",
581 'OPENTURNS_WRAPPER': "FICHIER_EFICAS_OPENTURNS_WRAPPER",
582 'CARMEL3D': "FICHIER_EFICAS_CARMEL3D",
583 'CARMELCND': "FICHIER_EFICAS_CARMELCND",
586 folderName = { 'ASTER' : 'AsterFiles',
588 'CARMEL3D' : 'CARMEL3DFiles' ,
589 'CARMELCND' : 'CARMELCNDFiles' ,
591 'OPENTURNS_STUDY': 'OpenturnsFiles',
592 'OPENTURNS_WRAPPER': 'OpenturnsFiles'}
594 folderType = { 'ASTER': "ASTER_FILE_FOLDER",
595 'SEP': "SEP_FILE_FOLDER",
596 'MAP': "MAP_FILE_FOLDER",
597 'CARMEL3D': "CARMEL3D_FILE_FOLDER",
598 'CARMELCND': "CARMELCND_FILE_FOLDER",
599 'OPENTURNS_STUDY':"OPENTURNS_FILE_FOLDER",
600 'OPENTURNS_WRAPPER': "OPENTURNS_FILE_FOLDER"}
603 moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
604 itemName = re.split("/",jdcPath)[-1]
606 if folderName.has_key(self.code) :
607 monFolderName=folderName[ self.code ]
609 monFolderName=str(self.code)+"Files"
611 if folderType.has_key(self.code) :
612 monFolderType=fileType[ self.code ]
614 monFolderType=str(self.code)+"_FILE_FOLDER"
616 if fileType.has_key(self.code) :
617 monFileType=fileType[ self.code ]
619 monFileType="FICHIER_EFICAS_"+str(self.code)
621 fatherEntry = self.editor.findOrCreateItem(
623 name = monFolderName,
624 #icon = "ICON_COMM_FOLDER",
625 fileType = monFolderType)
627 commEntry = self.editor.findOrCreateItem( fatherEntry ,
629 fileType = monFileType,
631 #icon = "ICON_COMM_FILE",
632 comment = str( jdcPath ))
634 salome.sg.updateObjBrowser(1)
636 #print 'addJdcInSalome commEntry->', commEntry
638 ok, msgError = True, ''
639 except Exception, exc:
640 msgError = "Can't add Eficas file to Salome study tree"
641 logger.debug(msgError, exc_info = True)
642 QMessageBox.warning(self, self.tr("Warning"),
643 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de détails " % (msgError, exc)))
647 #---------------------------------------
648 def displayShape( self, shapeName ):
649 #---------------------------------------
651 visualisation de nom shapeName dans salome
653 ok, msgError = False, ''
657 sgPyQt = SalomePyQt.SalomePyQt()
658 myActiveView=sgPyQt.getActiveView()
659 if myActiveView < 0 :
660 return ok, 'pas de vue courante'
662 currentViewType=sgPyQt.getViewType(myActiveView)
663 if str(currentViewType) != "OCCViewer" : # maillage
664 ok, msgError = self.displayMeshGroups(shapeName)
666 current_color = COLORS[ self.icolor % LEN_COLORS ]
667 from salome.geom.geomtools import GeomStudyTools
668 myGeomTools=GeomStudyTools(self.editor)
669 ok = myGeomTools.displayShapeByName( shapeName, current_color )
671 self.icolor = self.icolor + 1
673 msgError =self.tr("Impossible d afficher ")+shapeName
679 #---------------------------------------
680 def ChercheGrpMeshInSalome(self):
681 #---------------------------------------
682 print "je passe par la"
687 entries = salome.sg.getAllSelected()
688 nbEntries = len( entries )
689 names, msg = None, self.tr("Selection SALOME non autorisee.")
691 for entry in entries:
692 names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
698 #---------------------------------------
699 def ChercheGrpMailleInSalome(self):
700 #---------------------------------------
705 entries = salome.sg.getAllSelected()
706 nbEntries = len( entries )
707 names, msg = None, self.tr("Selection SALOME non autorisee.")
709 for entry in entries:
711 names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
722 #-------------------------------------------------------------------------------------------------------
723 # Pilotage de la Visu des elements de structures
727 def envoievisu(self,liste_commandes):
729 from salome.geom.structelem import StructuralElementManager, InvalidParameterError
731 QMessageBox.critical(self, self.tr("Error"),
732 self.tr("Impossible d'afficher les elements de structure: "
733 "module GEOM n est pas installe."))
736 atLeastOneStudy = self.editor.study
737 if not atLeastOneStudy:
739 logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
740 structElemManager = StructuralElementManager()
741 elem = structElemManager.createElement(liste_commandes)
743 salome.sg.updateObjBrowser(True)
744 except InvalidParameterError, err:
745 trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
746 "greater than %(minval)g (actual value is %(value)g)")
747 msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
748 "minval": err.minValue, "value": err.value}
749 QMessageBox.warning(self, self.tr("Error"), msg)
751 traceback.print_exc()
752 logger.debug(10*'#'+":pb dans envoievisu")
757 This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
758 when Eficas is launched in Salome context. It handles the objects that can
759 be selected from Salome object browser.
760 By default, the selected value is the entry of the selected item in the
761 object browser. This class can be subclassed to provide more advanced
765 help_message = u"Une entrée de l'arbre d'étude de Salome est attendue"
767 def __init__(self, entryStr):
768 self._entry = entryStr
771 def __convert__(entryStr):
772 return SalomeEntry(entryStr)
775 def get_selected_value(selected_entry, study_editor):
776 return selected_entry
779 #-------------------------------------------------------------------------------------------------------
780 # Point d'entree lancement EFICAS
782 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
783 logger.debug(10*'#'+":runEficas: START")
785 logger.debug(10*'#'+":runEficas: code="+str(code))
786 logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
787 logger.debug(10*'#'+":runEficas: module="+str(module))
788 logger.debug(10*'#'+":runEficas: version="+str(version))
790 #if not appli: #une seul instance possible!
791 appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
792 module = module, version = version, componentName = componentName,multi=multi )
793 #if not appli: #une seul instance possible!
794 # appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
795 # module = module, componentName = componentName, version=version )
796 logger.debug(10*'#'+":runEficas: END")