]> SALOME platform Git repositories - tools/eficas.git/blob - InterfaceQT4/editor.py
Salome HOME
update version
[tools/eficas.git] / InterfaceQT4 / editor.py
1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2021   EDF R&D
3 #
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 # Lesser General Public License for more details.
13 #
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 #
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 #
20 from __future__ import absolute_import
21 from __future__ import print_function
22 try :
23     from builtins import str
24     from builtins import range
25 except : pass
26
27 import types,sys,os, re
28 import  subprocess
29 import traceback
30
31
32 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
33 from PyQt5.QtGui     import QPalette
34 from PyQt5.QtCore    import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
35
36 import traceback
37
38 # Modules Eficas
39 from Extensions.i18n import tr
40
41 from Editeur        import session
42 from Editeur        import comploader
43 from Editeur        import Objecttreeitem
44 from InterfaceQT4   import browser
45
46 from desBaseWidget    import Ui_baseWidget
47 from InterfaceQT4.monViewTexte   import ViewText
48 from monWidgetCreeParam import MonWidgetCreeParam
49
50 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
51 debug = False
52
53
54 from InterfaceQT4.editorSsIhm    import JDCEditorSsIhm
55
56
57 class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
58 # ----------------------------------------- #
59     """
60        Editeur de jdc
61     """
62
63 # ----------------------------------------
64 # Methodes faisant appel a ssIhm
65 # ----------------------------------------
66
67     def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, units = None, include=0):
68     #------------------------------------------------------------------------------------------------
69
70
71         QWidget.__init__(self,None)
72         self.setupUi(self)
73
74         self.inhibeSplitter=0
75         self.widgetOptionnel=None
76         self.fenetreCentraleAffichee=None
77         self.dejaDansPlieTout=False
78         self.listeDesListesOuvertes=set()
79         if appliEficas!=None and hasattr(appliEficas,"statusBar"): self.sb = appliEficas.statusBar()
80         else : self.sb = None
81         self.QWParent=QWParent
82
83         JDCEditorSsIhm. __init__ (self,appliEficas,fichier, jdc,units,include)
84         if self.jdc:
85             comploader.chargerComposants()
86             self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
87
88
89         # Particularites IHM : met la fenetre a jour
90
91         self.initSplitterSizes()
92
93         #self.affiche=self.appliEficas.maConfiguration.affiche
94
95         self.afficheListesPliees=self.maConfiguration.afficheListesPliees
96         if self.code in ['MAP','CARMELCND','PSEN'] : self.maConfiguration.afficheCommandesPliees=False
97         if self.code in ['MAP',]: self.fermeArbre()
98         #   self.widgetTree.close()
99         #   self.widgetTree=None
100
101         if self.maConfiguration.closeArbre      : self.fermeArbre()
102         if self.maConfiguration.closeOptionnel  : self.fermeOptionnel()
103         if self.maConfiguration.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
104
105
106         self.formatFichierOut =  self.appliEficas.formatFichierOut
107         self.formatFichierIn  =  self.appliEficas.formatFichierIn
108
109         self.node_selected = []
110         self.deplier = True
111         self.message=''
112         self.afficheApresInsert=False
113         if self.maConfiguration.closeArbre    : self.afficheApresInsert=True
114         if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
115         if self.code in ['TELEMAC',]          : self.enteteQTree='premier'
116         else                                  : self.enteteQTree='complet'
117         if self.code in ['Adao','ADAO','TELEMAC','VP'] : self.affichePlie=True
118         else                                      : self.affichePlie=False
119
120         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
121
122         if self.appliEficas.readercata.demandeCatalogue==True  :
123             nomFichierTranslation='translatorFichier'+'_'+str(self.appliEficas.readercata.labelCode)
124             if hasattr(self.appliEficas.maConfiguration,nomFichierTranslation) :
125                 translatorFichier=getattr(self.appliEficas.maConfiguration,nomFichierTranslation)
126                 from Extensions import localisation
127                 localisation.localise(None,self.appliEficas.langue,translatorFichier=translatorFichier)
128
129
130         if self.jdc_item and self.appliEficas.ssIhm==False :
131             self.tree = browser.JDCTree( self.jdc_item,  self )
132         self.appliEficas.construitMenu()
133
134         self.adjustSize()
135
136
137     #-------------------------------#
138     def readFile(self, fn):
139     #--------------------------------#
140         """
141         Public slot to read the text from a file.
142         @param fn filename to read from (string or QString)
143         """
144
145         jdc=JDCEditorSsIhm.readFile(self, fn)
146
147         # Particularites IHM : met le titre de la fenetre a jour
148 #        qApp.restoreOverrideCursor()
149         if self.fileInfo!= None : self.lastModified = self.fileInfo.lastModified()
150         nouveauTitre=self.titre+"              "+os.path.basename(self.fichier)
151         self.appliEficas.setWindowTitle(nouveauTitre)
152
153         return jdc
154
155 # ---------------------------------------------
156 # Methodes Inchangees
157 # ---------------------------------------------
158 #   _newJDC
159 #   _newJDCInclude
160 #   __generateTempFilename
161 #   getSource
162 #   generDico
163 #   viewJdcSource
164 #   viewJdcPy
165 #   viewJdcRapport
166 #   getFileName
167 #   initModif
168 #   writeFile
169 #   getTextJDC
170 #   verifieChecksum
171 #   getChecksum
172 #   getDico
173 #   chercheGroupes
174 #   chercheDico
175 #   saveFileLegerAs
176
177 # ---------------------------------------------
178 # Methodes Surchargees
179 # ---------------------------------------------
180
181     #-----------------------------------------------------------------------#
182     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
183     #--------------------------------------------------------------------#
184         w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
185         w.show()
186
187     #--------------------------------#
188     def informe(self,titre,txt,critique=True):
189     #--------------------------------#
190         if  critique :
191             self.afficheInfos(tr(txt),Qt.red)
192             QMessageBox.critical( self, tr(titre), tr(txt))
193         else :
194             QMessageBox.warning( self, tr(titre),tr(txt))
195
196     #--------------------------------#
197     def ajoutCommentaire(self):
198     #--------------------------------#
199         if self.tree.selectedItems()==[] :
200             QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
201             return
202         noeudAvantCommentaire=self.tree.selectedItems()[0]
203         if noeudAvantCommentaire ==self.tree.racine :
204             self.tree.racine.appendChild("COMMENTAIRE",pos=0)
205             return
206         noeudAvantCommentaire.addComment(True)
207
208
209     #----------------------------------------------#
210     def _viewTextExecute(self, txt, prefix, suffix):
211     #----------------------------------------------#
212         self.w = ViewText( self.QWParent )
213         self.w.setWindowTitle( "execution" )
214         self.monExe=QProcess(self.w)
215         pid=self.monExe.pid()
216         nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
217         f=open(nomFichier,'w')
218         f.write(txt)
219         f.close()
220         self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
221         self.monExe.readyReadStandardError.connect( self.readFromStdErr)
222         exe='sh ' + nomFichier
223         self.monExe.start(exe)
224         self.monExe.closeWriteChannel()
225         self.w.exec_()
226         try:
227             commande="rm  "+ nomFichier
228             os.system(commande)
229         except :
230             pass
231
232     def readFromStdErr(self):
233         a=self.monExe.readAllStandardError()
234         self.w.view.append(str(a.data()))
235
236     def readFromStdOut(self) :
237         a=self.monExe.readAllStandardOutput()
238         self.w.view.append(str(a.data()))
239
240
241     #-----------------------#
242     def gestionParam(self):
243     #-----------------------#
244         w = MonWidgetCreeParam( self)
245         w.show()
246
247
248     #----------------#
249     def closeIt(self):
250     #----------------#
251         """
252         Public method called by the viewmanager to finally get rid of us.
253         """
254         if self.jdc: self.jdc.supprime()
255         self.close()
256
257     #----------------------------------------------#
258     def afficheInfos(self,message,couleur=Qt.black):
259     #----------------------------------------------#
260         if couleur=='red' : couleur = Qt.red
261         if self.sb:
262             mapalette=self.sb.palette()
263             mapalette.setColor( QPalette.WindowText, couleur )
264             self.sb.setPalette( mapalette );
265             self.sb.showMessage(message,4000)
266             self.couleur=couleur
267
268     #------------------------------#
269     def afficheAlerte(self,titre,message):
270     #------------------------------#
271     # appele par I_MACRO_ETAPE
272         QMessageBox.information( self, titre, message)
273
274     #-----------------------------------#
275     def afficheCommentaire(self,message):
276     #-----------------------------------#
277         self.labelCommentaire.setText(message)
278         QTimer.singleShot(6000, self.rendInvisible)
279
280     #----------------------#
281     def rendInvisible(self):
282     #----------------------#
283         self.labelCommentaire.setText("")
284
285     #---------------------------------------#
286     def chercheNoeudSelectionne(self,copie=1):
287     #---------------------------------------#
288         """
289           appele par Cut et Copy pour positionner self.node_selected
290         """
291         self.node_selected=[]
292         if len(self.tree.selectedItems()) == 0 : return
293         self.node_selected=self.tree.selectedItems()
294
295
296     #---------------------#
297     def handleSupprimer(self):
298     #---------------------#
299         self.chercheNoeudSelectionne()
300         if len(self.node_selected) == 0 : return
301         self.QWParent.noeud_a_editer = []
302         if self.node_selected[0]==self.tree.racine: return
303         if len(self.node_selected) == 1 : self.node_selected[0].delete()
304         else : self.node_selected[0].deleteMultiple(self.node_selected)
305
306     #---------------------#
307     def handleRechercher(self):
308     #---------------------#
309         from .monRecherche import DRecherche
310         monRechercheDialg=DRecherche(parent=self,fl=0)
311         monRechercheDialg.show()
312
313
314     #--------------------------------#
315     def handleRechercherDsCatalogue(self):
316     #-----------------------------#
317         from .monRechercheCatalogue import DRechercheCatalogue
318         monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
319         monRechercheDialg.show()
320
321     #---------------------#
322     def handleDeplier(self):
323     #---------------------#
324         if self.tree == None : return
325         #self.tree.collapseAll()
326         if self.deplier :
327             #print "je plie"
328             self.tree.expandItem(self.tree.topLevelItem(0))
329             self.deplier = False
330             if self.fenetreCentraleAffichee != None  :
331                 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
332                     self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
333         else:
334             #print "je deplie"
335             self.tree.expandItem(self.tree.topLevelItem(0))
336             self.deplier = True
337             if self.fenetreCentraleAffichee != None  :
338                 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
339                     self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
340
341     #---------------------#
342     def handleEditCut(self):
343     #---------------------#
344         """
345         Stocke dans Eficas.noeud_a_editer le noeud a couper
346         """
347         #print "handleEditCut"
348         self.chercheNoeudSelectionne()
349         self.QWParent.edit="couper"
350         self.QWParent.noeud_a_editer = self.node_selected
351
352     #-----------------------#
353     def handleEditCopy(self):
354     #-----------------------#
355         """
356         Stocke dans Eficas.noeud_a_editer le noeud a copier
357         """
358         self.chercheNoeudSelectionne()
359         if len(self.node_selected) == 0 : return
360         if len(self.node_selected) == 1 : self.node_selected[0].updateNodeLabelInBlue()
361         else :  self.node_selected[0].updatePlusieursNodeLabelInBlue(self.node_selected)
362         self.QWParent.edit="copier"
363         self.QWParent.noeud_a_editer = self.node_selected
364
365     #------------------------#
366     def handleEditPaste(self):
367     #------------------------#
368         """
369         Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
370         Ne permet que la copie d'objets de type Commande ou MCF
371         """
372         self.chercheNoeudSelectionne()
373         if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
374             QMessageBox.information( self,
375                         tr("Copie impossible"),
376                         tr("Veuillez selectionner un objet a copier"))
377             return
378         if len(self.node_selected) != 1 :
379             QMessageBox.information( self,
380                         tr("Copie impossible"),
381                         tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
382             return
383         noeudOuColler=self.node_selected[0]
384
385         if len(self.QWParent.noeud_a_editer)!=1:
386             #self.handleEditPasteMultiple()
387             QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
388             return
389
390         noeudACopier=self.QWParent.noeud_a_editer[0]
391
392         if (self.QWParent.edit != "couper"):
393         #print   (noeudOuColler.item.parent.getChild(noeudOuColler.item.nom))
394             try:
395                 if noeudOuColler == self.tree.racine :
396                     child=noeudOuColler.doPastePremier(noeudACopier)
397                 else :
398                     child=noeudACopier.doPaste(noeudOuColler,'after')
399
400                 if child==None or child==0:
401                     QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
402                     self.message = ''
403                     self.afficheInfos("Copie refusee",Qt.red)
404                 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
405                     try :
406                         nom=noeudACopier.item.sd.nom
407                         child.item.nommeSd(nom)
408                     except :
409                         pass
410                 return
411                 self.initModif()
412                 child.select()
413             except  :
414                 traceback.print_exc()
415                 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
416                 self.message = ''
417                 self.afficheInfos("Copie refusee",Qt.red)
418                 return
419
420         # il faut declarer le JDCDisplay_courant modifie
421         # suppression eventuelle du noeud selectionne
422         # si possible on renomme l objet comme le noeud couper
423
424         if (self.QWParent.edit == "couper"):
425             if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
426                 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
427
428             #if 1:
429             try :
430                 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
431                 indexNoeudACopier=self.getTreeIndex(noeudACopier)
432                 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
433                 noeudACopier.treeParent.buildChildren()
434
435             #else:
436             except:
437                 pass
438             self.QWParent.noeud_a_editer=[]
439
440         # on rend la copie a nouveau possible en liberant le flag edit
441         self.QWParent.edit="copier"
442         noeudACopier.select()
443
444     #----------------------------------#
445     def handleDeplaceMultiple(self):
446     #----------------------------------#
447         pass
448
449     #----------------------------------#
450     def handleEditPasteMultiple(self):
451     #----------------------------------#
452
453     # On ne garde que les niveaux "Etape"
454     # On insere dans l'ordre du JDC
455         listeNoeudsACouper=[]
456         listeIndex=[]
457         listeChild=[]
458         listeItem=[]
459         from InterfaceQT4 import compojdc
460         noeudOuColler=self.node_selected[0]
461         if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
462             QMessageBox.information( self,
463                       tr("Copie impossible a cet endroit",),
464                       tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
465             return
466         indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
467
468         for noeud in self.QWParent.noeud_a_editer :
469             if not (isinstance(noeud.treeParent, compojdc.Node)): continue
470             indexInTree=noeud.treeParent.children.index(noeud)
471             indice = 0
472             for index in listeIndex:
473                 if index < indexInTree : indice = indice +1
474             listeIndex.insert(indice, indexInTree)
475             listeNoeudsACouper.insert(indice, noeud)
476
477         noeudJdc=noeudOuColler.treeParent
478         dejaCrees=0
479         # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
480         listeIndex.reverse()
481         for index in listeIndex:
482             indexTravail=index
483             if indexNoeudOuColler < index:
484                 indexTravail=indexTravail+dejaCrees
485             noeudOuColler=noeudJdc.children[indexNoeudOuColler]
486             noeud=noeudJdc.children[indexTravail]
487             child=noeud.doPaste(noeudOuColler)
488             listeChild.append(child)
489             dejaCrees=dejaCrees+1
490
491         self.QWParent.noeud_a_editer = []
492         for i in range(len(listeIndex)):
493             noeud=noeudJdc.children[indexNoeudOuColler+1+i]
494             self.QWParent.noeud_a_editer.append(noeud)
495
496         listeASupprimer=[]
497         if self.QWParent.edit !="couper" : return
498
499         for index in listeIndex:
500             indexTravail=index
501             if indexNoeudOuColler < index:
502                 indexTravail=indexTravail+(len(listeIndex))
503             noeud=noeudJdc.children[indexTravail]
504
505             listeItem.append(noeud.item)
506             listeASupprimer.append(noeud)
507
508         for i in range(len(listeChild)):
509             self.tree.item.suppItem(listeItem[i])
510             listeChild[i].item.update(listeItem[i])
511
512         self.QWParent.noeud_a_editer = []
513
514     #----------------------------------#
515     def handleAjoutEtape(self,nomEtape):
516     #----------------------------------#
517         self.chercheNoeudSelectionne()
518         if len(self.node_selected) == 0 or self.node_selected[0] == self.tree.racine :
519             nodeOuAjouter=self.tree.racine
520             nouveau=nodeOuAjouter.appendChild(nomEtape,pos='first')
521         else :
522             nodeOuAjouter=self.node_selected[0]
523             if nodeOuAjouter != self.tree.racine :
524                 while  nodeOuAjouter.treeParent != self.tree.racine:
525                     nodeOuAjouter=nodeOuAjouter.treeParent
526             nouveau=nodeOuAjouter.appendBrother(nomEtape)
527         try :
528             self.node_selected[0].setSelected(False)
529         except : pass
530         nouveau.setSelected(True)
531         nouveau.affichePanneau()
532
533
534     #---------------------------#
535     def getFileVariable(self) :
536     #---------------------------#
537         titre = tr("Choix d'un fichier XML")
538         texte = tr("Le fichier contient une commande MODEL\n")
539         texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
540         QMessageBox.information( self, titre,tr(texte))
541
542         fichier = QFileDialog.getOpenFileName(self.appliEficas,
543                       tr('Ouvrir Fichier'),
544                       self.appliEficas.maConfiguration.savedir,
545                       tr('Wrapper Files (*.xml);;''All Files (*)'))
546         return  fichier
547
548     #------------#
549     def run(self):
550     #------------#
551         fonction="run"+self.code
552         if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
553
554     #------------#
555     def saveRun(self):
556     #------------#
557         fonction="saveRun"+self.code
558         if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
559
560
561 # ---------------------------------------------
562 # Methodes Non Crees dans ssIHM
563 # ---------------------------------------------
564     #---------------#
565     def runVP(self):
566     #---------------#
567         texte=self.getTextJDC("MAPVp",pourRun=1)
568         print (texte)
569
570     #---------------#
571     def runMAP(self):
572     #---------------#
573
574         if not(self.jdc.isValid()):
575             QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
576             return
577         if len(self.jdc.etapes) != 1 :
578             QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
579             return
580         if self.modified or self.fichier==None  :
581             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
582             texte=self.getTextJDC("MAP")
583             self.writeFile( self.fichierMapInput, txt = texte)
584         else :
585             self.fichierMapInput=self.fichier
586         composant=self.jdc.etapes[0].nom.lower()[0:-5]
587
588
589         # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
590         # then instantiate corresponding class and call getUseSalome() method
591         try:
592             from mapengine.spec import factory
593             mapComponent = factory.new(composant)[0]
594
595             command = "map"
596             if mapComponent.getUseSalome():
597                 command += " -r sappli"
598             textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
599
600             #textePython="ls -l"
601             self._viewTextExecute( textePython,"map_run",".sh")
602             #try:
603             #  commande="rm  "+self.fichierMapInput
604             #   os.system(commande)
605             #except :
606             #   pass
607         except Exception as e:
608             print((traceback.print_exc()))
609
610     #-------------------#
611     def runZCRACKS(self):
612     #-------------------#
613         if not(self.jdc.isValid()):
614             QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
615             return
616         if self.modified or self.fichier==None  :
617         #if 1:
618             self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
619             texte=self.getTextJDC("ZCRACKS",pourRun=1)
620             self.writeFile( self.fichierZcracksInput, txt = texte)
621         else :
622             self.fichierZcracksInput=self.fichier
623         try :
624             #commande ="Zrun -zp "
625             commande="more "
626             textePython=(commande + self.fichierZcracksInput)
627             self._viewTextExecute( textePython,"run_zcracks",".sh")
628         except Exception as e:
629             print((traceback.print_exc()))
630
631     #-------------------#
632     def runCARMELCND(self):
633     #-------------------#
634         #if not(self.jdc.isValid()):
635         #   QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
636         #   return
637         if self.modified or self.fichier==None  :
638             QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
639             return
640         if not hasattr(self,'generator'): texte=self.getTextJDC(self.formatFichierOut)
641         from PrepareRunCarmel import prepareRunCarmel
642         fichierGenerique=os.path.basename(self.fichier).split(".")[0]
643         repMed=os.path.dirname(self.fichier)
644         repExeCarmel=self.generator.get_repExeCarmel()
645         textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
646         nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
647         f=open(nomFichier,'w')
648         f.write(textePython)
649         f.close()
650         commande="xterm -e sh "+nomFichier +"\n"
651         os.system(commande)
652
653     #-------------------#
654     def runCarmelCS(self):
655     #-------------------#
656         try :
657             commande="runSession pilotyacsCS.py"
658             os.system(commande)
659         except Exception as e:
660             print((traceback.print_exc()))
661
662     #-----------------------------------------------------#
663     def determineNomFichier(self,path,extension):
664     #-----------------------------------------------------#
665         if self.appliEficas.code in DictExtensions:
666             chaine1=DictExtensions[self.appliEficas.code]+" (*."+DictExtensions[self.appliEficas.code]+");;"
667             extensions= tr(chaine1+ "All Files (*)")
668         else :
669             extensions= tr("JDC (*.comm);;" "All Files (*)")
670
671         if self.appliEficas.code == "MAP" :
672             extensions = extensions + ";; Run (*.input);;"
673
674         fn = QFileDialog.getSaveFileName( self,
675                tr("sauvegarde"), path,
676                extensions,None,
677                QFileDialog.DontConfirmOverwrite)
678         if fn == None : return (0, None)
679         fn=fn[0]
680         if fn=='': return (0, None)
681
682         ext = QFileInfo(fn).suffix()
683         if ext == '': fn+=extension
684
685         if QFileInfo(fn).exists():
686             msgBox = QMessageBox(self)
687             msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
688             msgBox.setText(tr("Le fichier")+ "  "+str(fn)+ "  " +tr("existe deja"))
689             msgBox.addButton(tr("&Ecraser"),0)
690             msgBox.addButton(tr("&Abandonner"),1)
691             abort=msgBox.exec_()
692             if abort == 1 :  return (0, "")
693         return (1,fn)
694
695     #-----------------#
696     def saveRunMAP(self):
697     #-----------------#
698         extension=".input"
699         if not(self.jdc.isValid()):
700             QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
701                                  tr("Un JdC valide est necessaire pour creer un .input")
702                                   )
703             return
704         try :
705             composant=self.jdc.etapes[0].nom.lower()[0:-5]
706         except :
707             QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
708                                  tr("Choix du composant obligatoire")
709                                   )
710             return
711         if hasattr(self.maConfiguration, "savedir"): path=self.maConfiguration.savedir
712         else : path='C:/'
713
714         monNomFichier=""
715         if self.fichier is not None and self.fichier != "" :
716             maBase=str(QFileInfo(self.fichier).baseName())+".input"
717             monPath=str(QFileInfo(self.fichier).absolutePath())
718             monNomFichier=os.path.join(monPath,maBase)
719         elif hasattr(self,'monNomFichierInput'):
720             monNomFichier=self.monNomFichierInput
721
722
723         monDialog=QFileDialog(self.appliEficas)
724         monDialog.setDirectory (path)
725         monDialog.setWindowTitle ("Save")
726
727         for c in monDialog.children():
728             if isinstance(c,QDialogButtonBox):
729                 for b in c.children():
730                     if isinstance(b,QPushButton):
731                         avant=b.text()
732                         if avant=="&Open": b.setText("Save")
733         mesFiltres= "input Map (*.input);;All Files (*)"
734         monDialog.setNameFilters(mesFiltres)
735         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
736         BOk=monDialog.exec_()
737         if BOk==0: return
738         fn=str(monDialog.selectedFiles()[0])
739         if fn == "" or fn == None : return
740         if not fn.endswith(".input"):
741             fn += ".input"
742         self.monNomFichierInput=fn
743
744         if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
745             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
746             texte=self.getTextJDC("MAP")
747             self.writeFile( self.fichierMapInput, txt = texte)
748
749         cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
750         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
751         (output, err) = p.communicate()
752
753
754     #-----------------#
755     def saveRunPSEN(self):
756     #-----------------#
757         #print ("saveRunPSEN")
758         self.saveFile()
759
760
761
762     #-----------------------------------------#
763     def handleAjoutGroup(self,listeGroup):
764     #-----------------------------------------#
765         try :
766         #if 1:
767             from ajoutGroupe import handleAjoutGroupFiltre
768             #print listeGroup
769             handleAjoutGroupFiltre(self,listeGroup)
770             #print "apres handleAjoutGroupFiltre"
771         except :
772         #else :
773             pass
774
775
776     #-----------------------------------------------------------------#
777     def saveCompleteFile(self, path = None, saveas= 0,formatLigne="beautifie"):
778     #-----------------------------------------------------------------#
779         extension='.casR'
780         fn = self.fichierComplet
781         #saveas=True # Pour forcer le nom
782         self.generator=self.maConfiguration.mesGenerators.plugins[self.formatFichierOut]()
783         if self.fichierComplet is None or saveas:
784             if path is None: path=self.maConfiguration.savedir
785             bOK, fn=self.determineNomFichier(path,extension)
786             if bOK == 0 : return (0, None)
787             if fn == None : return (0, None)
788             if fn== '' : return (0, None)
789
790             ulfile = os.path.abspath(fn)
791             self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
792             fn = QDir.toNativeSeparators(fn)
793
794         self.fichierComplet = os.path.splitext(fn)[0]+extension
795
796         if hasattr(self.generator, "writeComplet"):
797             self.generator.writeComplet(self.fichierComplet,self.jdc,config=self.appliEficas.maConfiguration,appliEficas=self.appliEficas)
798
799         if self.salome : self.appliEficas.addJdcInSalome( self.fichierComplet)
800
801         self.modified = 0
802         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichierComplet))
803         self.appliEficas.setWindowTitle(nouveauTitre)
804         return (1, self.fichierComplet)
805
806     #-----------------------------------------------------------------#
807     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
808     #-----------------------------------------------------------------#
809         """
810         Public slot to save the text to a file.
811
812         @param path directory to save the file in (string or QString)
813         @return tuple of two values (boolean, string) giving a success indicator and
814             the name of the saved file
815         """
816
817         self.modified=1
818         if not self.modified and not saveas:
819             return (0, None)      # do nothing if text wasn't changed
820
821         if self.appliEficas.code in DictExtensions :
822             extension=DictExtensions[self.appliEficas.code]
823         else :
824             extension='.comm'
825
826         newName = None
827         fn = self.fichier
828         if self.fichier is None or saveas:
829             if path is None: path=self.maConfiguration.savedir
830             bOK, fn=self.determineNomFichier(path,extension)
831             if bOK == 0 : return (0, None)
832             if fn == None : return (0, None)
833             if fn== '' : return (0, None)
834
835             ulfile = os.path.abspath(fn)
836             self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
837             fn = QDir.toNativeSeparators(fn)
838             newName = fn
839
840
841         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
842         self.fichier = fn
843         self.modified  = False
844         if self.fileInfo is None or saveas:
845             self.fileInfo = QFileInfo(self.fichier)
846             self.fileInfo.setCaching(0)
847         self.lastModified = self.fileInfo.lastModified()
848         if newName is not None:
849             self.appliEficas.addToRecentList(newName)
850             self.tree.racine.item.getObject().nom=os.path.basename(newName)
851             self.tree.racine.updateNodeLabel()
852
853
854         if  self.jdc.cata.modeleMetier:self.jdc.toXml(self.fichier)
855         if  self.jdc.cata.modeleMetier and self.jdc.isValid():
856             if self.generator != self.XMLgenerator :
857                 self.XMLgenerator.gener(self.jdc)
858                 self.XMLgenerator.writeDefault(fn)
859
860         if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
861         #if hasattr(self.generator, "writeDefault"):
862             self.generator.writeDefault(fn)
863         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
864             msgBox = QMessageBox(None)
865             msgBox.setWindowTitle(tr("Fichier .cas invalide / incomplet"))
866             msgBox.setText(tr("Le fichier .cas est invalide / incomplet"))
867             msgBox.addButton(tr("&Sauvegarder"),1)
868             msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
869             msgBox.addButton(tr("&Annuler"),2)
870             res=msgBox.exec_()
871             if res == 0 :
872                 self.generator.writeDefault(fn)
873                 return (1, self.fichier)
874             if res == 2 : return (0, None)
875             if self.appliEficas.salome : self.appliEficas.close()
876             else : sys.exit(1)
877
878         if self.salome :
879             self.appliEficas.addJdcInSalome( self.fichier)
880         self.modified = 0
881         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
882         self.appliEficas.setWindowTitle(nouveauTitre)
883
884         return (1, self.fichier)
885 #
886
887     #----------------------------------------------#
888     def sauveLigneFile(self):
889     #----------------------------------------------#
890         self.modified=1
891         return self.saveFile(formatLigne="Ligne")
892
893
894     #----------------------------------------------#
895     def saveFileAs(self, path = None,fileName=None):
896     #----------------------------------------------#
897         """
898         Public slot to save a file with a new name.
899
900         @param path directory to save the file in (string or QString)
901         @return tuple of two values (boolean, string) giving a success indicator and
902             the name of the saved file
903         """
904         if fileName != None :
905             self.fichier = fileName
906             return self.saveFile()
907         return self.saveFile(path,1,"beautifie")
908
909
910
911     #---------------------------------------------#
912     def getFile(self,unite=None,fic_origine = ''):
913     #---------------------------------------------#
914     # appele par I_JDC
915         ulfile  = None
916         jdcText = ""
917
918         titre  = ""
919
920         if unite :
921             titre = tr("Choix unite %d ", unite)
922             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
923             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
924             labeltexte = tr('Fichier pour unite ') + repr( unite)
925         else:
926             titre = tr("Choix d'un fichier de poursuite")
927             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
928             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
929
930         QMessageBox.information( self, titre,texte)
931         fn = QFileDialog.getOpenFileName(self.appliEficas,
932                    titre,
933                    self.appliEficas.maConfiguration.savedir)
934
935         # ce retour est impose par le getFile d'I_JDC
936         if fn== '' : return None," "
937         if not fn : return (0, " ")
938         fn=fn[0]
939
940         ulfile = os.path.abspath(fn)
941         self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
942
943         # On utilise le convertisseur defini par formatFichierIn
944         source=self.getSource(ulfile)
945         if source:
946             # On a reussia convertir le fichier self.ulfile
947             jdcText = source
948         else:
949             # Une erreur a ete rencontree
950             jdcText = ''
951         return ulfile, jdcText
952
953     #-----------------------------------#
954     def updateJdc(self, etape,texte):
955     #------------------------------------#
956     # ajoute une etape  de JdC a partir d un texte
957         CONTEXT.setCurrentStep(etape)
958         etape.buildIncludeEtape(texte)
959         if not (etape.text_included_converted) :
960             QMessageBox.information( self,
961                        tr("Impossible d importer le texte"),
962                        etape.text_included_error)
963
964         self.tree.racine.buildChildren()
965
966     #-----------------------------------#
967     def updateJdcEtape(self, itemApres,texte):
968     #------------------------------------#
969     # ajoute une etape  de JdC a partir d un texte
970         monItem=itemApres
971         etape=monItem.item.object
972
973         CONTEXT.setCurrentStep(etape)
974         try :
975             ok=etape.buildIncludeEtape(texte)
976         except :
977             ok=0
978         if not ok :
979             QMessageBox.information( self,
980                        tr("Import texte"),
981                        tr("Impossible d importer le texte"))
982         self.tree.racine.buildChildren()
983         return ok
984
985     #-------------------------------------------#
986     def updateJdcAfterEtape(self, etape,texte):
987     #--------------------------------------------#
988     # ajoute une etape  de JdC a partir d un texte
989         CONTEXT.setCurrentStep(etape)
990         try :
991             ok=etape.buildIncludeEtape(texte,doitEtreValide=0)
992         except :
993             ok=0
994         if not ok :
995             QMessageBox.information( self,
996                        tr("Import texte"),
997                        tr("Impossible d importer le texte"))
998         self.tree.racine.buildChildren()
999         return ok
1000
1001
1002     #-------------------------------------#
1003     def deleteEtape(self,etape):
1004     #-------------------------------------#
1005     # dans le JDC
1006         self.jdc.suppEntite(etape)
1007
1008
1009     #-----------------------------------------
1010     def initSplitterSizes(self, nbWidget=3):
1011     #-----------------------------------------
1012         #print ("je passe ds initSplitterSizes", nbWidget)
1013
1014         if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes3=[1,1550,300]
1015         #elif self.code in [ 'MAP']            : self.splitterSizes3=[700,300]
1016         else                                  : self.splitterSizes3=[150,1000,300]
1017
1018         if   self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes2=[5,1500]
1019         else                                  : self.splitterSizes2=[300,1000]
1020
1021
1022     #-----------------------------------------
1023     def restoreSplitterSizes(self,nbWidget=3):
1024     #----------------------------------------
1025
1026         #traceback.print_stack()
1027         #print ("je passe ds restoreSplitterSizes")
1028         if not(hasattr(self,'splitter')) : return
1029         if nbWidget==2  : newSizes=self.splitterSizes2
1030         if nbWidget==3  : newSizes=self.splitterSizes3
1031         #self.inhibeSplitter = 1
1032         #print (newSizes)
1033         self.splitter.setSizes(newSizes)
1034         #self.inhibeSplitter = 0
1035         QApplication.processEvents()
1036         # seule la fentetre du milieu est necessaire
1037         self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1038
1039     #-----------------------------------------
1040     def saveSplitterSizes(self,event):
1041     #-----------------------------------------
1042         #print ("je passe ds saveSplitterSizes")
1043         if self.inhibeSplitter : return
1044         if self.widgetOptionnel == None  : self.splitterSizes2 = self.splitter.sizes()[0:2]
1045         else                             : self.splitterSizes3 = self.splitter.sizes()[0:3]
1046
1047     #------------------------
1048     def fermeOptionnel(self):
1049     #------------------------
1050         if self.widgetOptionnel == None : return
1051
1052         self.inhibeSplitter=1
1053         self.widgetOptionnel.setParent(None)
1054         self.widgetOptionnel.close()
1055         self.widgetOptionnel.deleteLater()
1056         self.widgetOptionnel=None
1057         self.inhibeSplitter=0
1058         self.restoreSplitterSizes(2)
1059
1060     #------------------------
1061     def ajoutOptionnel(self):
1062     #------------------------
1063         #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1064         #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1065         #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1066
1067         self.restoreSplitterSizes(3)
1068
1069
1070     #------------------------
1071     def fermeArbre(self):
1072     #------------------------
1073         #print (self.widgetTree)
1074         self.oldWidgetTree=self.widgetTree
1075         self.widgetTree.hide()
1076         #self.widgetTree=None
1077
1078     #------------------------
1079     def ouvreArbre(self):
1080     #------------------------
1081         #print ('je passe la')
1082         #print (self.widgetTree)
1083         #self.widgetTree=self.oldWidgetTree
1084         self.widgetTree.show()
1085         #self.restoreSplitterSizes(3)
1086
1087     #-----------------------
1088     def getEtapeCourante(self) :
1089     #-----------------------
1090         if len(self.tree.selectedItems()) != 1 : return None
1091         etape=self.tree.selectedItems()[0].item.object.getEtape()
1092         return etape
1093     #-----------------------------
1094     def getTreeIndex(self,noeud):
1095     #----------------------------
1096         indexNoeud=-1
1097         if noeud in noeud.treeParent.children :
1098             indexNoeud=noeud.treeParent.children.index(noeud)
1099         else :
1100             if hasattr(noeud,'vraiParent') :
1101                 noeudVrai = noeud
1102                 noeudVraiParent = noeud.vraiParent
1103                 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1104                     noeudVrai = noeudVraiParent
1105                     noeudVraiParent = noeudVraiParent.vraiParent
1106                     pass
1107                 if noeudVraiParent == noeud.treeParent :
1108                     indexNoeud=noeud.treeParent.children.index(noeudVrai)
1109                     pass
1110                 pass
1111             pass
1112         return indexNoeud
1113
1114     #-------------------#  Pour execution avec output et error dans le bash
1115     def runPSEN(self):
1116     #-------------------#
1117
1118         #if self.modified or self.fichier==None  : self.saveFile()
1119         self.saveFile()
1120
1121         #lancement avec le .bat
1122         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
1123         WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
1124         import subprocess
1125         p = subprocess.Popen(['python',WrapperFilePath])
1126         (out,err)=p.communicate()
1127         print (out)
1128         print (err)
1129
1130     #-------------------#  Pour execution avec output et error dans le bash
1131     def runPSEN_N1(self):
1132     #-------------------#
1133
1134
1135         self.saveFile()
1136         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1137         sys.path.append(path1)
1138
1139         if not(self.jdc.isValid()):
1140             QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
1141         if 'dicoImbrique' in generator.plugins:
1142             self.generator=generator.plugins['dicoImbrique']()
1143             jdc_formate=self.generator.gener(self.jdc)
1144             dico=self.generator.Dico
1145
1146             ###to delete
1147             #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1148             fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
1149             f = open( str(fileDico), 'w')
1150             f.write("Dico =" + str(dico) )
1151             f.close()
1152             ###
1153
1154
1155         print ('in runPSEN_N1', dico)
1156         print (dico)
1157         from Run import run
1158         run(dico)
1159         #res,txt_exception=run(dico)
1160         #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
1161         #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
1162
1163     #-------------------#  Pour execution avec output et error dans le bash
1164     def process_N1(self):
1165     #-------------------#
1166
1167         path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
1168         sys.path.append(path1)
1169
1170
1171         if 'dicoImbrique' in generator.plugins:
1172             self.generator=generator.plugins['dicoImbrique']()
1173             jdc_formate=self.generator.gener(self.jdc)
1174             dico=self.getDico() #generator.Dico
1175
1176
1177             for k in dico['CONTINGENCY_PROCESSING']:
1178             #print (k)
1179                 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
1180                     newK=k.replace('__',' ')
1181                     l="'"+str(newK)+"'"
1182                     dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
1183                     del dico['CONTINGENCY_PROCESSING'][k]
1184
1185             ###to delete
1186             fileDico =  os.path.join(path1, 'dicoN1_process.py')
1187             f = open( str(fileDico), 'w')
1188             f.write("Dico =" + str(dico) )
1189             f.close()
1190             ###
1191             return dico
1192
1193         #return self.getDico()
1194
1195     #-------------------#  Pour execution avec output et error dans le bash
1196     def process_VP(self):
1197     #-------------------#
1198         if 'dicoImbrique' in generator.plugins:
1199             self.generator=generator.plugins['dicoImbrique']()
1200             jdc_formate=self.generator.gener(self.jdc)
1201             dico=self.getDico() #generator.Dico
1202             return dico
1203
1204 if __name__ == "__main__":
1205     print ('in main')