1 # -*- coding: utf-8 -*-
2 #_____________________________________
4 import sys, os, re,types
6 from PyQt5.QtWidgets import QMessageBox
7 from PyQt5.QtWidgets import QApplication
10 from salome.kernel.logger import Logger
11 logger = Logger( "EFICAS_SRC.EFICASGUI.eficasSalome.py" )
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,
29 from InterfaceQT4 import qtEficas
33 sgPyQt = SalomePyQt.SalomePyQt()
34 langue=str(sgPyQt.stringSetting("language","language"))
37 from salome.kernel.studyedit import getStudyEditor
40 # couleur pour visualisation des geometries
42 COLORS = colors.ListeColors
43 LEN_COLORS = len( COLORS )
45 from Extensions import localisation
46 localisation.localise(None,langue)
49 class MyEficas( qtEficas.Appli ):
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
56 def __init__( self, parent, code = None, fichier = None, module = "EFICAS",
57 version = None, componentName = "Eficas",multi=False):
61 @param parent: widget Qt parent
63 @param code: catalogue a lancer
65 @param fichier: chemin absolu du fichier eficas a ouvrir a das le lancement. optionnel
68 #dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF',
69 # 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac',
70 # 'pytel' : 'pytel', 'telemac2d' : 'telemac2dSalome','coupling1d2d':'coupling1d2d',
71 # 'mascaret':'mascaret','boundary_conditions':'boundary_conditions'}
73 dictPathCode={'ADAO':'Adao','MT':'MT','CARMEL3D':'Carmel3D', 'CF':'CF',
74 'SPECA':'SPECA','MAP':'MAP','SEP':'SEP', 'TELEMAC':'Telemac'}
76 if code in dictPathCode.keys():
77 pathCode=dictPathCode[code]
78 sys.path[:0]=[os.path.join(eficasConfig.eficasPath,pathCode)]
80 if Editeur.__dict__.has_key( 'session' ):
81 from Editeur import session
85 eficasArg += [ fichier ]
87 eficasArg += [ "-c", version ]
90 session.parse( eficasArg )
92 self.editor = getStudyEditor() # Editeur de l'arbre d'etude
94 qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
96 #--------------- specialisation EFICAS dans SALOME -------------------
98 self.salome = True #active les parties de code specifique dans Salome( pour le logiciel Eficas )
99 self.module = module #indique sous quel module dans l'arbre d'etude ajouter le JDC.
100 self.componentName = componentName
102 # donnee pour la creation de groupe de maille
103 self.mainShapeNames = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par
104 #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.
105 #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name )
106 #----------------------------------------------------------------------
108 self.icolor = 0 # compteur pour memoriser la couleur courante
112 def closeEvent(self,event):
117 if hasattr(self,'readercata') :
126 from Extensions.param2 import originalMath
127 #Numeric.cos=originalMath.numeric_ncos
128 #Numeric.sin=originalMath.numeric_nsin
129 #Numeric.array=originalMath.numeric_narray
130 #math.sin=originalMath.sin
131 #math.cos=originalMath.cos
132 #math.sqrt=originalMath.sqrt
133 #math.ceil=originalMath.ceil
134 #math.pi=originalMath.pi
135 originalMath.toOriginal()
142 # ___________________________ Methodes de l ex Pal __________________________________
144 #----------------------------------------------------------------
145 def getCORBAObjectInComponent( self, entry, composant ):
146 #----------------------------------------------------------------
148 mySO = self.editor.study.FindObjectID(entry)
150 object = mySO.GetObject()
152 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
153 SCom = self.editor.study.FindComponent( composant )
154 print myComponent , SCom
155 self.editor.builder.LoadWith( SCom , myComponent )
156 object = mySO.GetObject()
158 logger.debug("selectedEntry: An error occurs")
162 #----------------------------------------------
163 def giveMeshGroups( self,entry,label1,typeMesh):
164 #----------------------------------------------
169 monMaillage =self.getCORBAObjectInComponent(entry,"SMESH")
170 if monMaillage != None : # selection d'un groupe de SMESH
171 if monMaillage._narrow(SMESH.SMESH_Mesh):
172 mailSO = self.editor.study.FindObjectID(entry)
173 if mailSO == None : return names, msg
176 subIt = self.editor.study.NewChildIterator(mailSO)
178 subSO = subIt.Value()
181 if (subSO.GetName()[0:9]!=label1) : continue
182 subSSMeshit=self.editor.study.NewChildIterator(subSO)
183 while subSSMeshit.More():
184 subSSMeshSO = subSSMeshit.Value()
186 if subSSMeshSO.GetObject()._narrow(typeMesh):
187 names.append(subSSMeshSO.GetName())
189 msg=entry + self.tr(" n est pas un maillage")
191 logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )
192 msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry
195 #-------------------------------------
196 def isMeshGroup( self,entry):
197 #-------------------------------------
201 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
202 if monObjet != None : # selection d'un groupe de SMESH
203 if monObjet._narrow(SMESH.SMESH_GroupBase):
206 logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )
209 #-------------------------------------
210 def isMesh( self,entry):
211 #-------------------------------------
215 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
216 if monObjet != None : # selection d'un groupe de SMESH
217 if monObjet._narrow(SMESH.SMESH_Mesh):
220 logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )
223 #-------------------------------------
224 def getMesh( self,entry):
225 #-------------------------------------
230 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
231 if monObjet != None : # selection d'un groupe de SMESH
232 meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
234 logger.debug(' pb avec ( entry = %s ) ' %entry )
237 #-------------------------------------
239 #-------------------------------------
240 def isShape( self,entry):
241 #-------------------------------------
245 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
246 if monObjet != None : # selection d'un objet GEOM
247 if monObjet._narrow(GEOM.GEOM_Object ):
250 logger.debug(' isShape pb avec ( entry = %s ) ' %entry )
253 #-----------------------------------------------------------------
254 def getMainShapeEntry(self,entry):
255 #-----------------------------------------------------------------
258 mainShapeEntry = entry.split(':')[:4]
259 if len(mainShapeEntry) == 4:
260 strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
261 if self.isMainShape(strMainShapeEntry):
262 result = strMainShapeEntry
264 logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
268 #-----------------------------------------------------------------
269 def isMainShape(self,entry):
270 #-----------------------------------------------------------------
273 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
275 shape = monObjet._narrow( GEOM.GEOM_Object )
276 if shape.IsMainShape():
279 logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
284 #-----------------------------------------------------------------
285 def ChercheType( self, shape ):
286 #-----------------------------------------------------------------
287 tgeo = shape.GetShapeType()
288 geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
289 #print dir(self.editor.study)
290 groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
291 if tgeo != "COMPOUND" : return tgeo
293 strInfo = groupIMeasureOp.WhatIs( shape )
295 l = strInfo.split('\n')
298 nom, valeur = couple.split(':')
299 dictInfo[ nom.strip() ] = valeur.strip()
301 ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
303 if dictInfo[ t ] != '0':
309 #-----------------------------------------------------------------
310 def selectShape( self, editor, entry, kwType = None ):
311 #-----------------------------------------------------------------
313 selection sous-geometrie dans Salome:
314 -test1) si c'est un element sous-geometrique .
315 -test2) si appartient a la geometrie principale.
317 name, msgError = '',''
318 mySO = self.editor.study.FindObjectID(entry)
320 return name, msgError
321 object = mySO.GetObject()
323 return name, msgError
326 shape = object._narrow( GEOM.GEOM_Object )
328 return name, msgError
330 tGeo=self.ChercheType(shape)
332 return name, msgError
333 #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
334 # name,msgError = '',"la selection n est pas un Vertex"
335 # return name, msgError
336 if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
337 name, msgError = '', "la selection n est pas un groupe de maille"
338 return name, msgError
340 mainShapeEntry = self.getMainShapeEntry( entry )
341 if self.mainShapeNames.has_key( editor ):
342 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
343 if self.mainShapeNames[editor] == mainShapeEntry:
346 msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
348 self.mainShapeNames[editor] = mainShapeEntry
351 return name, msgError
354 #-----------------------------------------------------------------
355 def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
356 #-----------------------------------------------------------------
358 selection groupe de maille dans Salome:
359 -test 1) si c'est un groupe de maille
360 -test 2) si le maillage fait reference a la geometrie principale
362 name, msgError = '',''
364 mySO=self.editor.study.FindObjectID(selectedEntry )
365 from salome.smesh.smeshstudytools import SMeshStudyTools
366 monSMeshStudyTools=SMeshStudyTools(self.editor)
367 meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
368 if meshSO == None : return name, msgError
370 # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
372 groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
374 logger.debug("selectedMeshEntry: An error occurs")
377 aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
378 if aGroup: tGroup = aGroup.GetType()
380 if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
381 msgError = self.tr("GROUP_NO attend un groupe de noeud")
382 return name, msgError
383 elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
384 msgError = self.tr("GROUP_MA attend un point goupe de maille")
385 return name, msgError
387 # on cherche la shape associee
388 #PN PN mesh_Object est un SOject
389 meshObject = meshSO.GetObject()
390 mesh = meshObject._narrow( SMESH.SMESH_Mesh )
391 if mesh: #c'est bien un objet maillage
392 shape = mesh.GetShapeToMesh()
394 ior = salome.orb.object_to_string( shape )
396 sObject = self.editor.study.FindObjectIOR( ior )
397 mainShapeID = sObject.GetID()
401 return name, self.tr("Type d objet non permis")
403 # on cherche si la shape associee est la bonne
404 #print "------------- mainShapeID" , mainShapeID
405 if self.mainShapeNames.has_key( editor ):
406 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
407 if self.mainShapeNames[editor] == mainShapeID:
410 msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
412 self.mainShapeNames[editor] = mainShapeID
415 #print "------------------------------ name :", name
416 #print "------------------------------ name :", name
417 #print "------------------------------ name :", name
421 def displayMeshGroups(self, meshGroupName):
423 visualisation group de maille de nom meshGroupName dans salome
425 ok, msgError = False, ''
428 sg = salome.ImportComponentGUI('SMESH')
429 meshGroupEntries = []
431 selMeshGroupEntry = None
433 # liste des groupes de maille de nom meshGroupName
434 listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
436 #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
439 return 0,self.tr('Plusieurs objets portent ce nom')
441 return 0,self.tr('Aucun objet ne porte ce nom')
443 groupEntry = SObjet.GetID()
444 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
445 SCom = self.editor.study.FindComponent("SMESH")
446 myBuilder = self.editor.study.NewBuilder()
447 myBuilder.LoadWith( SCom , myComponent )
448 sg.CreateAndDisplayActor(groupEntry)
449 #color = COLORS[ self.icolor % LEN_COLORS ]
450 #self.icolor = self.icolor + 1
451 #sg.SetColor(groupEntry, color[0], color[1], color[2])
452 salome.sg.Display(groupEntry)
458 msgError = self.tr("Impossible d afficher ")+shapeName
462 # ___________________________ Methodes appelees par EFICAS __________________________________
463 #----------------------------------------------------------------
464 def selectGroupFromSalome( self, kwType = None, editor=None):
465 #----------------------------------------------------------------
467 Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille) partir de l'arbre salome
468 retourne ( la liste des noms des groupes, message d'erreur )
470 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
474 atLeastOneStudy = self.editor.study
475 if not atLeastOneStudy:
478 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
479 entries = salome.sg.getAllSelected()
480 nbEntries = len( entries )
482 for entry in entries:
483 if self.isMeshGroup(entry): # selection d 'un sous maillage
484 name, msg = self.selectMeshGroup( editor, entry, kwType )
485 elif self.isShape(entry): # selection d'une sous-geometrie
486 name, msg = self.selectShape( editor, entry, kwType )
488 name, msg = None,self.tr("Selection SALOME non autorisee.")
493 logger.debug("selectGroupFromSalome: An error occurs")
494 #print "=================== selectGroupFromSalome ", names, msg
495 #print "=================== selectGroupFromSalome ", names, msg
496 #print "=================== selectGroupFromSalome ", names, msg
499 #----------------------------------------------------------------
500 def selectMeshFile( self, editor=None):
501 #----------------------------------------------------------------
505 atLeastOneStudy = self.editor.study
506 if not atLeastOneStudy: return "", 'Pas d etude'
508 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
509 entries = salome.sg.getAllSelected()
510 nbEntries = len( entries )
511 if nbEntries != 1 : return "", 'select a Mesh'
513 if not self.isMesh(entry): return "", 'select a Mesh'
514 mySO=self.editor.study.FindObjectID(entry)
516 ok, anAttr = mySO.FindAttribute("AttributeName")
517 if not ok : return "" ,'Pb de nommage'
518 meshFile="/tmp/"+str(anAttr.Value())+'.med'
519 myMesh=self.getMesh(entry)
520 if myMesh==None : return "" ,'Pb dans la selection '
521 myMesh.ExportMED( meshFile, 0)
524 return "", "Pb dans la selection "
526 #----------------------------------------------------------------
527 def importMedFile( self,fileName, editor=None):
528 #----------------------------------------------------------------
530 theStudy = self.editor.study
531 if not theStudy: return (0, 'Pas d etude')
532 from salome.smesh import smeshBuilder
533 smesh = smeshBuilder.New(theStudy)
534 aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
535 salome.sg.updateObjBrowser(1)
538 return (O,"Pb a l import")
540 #----------------------------------------------------------------
541 def selectEntryFromSalome( self, kwType = None, editor=None):
542 #----------------------------------------------------------------
544 Selection d'element a partir de l'arbre salome
545 Ne verifie que l unicite de la selection
546 retourne ( la liste avec le nom du groupe, message d'erreur )
548 retourne une liste pour etre coherent avec selectGroupFromSalome
549 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
552 if self.editor.study._non_existent():
553 raise Exception(self.tr(u"L'etude Salome n'existe plus"))
554 entries = salome.sg.getAllSelected()
555 nbEntries = len( entries )
557 raise Exception(self.tr(u"Veuillez selectionner une entree de l'arbre d'etude de Salome"))
559 raise Exception(self.tr(u"Une seule entree doit être selectionnee dans l'arbre d'etude de Salome"))
561 value = kwType.get_selected_value(entries[0], self.editor)
562 msg = self.tr(u"L'entree de l'arbre d'etude de Salome a ete selectionnee")
565 QMessageBox.information(self, self.tr(u"Selection depuis Salome"), unicode(e))
566 return [], unicode(e)
569 #---------------------------------------------
570 def addJdcInSalome( self, jdcPath ):
571 #---------------------------------------------
573 Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
576 msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
579 atLeastOneStudy = self.editor.study
580 if not atLeastOneStudy:
583 fileType = { 'TELEMAC' : "FICHIER_EFICAS_TELEMAC",
584 'ADAO' : "FICHIER_EFICAS_ADAO",
585 'SEP' : "FICHIER_EFICAS_SEP",
586 'SPECA' : "FICHIER_EFICAS_SPECA",
587 'MT' : "FICHIER_EFICAS_MT",
588 'CF' : "FICHIER_EFICAS_CF",
589 'MAP' : "FICHIER_EFICAS_MAP",
590 'CARMEL3D' : "FICHIER_EFICAS_CARMEL3D",
594 folderName = { 'TELEMAC' : "TelemacFiles",
595 'ADAO' : "AdaoFiles",
597 'SPECA' : "SpecaFiles",
600 'CARMEL3D' : 'CARMEL3DFiles' ,
605 folderType = { 'TELEMAC' : "TELEMAC_FILE_FOLDER",
606 'ADAO' : "ADAO_FILE_FOLDER",
607 'SEP' : "SEP_FILE_FOLDER",
608 'SPECA' : "SPECA_FILE_FOLDER",
609 'MT' : "MT_FILE_FOLDER",
610 'CF' : "CF_FILE_FOLDER",
611 'SEP' : "SEP_FILE_FOLDER",
612 'MAP' : "MAP_FILE_FOLDER",
613 'CARMEL3D' : "CARMEL3D_FILE_FOLDER",
617 moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
618 itemName = re.split("/",jdcPath)[-1]
620 if folderName.has_key(self.code) :
621 monFolderName=folderName[ self.code ]
623 monFolderName=str(self.code)+"Files"
625 if folderType.has_key(self.code) :
626 monFolderType=fileType[ self.code ]
628 monFolderType=str(self.code)+"_FILE_FOLDER"
630 if fileType.has_key(self.code) :
631 monFileType=fileType[ self.code ]
633 monFileType="FICHIER_EFICAS_"+str(self.code)
635 fatherEntry = self.editor.findOrCreateItem(
637 name = monFolderName,
638 #icon = "ICON_COMM_FOLDER",
639 fileType = monFolderType)
641 commEntry = self.editor.findOrCreateItem( fatherEntry ,
643 fileType = monFileType,
645 #icon = "ICON_COMM_FILE",
646 comment = str( jdcPath ))
648 salome.sg.updateObjBrowser(1)
650 #print 'addJdcInSalome commEntry->', commEntry
652 ok, msgError = True, ''
653 except Exception, exc:
654 msgError = "Can't add Eficas file to Salome study tree"
655 logger.debug(msgError, exc_info = True)
656 QMessageBox.warning(self, self.tr("Warning"),
657 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de details " % (msgError, exc)))
661 #---------------------------------------
662 def displayShape( self, shapeName ):
663 #---------------------------------------
665 visualisation de nom shapeName dans salome
667 ok, msgError = False, ''
671 sgPyQt = SalomePyQt.SalomePyQt()
672 myActiveView=sgPyQt.getActiveView()
673 if myActiveView < 0 :
674 return ok, 'pas de vue courante'
676 currentViewType=sgPyQt.getViewType(myActiveView)
677 if str(currentViewType) != "OCCViewer" : # maillage
678 ok, msgError = self.displayMeshGroups(shapeName)
680 current_color = COLORS[ self.icolor % LEN_COLORS ]
681 from salome.geom.geomtools import GeomStudyTools
682 myGeomTools=GeomStudyTools(self.editor)
683 ok = myGeomTools.displayShapeByName( shapeName, current_color )
685 self.icolor = self.icolor + 1
687 msgError =self.tr("Impossible d afficher ")+shapeName
693 #---------------------------------------
694 def ChercheGrpMeshInSalome(self):
695 #---------------------------------------
696 print "je passe par la"
701 entries = salome.sg.getAllSelected()
702 nbEntries = len( entries )
703 names, msg = None, self.tr("Selection SALOME non autorisee.")
705 for entry in entries:
706 names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
712 #---------------------------------------
713 def ChercheGrpMailleInSalome(self):
714 #---------------------------------------
719 entries = salome.sg.getAllSelected()
720 nbEntries = len( entries )
721 names, msg = None, self.tr("Selection SALOME non autorisee.")
723 for entry in entries:
725 names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
736 #-------------------------------------------------------------------------------------------------------
737 # Pilotage de la Visu des elements de structures
741 def envoievisu(self,liste_commandes):
743 from salome.geom.structelem import StructuralElementManager, InvalidParameterError
745 QMessageBox.critical(self, self.tr("Error"),
746 self.tr("Impossible d'afficher les elements de structure: "
747 "module GEOM n est pas installe."))
750 atLeastOneStudy = self.editor.study
751 if not atLeastOneStudy:
753 logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
754 structElemManager = StructuralElementManager()
755 elem = structElemManager.createElement(liste_commandes)
757 salome.sg.updateObjBrowser(True)
758 except InvalidParameterError, err:
759 trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
760 "greater than %(minval)g (actual value is %(value)g)")
761 msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
762 "minval": err.minValue, "value": err.value}
763 QMessageBox.warning(self, self.tr("Error"), msg)
765 traceback.print_exc()
766 logger.debug(10*'#'+":pb dans envoievisu")
771 This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
772 when Eficas is launched in Salome context. It handles the objects that can
773 be selected from Salome object browser.
774 By default, the selected value is the entry of the selected item in the
775 object browser. This class can be subclassed to provide more advanced
779 help_message = u"Une entree de l'arbre d'etude de Salome est attendue"
781 def __init__(self, entryStr):
782 self._entry = entryStr
785 def __convert__(entryStr):
786 return SalomeEntry(entryStr)
789 def get_selected_value(selected_entry, study_editor):
790 return selected_entry
793 #-------------------------------------------------------------------------------------------------------
794 # Point d'entree lancement EFICAS
796 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
797 logger.debug(10*'#'+":runEficas: START")
799 logger.debug(10*'#'+":runEficas: code="+str(code))
800 logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
801 logger.debug(10*'#'+":runEficas: module="+str(module))
802 logger.debug(10*'#'+":runEficas: version="+str(version))
804 #if not appli: #une seul instance possible!
805 appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
806 module = module, version = version, componentName = componentName,multi=multi )
807 #if not appli: #une seul instance possible!
808 # appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
809 # module = module, componentName = componentName, version=version )
810 logger.debug(10*'#'+":runEficas: END")