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,lang=None):
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 if lang!=None : langue=lang
95 else : langue=str(sgPyQt.stringSetting("language","language"))
97 qtEficas.Appli.__init__( self,code=code,salome=1,parent=parent,multi=multi,langue=langue)
99 #--------------- specialisation EFICAS dans SALOME -------------------
101 self.salome = True #active les parties de code specifique dans Salome( pour le logiciel Eficas )
102 self.module = module #indique sous quel module dans l'arbre d'etude ajouter le JDC.
103 self.componentName = componentName
105 # donnee pour la creation de groupe de maille
106 self.mainShapeNames = {} #dictionnaire pour gerer les multiples fichiers possibles ouverts par
107 #eficas ( cle = identifiant du JDC ), une mainshape par fichier ouvert.
108 #dictionnaire des sous-geometrie de la geometrie principale ( cle = entry, valeur = name )
109 #----------------------------------------------------------------------
111 self.icolor = 0 # compteur pour memoriser la couleur courante
115 def closeEvent(self,event):
120 if hasattr(self,'readercata') :
129 from Extensions.param2 import originalMath
130 #Numeric.cos=originalMath.numeric_ncos
131 #Numeric.sin=originalMath.numeric_nsin
132 #Numeric.array=originalMath.numeric_narray
133 #math.sin=originalMath.sin
134 #math.cos=originalMath.cos
135 #math.sqrt=originalMath.sqrt
136 #math.ceil=originalMath.ceil
137 #math.pi=originalMath.pi
138 originalMath.toOriginal()
145 # ___________________________ Methodes de l ex Pal __________________________________
147 #----------------------------------------------------------------
148 def getCORBAObjectInComponent( self, entry, composant ):
149 #----------------------------------------------------------------
151 mySO = self.editor.study.FindObjectID(entry)
153 object = mySO.GetObject()
155 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", composant)
156 SCom = self.editor.study.FindComponent( composant )
157 print myComponent , SCom
158 self.editor.builder.LoadWith( SCom , myComponent )
159 object = mySO.GetObject()
161 logger.debug("selectedEntry: An error occurs")
165 #----------------------------------------------
166 def giveMeshGroups( self,entry,label1,typeMesh):
167 #----------------------------------------------
172 monMaillage =self.getCORBAObjectInComponent(entry,"SMESH")
173 if monMaillage != None : # selection d'un groupe de SMESH
174 if monMaillage._narrow(SMESH.SMESH_Mesh):
175 mailSO = self.editor.study.FindObjectID(entry)
176 if mailSO == None : return names, msg
179 subIt = self.editor.study.NewChildIterator(mailSO)
181 subSO = subIt.Value()
184 if (subSO.GetName()[0:9]!=label1) : continue
185 subSSMeshit=self.editor.study.NewChildIterator(subSO)
186 while subSSMeshit.More():
187 subSSMeshSO = subSSMeshit.Value()
189 if subSSMeshSO.GetObject()._narrow(typeMesh):
190 names.append(subSSMeshSO.GetName())
192 msg=entry + self.tr(" n est pas un maillage")
194 logger.debug(' giveMeshGroups pb avec ( entry = %s ) ' %entry )
195 msg=' giveMeshGroup pb avec ( entry = %s ) '+ entry
198 #-------------------------------------
199 def isMeshGroup( self,entry):
200 #-------------------------------------
204 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
205 if monObjet != None : # selection d'un groupe de SMESH
206 if monObjet._narrow(SMESH.SMESH_GroupBase):
209 logger.debug(' isMeshGroup pb avec ( entry = %s ) ' %entry )
212 #-------------------------------------
213 def isMesh( self,entry):
214 #-------------------------------------
218 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
219 if monObjet != None : # selection d'un groupe de SMESH
220 if monObjet._narrow(SMESH.SMESH_Mesh):
223 logger.debug(' isMesh pb avec ( entry = %s ) ' %entry )
226 #-------------------------------------
227 def getMesh( self,entry):
228 #-------------------------------------
233 monObjet =self.getCORBAObjectInComponent(entry,"SMESH")
234 if monObjet != None : # selection d'un groupe de SMESH
235 meshObject=monObjet._narrow(SMESH.SMESH_Mesh)
237 logger.debug(' pb avec ( entry = %s ) ' %entry )
240 #-------------------------------------
242 #-------------------------------------
243 def isShape( self,entry):
244 #-------------------------------------
248 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
249 if monObjet != None : # selection d'un objet GEOM
250 if monObjet._narrow(GEOM.GEOM_Object ):
253 logger.debug(' isShape pb avec ( entry = %s ) ' %entry )
256 #-----------------------------------------------------------------
257 def getMainShapeEntry(self,entry):
258 #-----------------------------------------------------------------
261 mainShapeEntry = entry.split(':')[:4]
262 if len(mainShapeEntry) == 4:
263 strMainShapeEntry = '%s:%s:%s:%s'%tuple(mainShapeEntry)
264 if self.isMainShape(strMainShapeEntry):
265 result = strMainShapeEntry
267 logger.debug( 'Erreur pour SalomeStudy.getMainShapeEntry( entry = %s ) ' %entry )
271 #-----------------------------------------------------------------
272 def isMainShape(self,entry):
273 #-----------------------------------------------------------------
276 monObjet =self.getCORBAObjectInComponent(entry,"GEOM")
278 shape = monObjet._narrow( GEOM.GEOM_Object )
279 if shape.IsMainShape():
282 logger.debug( 'Errreur pour SalomeStudy.isMainShape( entry = %s ) ' %entry )
287 #-----------------------------------------------------------------
288 def ChercheType( self, shape ):
289 #-----------------------------------------------------------------
290 tgeo = shape.GetShapeType()
291 geomEngine = salome.lcc.FindOrLoadComponent( "FactoryServer", "GEOM" )
292 #print dir(self.editor.study)
293 groupIMeasureOp = geomEngine.GetIMeasureOperations(self.editor.study._get_StudyId())
294 if tgeo != "COMPOUND" : return tgeo
296 strInfo = groupIMeasureOp.WhatIs( shape )
298 l = strInfo.split('\n')
301 nom, valeur = couple.split(':')
302 dictInfo[ nom.strip() ] = valeur.strip()
304 ordre = [ "COMPSOLID", "SOLID", "SHELL", "FACE", "WIRE", "EDGE", "VERTEX" ]
306 if dictInfo[ t ] != '0':
312 #-----------------------------------------------------------------
313 def selectShape( self, editor, entry, kwType = None ):
314 #-----------------------------------------------------------------
316 selection sous-geometrie dans Salome:
317 -test1) si c'est un element sous-geometrique .
318 -test2) si appartient a la geometrie principale.
320 name, msgError = '',''
321 mySO = self.editor.study.FindObjectID(entry)
323 return name, msgError
324 object = mySO.GetObject()
326 return name, msgError
329 shape = object._narrow( GEOM.GEOM_Object )
331 return name, msgError
333 tGeo=self.ChercheType(shape)
335 return name, msgError
336 #if kwType == "GROUP_NO" and str(tGeo) != "VERTEX":
337 # name,msgError = '',"la selection n est pas un Vertex"
338 # return name, msgError
339 if kwType == "GROUP_MA" and str(tGeo) == "VERTEX":
340 name, msgError = '', "la selection n est pas un groupe de maille"
341 return name, msgError
343 mainShapeEntry = self.getMainShapeEntry( entry )
344 if self.mainShapeNames.has_key( editor ):
345 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
346 if self.mainShapeNames[editor] == mainShapeEntry:
349 msgError="Le groupe reference la geometrie " + mainShapeEntry + " et non " + self.mainShapeNames[editor]
351 self.mainShapeNames[editor] = mainShapeEntry
354 return name, msgError
357 #-----------------------------------------------------------------
358 def selectMeshGroup( self, editor, selectedEntry, kwType = None ):
359 #-----------------------------------------------------------------
361 selection groupe de maille dans Salome:
362 -test 1) si c'est un groupe de maille
363 -test 2) si le maillage fait reference a la geometrie principale
365 name, msgError = '',''
367 mySO=self.editor.study.FindObjectID(selectedEntry )
368 from salome.smesh.smeshstudytools import SMeshStudyTools
369 monSMeshStudyTools=SMeshStudyTools(self.editor)
370 meshSO = monSMeshStudyTools.getMeshFromGroup(mySO)
371 if meshSO == None : return name, msgError
373 # on verifie que l entree selectionnee a le bon type (NODE ou EDGE...)
375 groupObject = self.getCORBAObjectInComponent(selectedEntry,"SMESH")
377 logger.debug("selectedMeshEntry: An error occurs")
380 aGroup = groupObject._narrow( SMESH.SMESH_GroupBase )
381 if aGroup: tGroup = aGroup.GetType()
383 if kwType == "GROUP_NO" and tGroup != SMESH.NODE:
384 msgError = self.tr("GROUP_NO attend un groupe de noeud")
385 return name, msgError
386 elif kwType == "GROUP_MA" and tGroup == SMESH.NODE:
387 msgError = self.tr("GROUP_MA attend un point goupe de maille")
388 return name, msgError
390 # on cherche la shape associee
391 #PN PN mesh_Object est un SOject
392 meshObject = meshSO.GetObject()
393 mesh = meshObject._narrow( SMESH.SMESH_Mesh )
394 if mesh: #c'est bien un objet maillage
395 shape = mesh.GetShapeToMesh()
397 ior = salome.orb.object_to_string( shape )
399 sObject = self.editor.study.FindObjectIOR( ior )
400 mainShapeID = sObject.GetID()
404 return name, self.tr("Type d objet non permis")
406 # on cherche si la shape associee est la bonne
407 #print "------------- mainShapeID" , mainShapeID
408 if self.mainShapeNames.has_key( editor ):
409 #print "------------- self.mainShapeNames[editor]" , self.mainShapeNames[editor]
410 if self.mainShapeNames[editor] == mainShapeID:
413 msgError=self.tr("Le groupe reference la geometrie ") + mainShapeID + self.tr(" et non ") + self.mainShapeNames[editor]
415 self.mainShapeNames[editor] = mainShapeID
418 #print "------------------------------ name :", name
419 #print "------------------------------ name :", name
420 #print "------------------------------ name :", name
424 def displayMeshGroups(self, meshGroupName):
426 visualisation group de maille de nom meshGroupName dans salome
428 ok, msgError = False, ''
431 sg = salome.ImportComponentGUI('SMESH')
432 meshGroupEntries = []
434 selMeshGroupEntry = None
436 # liste des groupes de maille de nom meshGroupName
437 listSO = self.editor.study.FindObjectByName(meshGroupName, "SMESH")
439 #print "liste des groupes de maille de nom %s: "%(meshGroupName), listSO
442 return 0,self.tr('Plusieurs objets portent ce nom')
444 return 0,self.tr('Aucun objet ne porte ce nom')
446 groupEntry = SObjet.GetID()
447 myComponent = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
448 SCom = self.editor.study.FindComponent("SMESH")
449 myBuilder = self.editor.study.NewBuilder()
450 myBuilder.LoadWith( SCom , myComponent )
451 sg.CreateAndDisplayActor(groupEntry)
452 #color = COLORS[ self.icolor % LEN_COLORS ]
453 #self.icolor = self.icolor + 1
454 #sg.SetColor(groupEntry, color[0], color[1], color[2])
455 salome.sg.Display(groupEntry)
461 msgError = self.tr("Impossible d afficher ")+shapeName
465 # ___________________________ Methodes appelees par EFICAS __________________________________
466 #----------------------------------------------------------------
467 def selectGroupFromSalome( self, kwType = None, editor=None):
468 #----------------------------------------------------------------
470 Selection d'element(s) d'une geometrie ( sub-shape ) ou d'element(s) de maillage ( groupe de maille) partir de l'arbre salome
471 retourne ( la liste des noms des groupes, message d'erreur )
473 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel GROUPMA
477 atLeastOneStudy = self.editor.study
478 if not atLeastOneStudy:
481 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
482 entries = salome.sg.getAllSelected()
483 nbEntries = len( entries )
485 for entry in entries:
486 if self.isMeshGroup(entry): # selection d 'un sous maillage
487 name, msg = self.selectMeshGroup( editor, entry, kwType )
488 elif self.isShape(entry): # selection d'une sous-geometrie
489 name, msg = self.selectShape( editor, entry, kwType )
491 name, msg = None,self.tr("Selection SALOME non autorisee.")
496 logger.debug("selectGroupFromSalome: An error occurs")
497 #print "=================== selectGroupFromSalome ", names, msg
498 #print "=================== selectGroupFromSalome ", names, msg
499 #print "=================== selectGroupFromSalome ", names, msg
502 #----------------------------------------------------------------
503 def selectMeshFile( self, editor=None):
504 #----------------------------------------------------------------
508 atLeastOneStudy = self.editor.study
509 if not atLeastOneStudy: return "", 'Pas d etude'
511 # recupere toutes les selections de l'utilsateur dans l'arbre Salome
512 entries = salome.sg.getAllSelected()
513 nbEntries = len( entries )
514 if nbEntries != 1 : return "", 'select a Mesh'
516 if not self.isMesh(entry): return "", 'select a Mesh'
517 mySO=self.editor.study.FindObjectID(entry)
519 ok, anAttr = mySO.FindAttribute("AttributeName")
520 if not ok : return "" ,'Pb de nommage'
521 meshFile="/tmp/"+str(anAttr.Value())+'.med'
522 myMesh=self.getMesh(entry)
523 if myMesh==None : return "" ,'Pb dans la selection '
524 myMesh.ExportMED( meshFile, 0)
527 return "", "Pb dans la selection "
529 #----------------------------------------------------------------
530 def importMedFile( self,fileName, editor=None):
531 #----------------------------------------------------------------
533 theStudy = self.editor.study
534 if not theStudy: return (0, 'Pas d etude')
535 from salome.smesh import smeshBuilder
536 smesh = smeshBuilder.New(theStudy)
537 aMesh,aResult = smesh.CreateMeshesFromMED(fileName)
538 salome.sg.updateObjBrowser(1)
541 return (O,"Pb a l import")
543 #----------------------------------------------------------------
544 def selectEntryFromSalome( self, kwType = None, editor=None):
545 #----------------------------------------------------------------
547 Selection d'element a partir de l'arbre salome
548 Ne verifie que l unicite de la selection
549 retourne ( la liste avec le nom du groupe, message d'erreur )
551 retourne une liste pour etre coherent avec selectGroupFromSalome
552 Note: Appele par EFICAS lorsqu'on clique sur le bouton ajouter la liste du panel SalomeEntry
555 if self.editor.study._non_existent():
556 raise Exception(self.tr(u"L'etude Salome n'existe plus"))
557 entries = salome.sg.getAllSelected()
558 nbEntries = len( entries )
560 raise Exception(self.tr(u"Veuillez selectionner une entree de l'arbre d'etude de Salome"))
562 raise Exception(self.tr(u"Une seule entree doit être selectionnee dans l'arbre d'etude de Salome"))
564 value = kwType.get_selected_value(entries[0], self.editor)
565 msg = self.tr(u"L'entree de l'arbre d'etude de Salome a ete selectionnee")
568 QMessageBox.information(self, self.tr(u"Selection depuis Salome"), unicode(e))
569 return [], unicode(e)
572 #---------------------------------------------
573 def addJdcInSalome( self, jdcPath ):
574 #---------------------------------------------
576 Ajoute le Jeu De Commande dans l'arbre d'etude Salome dans la rubrique EFICAS
579 msgError = "Erreur dans l'export du fichier de commande dans l'arbre d'etude Salome"
580 if jdcPath == "" or jdcPath == None : return
583 atLeastOneStudy = self.editor.study
584 if not atLeastOneStudy:
587 fileType = { 'TELEMAC' : "FICHIER_EFICAS_TELEMAC",
588 'ADAO' : "FICHIER_EFICAS_ADAO",
589 'SEP' : "FICHIER_EFICAS_SEP",
590 'SPECA' : "FICHIER_EFICAS_SPECA",
591 'MT' : "FICHIER_EFICAS_MT",
592 'CF' : "FICHIER_EFICAS_CF",
593 'MAP' : "FICHIER_EFICAS_MAP",
594 'CARMEL3D' : "FICHIER_EFICAS_CARMEL3D",
598 folderName = { 'TELEMAC' : "TelemacFiles",
599 'ADAO' : "AdaoFiles",
601 'SPECA' : "SpecaFiles",
604 'CARMEL3D' : 'CARMEL3DFiles' ,
609 folderType = { 'TELEMAC' : "TELEMAC_FILE_FOLDER",
610 'ADAO' : "ADAO_FILE_FOLDER",
611 'SEP' : "SEP_FILE_FOLDER",
612 'SPECA' : "SPECA_FILE_FOLDER",
613 'MT' : "MT_FILE_FOLDER",
614 'CF' : "CF_FILE_FOLDER",
615 'SEP' : "SEP_FILE_FOLDER",
616 'MAP' : "MAP_FILE_FOLDER",
617 'CARMEL3D' : "CARMEL3D_FILE_FOLDER",
621 moduleEntry = self.editor.findOrCreateComponent(self.module, self.componentName)
622 itemName = re.split("/",jdcPath)[-1]
624 if folderName.has_key(self.code) :
625 monFolderName=folderName[ self.code ]
627 monFolderName=str(self.code)+"Files"
629 if folderType.has_key(self.code) :
630 monFolderType=fileType[ self.code ]
632 monFolderType=str(self.code)+"_FILE_FOLDER"
634 if fileType.has_key(self.code) :
635 monFileType=fileType[ self.code ]
637 monFileType="FICHIER_EFICAS_"+str(self.code)
639 fatherEntry = self.editor.findOrCreateItem(
641 name = monFolderName,
642 #icon = "ICON_COMM_FOLDER",
643 fileType = monFolderType)
645 commEntry = self.editor.findOrCreateItem( fatherEntry ,
647 fileType = monFileType,
649 #icon = "ICON_COMM_FILE",
650 comment = str( jdcPath ))
652 salome.sg.updateObjBrowser(1)
654 #print 'addJdcInSalome commEntry->', commEntry
656 ok, msgError = True, ''
657 except Exception, exc:
658 msgError = "Can't add Eficas file to Salome study tree"
659 logger.debug(msgError, exc_info = True)
660 QMessageBox.warning(self, self.tr("Warning"),
661 self.tr("%s. Raison:\n%s\n\n Voir la log pour plus de details " % (msgError, exc)))
665 #---------------------------------------
666 def displayShape( self, shapeName ):
667 #---------------------------------------
669 visualisation de nom shapeName dans salome
671 ok, msgError = False, ''
675 sgPyQt = SalomePyQt.SalomePyQt()
676 myActiveView=sgPyQt.getActiveView()
677 if myActiveView < 0 :
678 return ok, 'pas de vue courante'
680 currentViewType=sgPyQt.getViewType(myActiveView)
681 if str(currentViewType) != "OCCViewer" : # maillage
682 ok, msgError = self.displayMeshGroups(shapeName)
684 current_color = COLORS[ self.icolor % LEN_COLORS ]
685 from salome.geom.geomtools import GeomStudyTools
686 myGeomTools=GeomStudyTools(self.editor)
687 ok = myGeomTools.displayShapeByName( shapeName, current_color )
689 self.icolor = self.icolor + 1
691 msgError =self.tr("Impossible d afficher ")+shapeName
697 #---------------------------------------
698 def ChercheGrpMeshInSalome(self):
699 #---------------------------------------
700 print "je passe par la"
705 entries = salome.sg.getAllSelected()
706 nbEntries = len( entries )
707 names, msg = None, self.tr("Selection SALOME non autorisee.")
709 for entry in entries:
710 names,msg=self.giveMeshGroups(entry,"SubMeshes",SMESH.SMESH_subMesh)
716 #---------------------------------------
717 def ChercheGrpMailleInSalome(self):
718 #---------------------------------------
723 entries = salome.sg.getAllSelected()
724 nbEntries = len( entries )
725 names, msg = None, self.tr("Selection SALOME non autorisee.")
727 for entry in entries:
729 names,msg=self.giveMeshGroups(entry,"Groups of",SMESH.SMESH_GroupBase)
740 #-------------------------------------------------------------------------------------------------------
741 # Pilotage de la Visu des elements de structures
745 def envoievisu(self,liste_commandes):
747 from salome.geom.structelem import StructuralElementManager, InvalidParameterError
749 QMessageBox.critical(self, self.tr("Error"),
750 self.tr("Impossible d'afficher les elements de structure: "
751 "module GEOM n est pas installe."))
754 atLeastOneStudy = self.editor.study
755 if not atLeastOneStudy:
757 logger.debug(10*'#'+":envoievisu: creating a StructuralElementManager instance")
758 structElemManager = StructuralElementManager()
759 elem = structElemManager.createElement(liste_commandes)
761 salome.sg.updateObjBrowser(True)
762 except InvalidParameterError, err:
763 trStr = self.tr("Invalid parameter for group %(group)s: %(expr)s must be "
764 "greater than %(minval)g (actual value is %(value)g)")
765 msg = str(trStr) % {"group": err.groupName, "expr": err.expression,
766 "minval": err.minValue, "value": err.value}
767 QMessageBox.warning(self, self.tr("Error"), msg)
769 traceback.print_exc()
770 logger.debug(10*'#'+":pb dans envoievisu")
775 This class replaces the class Accas.SalomeEntry (defined in EFICAS tool)
776 when Eficas is launched in Salome context. It handles the objects that can
777 be selected from Salome object browser.
778 By default, the selected value is the entry of the selected item in the
779 object browser. This class can be subclassed to provide more advanced
783 help_message = u"Une entree de l'arbre d'etude de Salome est attendue"
785 def __init__(self, entryStr):
786 self._entry = entryStr
789 def __convert__(entryStr):
790 return SalomeEntry(entryStr)
793 def get_selected_value(selected_entry, study_editor):
794 return selected_entry
797 #-------------------------------------------------------------------------------------------------------
798 # Point d'entree lancement EFICAS
800 def runEficas( code=None, fichier=None, module = "EFICAS", version=None, componentName = "Eficas",multi=False):
801 logger.debug(10*'#'+":runEficas: START")
803 logger.debug(10*'#'+":runEficas: code="+str(code))
804 logger.debug(10*'#'+":runEficas: fichier="+str(fichier))
805 logger.debug(10*'#'+":runEficas: module="+str(module))
806 logger.debug(10*'#'+":runEficas: version="+str(version))
808 #if not appli: #une seul instance possible!
809 appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
810 module = module, version = version, componentName = componentName,multi=multi )
811 #if not appli: #une seul instance possible!
812 # appli = MyEficas( SalomePyQt.SalomePyQt().getDesktop(), code = code, fichier = fichier,
813 # module = module, componentName = componentName, version=version )
814 logger.debug(10*'#'+":runEficas: END")