]> SALOME platform Git repositories - tools/eficas.git/blob - InterfaceQT4/editor.py
Salome HOME
sauve du 20/12
[tools/eficas.git] / InterfaceQT4 / editor.py
1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013   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 import types,sys,os, re
21 import  subprocess
22 import traceback
23
24 from determine import monEnvQT5
25 if monEnvQT5:
26     from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
27     from PyQt5.QtGui import QPalette
28     from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
29 else :
30     from PyQt4.QtGui  import *
31     from PyQt4.QtCore import *
32 import time
33 import pdb
34 from datetime import date
35 from Extensions.i18n import tr
36
37
38 # Modules Eficas
39
40 import convert, generator
41 from Editeur        import session
42 from Editeur        import comploader
43 from Editeur        import Objecttreeitem
44 from desBaseWidget  import Ui_baseWidget
45 from monViewTexte   import ViewText 
46 from monWidgetCreeParam import MonWidgetCreeParam 
47 import browser
48 import readercata
49
50 DictExtensions= {"MAP" : ".map"}
51
52     
53
54
55 class JDCEditor(Ui_baseWidget,QWidget):
56 # ----------------------------------------- #
57     """
58        Editeur de jdc
59     """
60
61     def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
62     #----------------------------------------------------------------------------------------------------------#
63
64         QWidget.__init__(self,None)
65         self.i=0
66         self.setupUi(self)
67         self.inhibeSplitter=0
68         self.widgetOptionnel=None
69         self.fenetreCentraleAffichee=None
70         self.dejaDansPlieTout=False
71         self.afficheCommandesPliees = True
72         self.listeDesListesOuvertes=set()
73         self.appliEficas = appli
74         self.appli       = appli  #---- attendu par IHM
75         self.vm          = vm
76         self.fichier     = fichier
77         self.jdc         = jdc
78         self.first       = True
79         self.QWParent    = QWParent
80         self.couleur     = Qt.black
81          
82         if appli != None :
83            self.salome =  self.appliEficas.salome
84         else :
85            self.salome=0
86            print "dans JDC pas d appli ????????"
87
88         # ces attributs sont mis a jour par definitCode appelee par newEditor
89         self.code   = self.appliEficas.CONFIGURATION.code
90
91         #self.afficheListesPliees=False
92         self.afficheListesPliees=True
93         if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
94         if self.code == 'PSEN_N1' : self.afficheListesPliees = False
95
96         self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
97         self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
98         self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
99         self.affiche=self.appliEficas.CONFIGURATION.affiche
100         #self.taille = self.appliEficas.taille
101
102         #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
103         if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
104         if self.code in ['MAP',]:
105            self.widgetTree.close()
106            self.widgetTree=None
107
108       
109
110         self.version_code = session.d_env.cata
111
112         if not hasattr ( self.appliEficas, 'readercata') or  self.appliEficas.multi==True:
113            self.readercata  = readercata.READERCATA( self, self.appliEficas )
114            self.appliEficas.readercata=self.readercata
115            self.appliEficas.code=self.code
116         else :
117            self.readercata=self.appliEficas.readercata
118         if self.readercata.fic_cata == None : return    #Sortie Salome
119         self.titre=self.readercata.titre
120         self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
121         self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
122
123         self.format =  self.appliEficas.format_fichier
124
125         self.dict_reels={}
126         self.liste_simp_reel=[]
127         self.ihm="QT"
128         self.dicoNouveauxMC={}
129
130         nameConf='configuration_'+self.code
131         configuration=__import__(nameConf)
132         self.CONFIGURATION = self.appliEficas.CONFIGURATION
133         self.CONFIGStyle =   self.appliEficas.CONFIGStyle
134
135         try:
136           self.CONFIGURATION.generator_module
137           _module = __import__(self.CONFIGURATION.generator_module)
138           info = _module.entryPoint()
139           generator.plugins.addEntryPoint(info)
140         except:
141           pass
142
143         try:
144           self.CONFIGURATION.convert_module
145           #print self.CONFIGURATION.convert_module
146           _module = __import__(self.CONFIGURATION.convert_module)
147           info = _module.entryPoint()
148           convert.plugins.addEntryPoint(info)
149         except :
150           pass
151
152         self.sb = None
153         if hasattr(self.appliEficas,"statusBar"):
154            self.sb = self.appliEficas.statusBar()
155
156         self.fileInfo       = None
157         self.lastModified   = 0
158
159         self.modified   = False
160         self.isReadOnly = False
161         self.node_selected = []
162         self.deplier = True
163         self.message=''
164         if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
165         else :  self.afficheApresInsert=False
166         if self.code in ['TELEMAC',] : self.enteteQTree='premier'
167         else : self.enteteQTree='complet'
168         if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
169         else : self.affichePlie=False
170
171         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
172
173         #------- construction du jdc --------------
174
175         jdc_item = None
176
177         self.nouveau=0
178         if self.fichier is not None:        #  fichier jdc fourni
179             self.fileInfo = QFileInfo(self.fichier)
180             self.fileInfo.setCaching(0)
181             if jdc==None :
182               # try :
183               if 1:
184                    self.jdc = self.readFile(self.fichier)
185                #except :
186               else :
187                    print "mauvaise lecture"
188             else :
189                self.jdc=jdc
190             if self.jdc is not None and units is not None:
191                self.jdc.recorded_units=units
192                self.jdc.old_recorded_units=units
193         else:
194             if not self.jdc:                   #  nouveau jdc
195                 if not include :
196                    self.jdc = self._newJDC(units=units)
197                 else :
198                    self.jdc = self._newJDCInclude(units=units)
199                 self.nouveau=1
200
201         if self.jdc:
202             self.jdc.appli = self # a resorber
203             self.jdc.editor = self 
204             self.jdc.lang    = self.appli.langue
205             self.jdc.aReafficher=False
206             txt_exception  = None
207             if not jdc:
208                 self.jdc.analyse()
209                 txt_exception = self.jdc.cr.get_mess_exception()
210             if txt_exception:
211                 self.jdc = None
212                 QApplication.restoreOverrideCursor()
213                 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
214                 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
215             else:
216                 comploader.charger_composants("QT")
217                 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
218                 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
219                     self.viewJdcRapport()
220  
221
222
223         if jdc_item and self.appliEficas.ssIhm==False:
224             self.tree = browser.JDCTree( jdc_item,  self )
225         self.appliEficas.construitMenu()
226
227         
228         #############
229         self.adjustSize()
230
231
232     #-------------------#  Pour execution avec output et error dans le bash
233     def runPSEN(self):
234     #-------------------#
235       #if self.modified or self.fichier==None  : self.saveFile()
236       self.saveFile()
237         
238       #lancement avec le .bat
239       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
240       WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py') 
241       import subprocess
242       p = subprocess.Popen(['python',WrapperFilePath])
243       (out,err)=p.communicate()        
244       print out
245       print err
246
247     #-------------------#  Pour execution avec output et error dans le bash
248     def runPSEN_N1(self):
249     #-------------------#
250       
251
252       self.saveFile()
253       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
254       sys.path.append(path1)
255
256       if not(self.jdc.isvalid()):
257          QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
258       if generator.plugins.has_key('dicoImbrique'):
259          self.generator=generator.plugins['dicoImbrique']()
260          jdc_formate=self.generator.gener(self.jdc)
261          dico=self.generator.Dico 
262          
263          ###to delete
264          #fileDico =  r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
265          fileDico =  os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
266          f = open( str(fileDico), 'wb')
267          f.write("Dico =" + str(dico) )
268          f.close()
269          ###
270          
271       
272       print 'in runPSEN_N1', dico
273       from Run import run 
274       run(dico)
275       #res,txt_exception=run(dico)
276       #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
277       #else  : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
278        
279     #-------------------#  Pour execution avec output et error dans le bash
280     def process_N1(self):
281     #-------------------#
282
283       path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
284       sys.path.append(path1)
285
286
287       if generator.plugins.has_key('dicoImbrique'):
288          self.generator=generator.plugins['dicoImbrique']()
289          jdc_formate=self.generator.gener(self.jdc)
290          dico=self.get_Dico() #generator.Dico
291
292
293          for k in dico['CONTINGENCY_PROCESSING'].keys():
294              print k
295
296              if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
297                 newK=k.replace('___',' ')
298                 l="'"+str(newK)+"'"
299                 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
300                 del dico['CONTINGENCY_PROCESSING'][k]
301
302          ###to delete
303          fileDico =  os.path.join(path1, 'dicoN1_process.py')
304          f = open( str(fileDico), 'wb')
305          f.write("Dico =" + str(dico) )
306          f.close()
307          ###
308          return dico
309
310         #return self.get_Dico()
311
312
313
314     #--------------------------------#
315     def _newJDC( self ,units = None):
316     #--------------------------------#
317         """
318         Initialise un nouveau JDC vierge
319         """
320         self.modified=1
321         CONTEXT.unset_current_step()
322
323         texte=""
324         if self.code == "CARMELCND" : texte=self._newJDCCND()
325         if self.code == "ZCRACKS" : texte=self._newZCRACKS()
326         if self.code == "TELEMAC" : texte=self._newTELEMAC()
327         if self.code == "PSEN" : texte = self._newPSEN()
328         if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
329         #if self.code == "CF" : texte = self._new_CF()
330         #   texte=self.newTexteCND
331        
332         jdc=self.readercata.cata[0].JdC( procedure =texte,
333                                          appli=self,
334                                          cata=self.readercata.cata,
335                                          cata_ord_dico=self.readercata.cata_ordonne_dico,
336                                          rep_mat=self.CONFIGURATION.rep_mat
337                                         )
338         jdc.lang    = self.appli.langue
339         if units is not None:
340            jdc.recorded_units=units
341            jdc.old_recorded_units=units
342         ## PNPN est ce que la ligne suivante est bien utile ?
343         if texte == "" :jdc.analyse()
344         return jdc
345
346     #--------------------------------#
347     def _newJDCInclude( self ,units = None):
348     #--------------------------------#
349         """
350         Initialise un nouveau JDC vierge
351         """
352         import Extensions.jdc_include
353         JdC_aux=Extensions.jdc_include.JdC_include
354         CONTEXT.unset_current_step()
355
356         jaux=self.readercata.cata[0].JdC( procedure="",
357                                appli=self,
358                                cata=self.readercata.cata,
359                                cata_ord_dico=self.readercata.cata_ordonne_dico,
360                                rep_mat=self.CONFIGURATION.rep_mat,
361                               )
362         jaux.analyse()
363
364         J=JdC_aux( procedure="",
365                    appli=self,
366                    cata=self.readercata.cata,
367                    cata_ord_dico=self.readercata.cata_ordonne_dico,
368                    jdc_pere=jaux,
369                    rep_mat=self.CONFIGURATION.rep_mat,
370                    )
371         J.analyse()
372         if units is not None:
373            J.recorded_units=units
374            J.old_recorded_units=units
375         return J
376
377
378     #-------------------------------#
379     def readFile(self, fn):
380     #--------------------------------#
381         """
382         Public slot to read the text from a file.
383         @param fn filename to read from (string or QString)
384         """
385         fn = unicode(fn)
386
387         # ------------------------------------------------------------------------------------
388         #                         charge le JDC
389         # ------------------------------------------------------------------------------------
390
391         jdcName=os.path.basename(fn)
392         # Il faut convertir le contenu du fichier en fonction du format
393         if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
394              # Le convertisseur existe on l'utilise
395              #appli = self
396              p=convert.plugins[self.appliEficas.format_fichier_in]()
397              p.readfile(fn)
398              if p.text=="" : self.nouveau=1
399              pareil,texteNew=self.verifieCHECKSUM(p.text)
400              #if texteNew == ""
401              if pareil == False and (self.appliEficas.ssIhm == False) :
402                 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
403              p.text=texteNew
404              memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
405              if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
406              p.text=texteNew
407              text=p.convert('exec',self.appliEficas)
408              if not p.cr.estvide():
409                 self.affiche_infos("Erreur a la conversion",Qt.red)
410         else :
411             self.affiche_infos("Type de fichier non reconnu",Qt.red)
412             if self.appliEficas.ssIhm == False:
413                     QMessageBox.critical( self, tr("Type de fichier non reconnu"),
414                     tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
415             return None
416
417         CONTEXT.unset_current_step()
418         jdc=self.readercata.cata[0].JdC(procedure=text,
419                                     appli=self,
420                                     cata=self.readercata.cata,
421                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
422                                     nom=jdcName,
423                                     rep_mat=self.CONFIGURATION.rep_mat
424                                    )
425         # ----------------------------------------------------
426         #      charge le JDC fin
427         # ----------------------------------------------------
428         self.modified = False
429
430 #        qApp.restoreOverrideCursor()
431         if self.fileInfo!= None :
432            self.lastModified = self.fileInfo.lastModified()
433         else :
434            self.lastModified = 1
435         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
436         self.appliEficas.setWindowTitle(nouveauTitre)
437         return jdc
438
439
440     #-----------------------#
441     def get_source(self,file):
442     #-----------------------#
443
444         # Il faut convertir le contenu du fichier en fonction du format
445         if convert.plugins.has_key(self.format):
446             # Le convertisseur existe on l'utilise
447             p=convert.plugins[self.format]()
448             p.readfile(file)
449             text=p.convert('execnoparseur')
450             if not p.cr.estvide():
451                 self.affiche_infos("Erreur a la conversion",Qt.red)
452             return text
453         else:
454             # Il n'existe pas c'est une erreur
455             self.affiche_infos("Type de fichier non reconnu",Qt.red)
456             QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
457             return None
458
459     #-----------------------------------------------------------------------#
460     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
461     #--------------------------------------------------------------------#
462         w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
463         w.show()
464     #
465
466     #----------------------------------------------#
467     def __generateTempFilename(self, prefix, suffix):
468     #----------------------------------------------#
469         import tempfile
470         (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
471         os.close(fd)
472         return filename
473     #
474
475
476     #----------------------------------------------#
477     def _viewTextExecute(self, txt, prefix, suffix):
478     #----------------------------------------------#
479         self.w = ViewText( self.QWParent )
480         self.w.setWindowTitle( "execution" )
481         self.monExe=QProcess(self.w)
482         pid=self.monExe.pid()
483         nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
484         f=open(nomFichier,'w')
485         f.write(txt)
486         f.close()
487         if monEnvQT5 :
488            self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
489            self.monExe.readyReadStandardError.connect( self.readFromStdErr)
490         else :
491            self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
492            self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
493         exe='sh ' + nomFichier
494         self.monExe.start(exe)
495         self.monExe.closeWriteChannel()
496         self.w.exec_()
497         try:
498           commande="rm  "+ nomFichier
499           os.system(commande)
500         except :
501           pass
502
503     def readFromStdErr(self):
504         a=self.monExe.readAllStandardError()
505         self.w.view.append(str(a.data(),len(a)))
506
507     def readFromStdErr(self) :
508         a=self.monExe.readAllStandardOutput()
509         self.w.view.append(str(a.data(),len(a)))
510
511     def readFromStdErrQT4(self):
512         a=self.monExe.readAllStandardError()
513         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
514
515     def readFromStdOutQT4(self) :
516         a=self.monExe.readAllStandardOutput()
517         self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
518         
519
520
521     #-----------------------#
522     def gestionParam(self):
523     #-----------------------#
524         w = MonWidgetCreeParam( self)
525         w.show()
526
527     #-----------------------#
528     def viewJdcSource(self):
529     #-----------------------#
530         f=open(self.fichier,'r')
531         texteSource=f.read()
532         f.close()
533         self._viewText(texteSource, "JDC_SOURCE")
534
535     #-----------------------#
536     def viewJdcPy(self):
537     #-----------------------#
538         strSource = str( self.get_text_JDC(self.format) )
539         self._viewText(strSource, "JDC_RESULTAT")
540
541     #-----------------------#
542     def viewJdcRapport(self):
543     #-----------------------#
544         strRapport = unicode( self.jdc.report() )
545         # on ajoute les regles
546         
547         self._viewText(strRapport, "JDC_RAPPORT")
548
549     #-----------------------#
550     def viewJdcRegles(self):
551     #-----------------------#
552         if self.tree :self.tree.AppelleBuildLBRegles()
553
554
555     #----------------#
556     def closeIt(self):
557     #----------------#
558         """
559         Public method called by the viewmanager to finally get rid of us.
560         """
561         if self.jdc:
562             self.jdc.supprime()
563         self.close()
564
565     #----------------------------------------------#
566     def affiche_infos(self,message,couleur=Qt.black):
567     #----------------------------------------------#
568         if self.sb:
569            mapalette=self.sb.palette()
570            mapalette.setColor( QPalette.WindowText, couleur )
571            self.sb.setPalette( mapalette );
572            self.sb.showMessage(message,4000)
573            self.couleur=couleur
574
575     #------------------------------#
576     def affiche_alerte(self,titre,message):
577     #------------------------------#
578     # appele par I_MACRO_ETAPE
579         QMessageBox.information( self, titre, message)
580
581     #-----------------------------------#
582     def affiche_commentaire(self,message):
583     #-----------------------------------#
584         self.labelCommentaire.setText(message)
585         QTimer.singleShot(6000, self.rendInvisible)
586
587     #----------------------#
588     def rendInvisible(self):
589     #----------------------#
590         self.labelCommentaire.setText("")
591
592     #-------------------#
593     def init_modif(self):
594     #-------------------#
595       """
596           Met l'attribut modified a 'o' : utilise par Eficas pour savoir
597           si un JDC doit etre sauvegarde avant destruction ou non
598       """
599       self.modified = True
600
601     #---------------------------------------#
602     def chercheNoeudSelectionne(self,copie=1):
603     #---------------------------------------#
604       """
605         appele par Cut et Copy pour positionner self.node_selected
606       """
607       self.node_selected=[]
608       if len(self.tree.selectedItems()) == 0 : return
609       self.node_selected=self.tree.selectedItems()
610
611
612     #---------------------#
613     def handleSupprimer(self):
614     #---------------------#
615       self.chercheNoeudSelectionne()
616       if len(self.node_selected) == 0 : return
617       self.QWParent.noeud_a_editer = []
618       if self.node_selected[0]==self.tree.racine: return
619       if len(self.node_selected) == 1 : self.node_selected[0].delete()
620       else : self.node_selected[0].deleteMultiple(self.node_selected)
621
622     #---------------------#
623     def handleRechercher(self):
624     #---------------------#
625       from monRecherche import DRecherche
626       monRechercheDialg=DRecherche(parent=self,fl=0)
627       monRechercheDialg.show()
628
629
630     #--------------------------------#
631     def handleRechercherDsCatalogue(self):
632     #-----------------------------#
633       from monRechercheCatalogue import DRechercheCatalogue
634       monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
635       monRechercheDialg.show()
636
637     #---------------------#
638     def handleDeplier(self):
639     #---------------------#
640        if self.tree == None : return
641        #self.tree.collapseAll()
642        if self.deplier :
643           #print "je plie"
644           self.tree.expandItem(self.tree.topLevelItem(0))
645           self.deplier = False
646           if self.fenetreCentraleAffichee != None  :
647              if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
648                  self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
649        else:
650           #print "je deplie"
651           self.tree.expandItem(self.tree.topLevelItem(0))
652           self.deplier = True
653           if self.fenetreCentraleAffichee != None  :
654              if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
655                  self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
656
657     #---------------------#
658     def handleEditCut(self):
659     #---------------------#
660       """
661       Stocke dans Eficas.noeud_a_editer le noeud a couper
662       """
663       #print "handleEditCut"
664       self.chercheNoeudSelectionne()
665       self.QWParent.edit="couper"
666       self.QWParent.noeud_a_editer = self.node_selected
667
668     #-----------------------#
669     def handleEditCopy(self):
670     #-----------------------#
671       """
672       Stocke dans Eficas.noeud_a_editer le noeud a copier
673       """
674       self.chercheNoeudSelectionne()
675       if len(self.node_selected) == 0 : return
676       if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
677       else :  self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
678       self.QWParent.edit="copier"
679       self.QWParent.noeud_a_editer = self.node_selected
680
681     #------------------------#
682     def handleEditPaste(self):
683     #------------------------#
684       """
685       Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
686       Ne permet que la copie d'objets de type Commande ou MCF
687       """
688       self.chercheNoeudSelectionne()
689       if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
690           QMessageBox.information( self,
691                       tr("Copie impossible"),
692                       tr("Veuillez selectionner un objet a copier"))
693           return
694       if len(self.node_selected) != 1 :
695           QMessageBox.information( self,
696                       tr("Copie impossible"),
697                       tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
698           return
699
700       if len(self.QWParent.noeud_a_editer)!=1:
701          self.handleEditPasteMultiple()
702          return
703
704       noeudOuColler=self.node_selected[0]
705       pos='after'
706       if noeudOuColler == self.tree.racine:
707          indexNoeudOuColler=0
708          pos='before'
709       else :
710          indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
711          indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
712
713       try :
714        noeudACopier=self.QWParent.noeud_a_editer[0]
715        indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
716        indexNoeudACopier=self.getTreeIndex(noeudACopier)
717       except :
718        QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
719        return
720
721       if (self.QWParent.edit != "couper"):
722         try:
723            if noeudOuColler == self.tree.racine :
724                child=noeudOuColler.doPastePremier(noeudACopier)
725            else :
726                child=noeudACopier.doPaste(noeudOuColler,pos)
727            if child==None or child==0:
728                QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
729                self.message = ''
730                self.affiche_infos("Copie refusee",Qt.red)
731            if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
732                try :
733                  nom=noeudACopier.item.sd.nom
734                  child.item.nomme_sd(nom)
735                except :
736                  pass
737            return
738            self.init_modif()
739            child.select()
740         except  :
741            traceback.print_exc()
742            QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
743            self.message = ''
744            self.affiche_infos("Copie refusee",Qt.red)
745            return
746
747       # il faut declarer le JDCDisplay_courant modifie
748       # suppression eventuelle du noeud selectionne
749       # si possible on renomme l objet comme le noeud couper
750
751       if (self.QWParent.edit == "couper"):
752          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
753            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
754
755          #if 1:
756          try :
757            # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
758             indexNoeudACopier=self.getTreeIndex(noeudACopier)
759             noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
760             noeudACopier.treeParent.build_children()
761
762          #else:
763          except:
764             pass
765          self.QWParent.noeud_a_editer=[]
766
767       # on rend la copie a nouveau possible en liberant le flag edit
768       self.QWParent.edit="copier"
769       noeudACopier.select()
770
771     #----------------------------------#
772     def handleDeplaceMultiple(self):
773     #----------------------------------#
774        pass
775
776     #----------------------------------#
777     def handleEditPasteMultiple(self):
778     #----------------------------------#
779
780     # On ne garde que les niveaux "Etape"
781     # On insere dans l'ordre du JDC
782      listeNoeudsACouper=[]
783      listeIndex=[]
784      listeChild=[]
785      listeItem=[]
786      from InterfaceQT4 import compojdc
787      noeudOuColler=self.node_selected[0]
788      if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
789         QMessageBox.information( self,
790                   tr("Copie impossible a cet endroit",),
791                   tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
792         return
793      indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
794
795      for noeud in self.QWParent.noeud_a_editer :
796         if not (isinstance(noeud.treeParent, compojdc.Node)): continue
797         indexInTree=noeud.treeParent.children.index(noeud)
798         indice = 0
799         for index in listeIndex:
800             if index < indexInTree : indice = indice +1
801         listeIndex.insert(indice, indexInTree)
802         listeNoeudsACouper.insert(indice, noeud)
803
804      noeudJdc=noeudOuColler.treeParent
805      dejaCrees=0
806      # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
807      listeIndex.reverse()
808      for index in listeIndex:
809          indexTravail=index
810          if indexNoeudOuColler < index:
811             indexTravail=indexTravail+dejaCrees
812          noeudOuColler=noeudJdc.children[indexNoeudOuColler]
813          noeud=noeudJdc.children[indexTravail]
814          child=noeud.doPaste(noeudOuColler)
815          listeChild.append(child)
816          dejaCrees=dejaCrees+1
817
818      self.QWParent.noeud_a_editer = []
819      for i in range(len(listeIndex)):
820         noeud=noeudJdc.children[indexNoeudOuColler+1+i]
821         self.QWParent.noeud_a_editer.append(noeud)
822
823      listeASupprimer=[]
824      if self.QWParent.edit !="couper" : return
825
826      for index in listeIndex:
827          indexTravail=index
828          if indexNoeudOuColler < index:
829             indexTravail=indexTravail+(len(listeIndex))
830          noeud=noeudJdc.children[indexTravail]
831
832          listeItem.append(noeud.item)
833          listeASupprimer.append(noeud)
834
835      for i in range(len(listeChild)):
836          self.tree.item.suppitem(listeItem[i])
837          listeChild[i].item.update(listeItem[i])
838
839      self.QWParent.noeud_a_editer = []
840
841
842     #---------------------#
843     def getFileName(self):
844     #---------------------#
845       return self.fichier
846
847     #---------------------------#
848     def get_file_variable(self) :
849     #---------------------------#
850      titre = tr("Choix d'un fichier XML")
851      texte = tr("Le fichier contient une commande MODEL\n")
852      texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
853      QMessageBox.information( self, titre,tr(texte))
854
855      fichier = QFileDialog.getOpenFileName(self.appliEficas,
856                    tr('Ouvrir Fichier'),
857                    self.appliEficas.CONFIGURATION.savedir,
858                    tr('Wrapper Files (*.xml);;''All Files (*)'))
859      return  fichier
860
861     #--------------------------------------------------#
862     def writeFile(self, fn, txt = None,formatLigne="beautifie"):
863     #--------------------------------------------------#
864         """
865         Public slot to write the text to a file.
866
867         @param fn filename to write to string
868         @return flag indicating success
869         """
870
871         fn = unicode(fn)
872        
873         if txt == None :
874             txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
875             eol = '\n'
876             if len(txt) >= len(eol):
877                if txt[-len(eol):] != eol:
878                   txt += eol
879             else:
880                 txt += eol
881             txt=self.ajoutVersionCataDsJDC(txt)
882             checksum=self.get_checksum(txt)
883             txt=txt+checksum
884         try:
885             f = open(fn, 'wb')
886             f.write(txt)
887             f.close()
888             return 1
889         except IOError, why:
890             if (self.appliEficas.ssIhm == False):
891                 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
892                 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
893             else :
894                 print why
895             return 0
896
897     #-----------------------------------------------------------#
898     def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
899     #-----------------------------------------------------------#
900       if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
901       if generator.plugins.has_key(format):
902          
903          # Le generateur existe on l'utilise
904          self.generator=generator.plugins[format]()
905          try :
906             jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
907             if pourRun : jdc_formate=self.generator.textePourRun
908          except ValueError,e:
909             QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
910          if not self.generator.cr.estvide():
911             self.affiche_infos(tr("Erreur a la generation"),Qt.red)
912             QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
913             return ""
914          else:
915             return jdc_formate
916       else:
917          # Il n'existe pas c'est une erreur
918          self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
919          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
920          return ""
921
922     #----------------------#
923     def get_Dico(self):
924     #---------------------#
925       if generator.plugins.has_key('dicoImbrique'):
926          self.generator=generator.plugins['dicoImbrique']()
927          jdc_formate=self.generator.gener(self.jdc)
928          dico=self.generator.Dico 
929          return dico
930       else : 
931          self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
932          QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
933          return ""
934
935
936     #------------#
937     def run(self):
938     #------------#
939       fonction="run"+self.code
940       #print fonction
941       if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
942
943     #------------#
944     def saveRun(self):
945     #------------#
946       fonction="saveRun"+self.code
947       if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
948
949     #---------------#
950     def runMAP(self):
951     #---------------#
952
953       if not(self.jdc.isvalid()):
954          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
955          return
956       if len(self.jdc.etapes) != 1 :
957          QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
958          return
959       if self.modified or self.fichier==None  :
960          self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
961          texte=self.get_text_JDC("MAP")
962          self.writeFile( self.fichierMapInput, txt = texte)
963       else :
964          self.fichierMapInput=self.fichier
965       composant=self.jdc.etapes[0].nom.lower()[0:-5]
966
967
968       # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
969       # then instantiate corresponding class and call getUseSalome() method
970       try:
971           from mapengine.spec import factory
972           mapComponent = factory.new(composant)[0]
973
974           command = "map"
975           if mapComponent.getUseSalome():
976               command += " -r sappli"
977           textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
978
979           #textePython="ls -l"
980           self._viewTextExecute( textePython,"map_run",".sh")
981           #try:
982           #  commande="rm  "+self.fichierMapInput
983           #   os.system(commande)
984           #except :
985           #   pass
986       except Exception, e:
987           print traceback.print_exc()
988
989     #-------------------#
990     def runZCRACKS(self):
991     #-------------------#
992       if not(self.jdc.isvalid()):
993          QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
994          return
995       if self.modified or self.fichier==None  :
996       #if 1:
997          self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
998          texte=self.get_text_JDC("ZCRACKS",pourRun=1)
999          self.writeFile( self.fichierZcracksInput, txt = texte)
1000       else :
1001          self.fichierZcracksInput=self.fichier
1002       try :
1003           #commande ="Zrun -zp "
1004           commande="more "
1005           textePython=(commande + self.fichierZcracksInput)
1006           self._viewTextExecute( textePython,"run_zcracks",".sh")
1007       except Exception, e:
1008           print traceback.print_exc()
1009
1010     #-------------------#
1011     def runCARMELCND(self):
1012     #-------------------#
1013       #if not(self.jdc.isvalid()):
1014       #   QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1015       #   return
1016       if self.modified or self.fichier==None  :
1017          QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1018          return
1019       if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1020       from PrepareRunCarmel import prepareRunCarmel
1021       fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1022       repMed=os.path.dirname(self.fichier)
1023       repExeCarmel=self.generator.get_repExeCarmel()
1024       textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1025       nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1026       f=open(nomFichier,'w')
1027       f.write(textePython)
1028       f.close()
1029       commande="xterm -e sh "+nomFichier +"\n"
1030       os.system(commande)
1031       #try :
1032       #    self._viewTextExecute( textePython,"carmel_run",".sh")
1033       #except Exception, e:
1034       #    print traceback.print_exc()
1035
1036     #-------------------#
1037     def runCarmelCS(self):
1038     #-------------------#
1039       try :
1040           commande="runSession pilotyacsCS.py"
1041           os.system(commande)
1042       except Exception, e:
1043           print traceback.print_exc()
1044
1045     #-----------------------------------------------------#
1046     def determineNomFichier(self,path,extension):
1047     #-----------------------------------------------------#
1048       if DictExtensions.has_key(self.appli.code) :
1049          chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1050          extensions= tr(chaine1+ "All Files (*)")
1051       else :
1052          extensions= tr("JDC (*.comm);;" "All Files (*)")
1053
1054       if self.appli.code == "MAP" :
1055          extensions = extensions + ";; Run (*.input);;"
1056
1057       fn = QFileDialog.getSaveFileName( self,
1058              tr("sauvegarde"), path,
1059              extensions,None,
1060              QFileDialog.DontConfirmOverwrite)
1061       if fn == None : return (0, None)
1062       if monEnvQT5 :  fn=fn[0]
1063       if fn=='': return (0, None)
1064
1065       ext = QFileInfo(fn).suffix()
1066       if ext == '': fn+=extension
1067
1068       if QFileInfo(fn).exists():
1069            if monEnvQT5 :
1070              msgBox = QMessageBox(self)
1071              msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1072              msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", unicode(fn)))
1073              msgBox.addButton(tr("&Ecraser"),0)
1074              msgBox.addButton(tr("&Abandonner"),1)
1075              abort=msgBox.exec_()
1076            else :
1077              abort = QMessageBox.warning(self,
1078                    tr("Sauvegarde du Fichier"),
1079                    tr("Le fichier <b>%s</b> existe deja.",str(fn)),
1080                    tr("&Ecraser"),
1081                    tr("&Abandonner"))
1082            if abort == 1 :  return (0, "")
1083       return (1,fn)
1084
1085     #-----------------#
1086     def saveRunMAP(self):
1087     #-----------------#
1088         extension=".input"
1089         if not(self.jdc.isvalid()):
1090            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1091                                 tr("Un JdC valide est necessaire pour creer un .input")
1092                                  )
1093            return
1094         try :
1095           composant=self.jdc.etapes[0].nom.lower()[0:-5]
1096         except :
1097            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1098                                 tr("Choix du composant obligatoire")
1099                                  )
1100            return
1101         if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1102         else : path='C:/'
1103
1104         monNomFichier=""
1105         if self.fichier is not None and self.fichier != "" :
1106              maBase=str(QFileInfo(self.fichier).baseName())+".input"
1107              monPath=str(QFileInfo(self.fichier).absolutePath())
1108              monNomFichier=os.path.join(monPath,maBase)
1109         elif hasattr(self,'monNomFichierInput'):
1110             monNomFichier=self.monNomFichierInput
1111
1112
1113         monDialog=QFileDialog(self.appliEficas)
1114         monDialog.setDirectory (path)
1115         monDialog.setWindowTitle ("Save")
1116
1117         for c in monDialog.children():
1118             if isinstance(c,QDialogButtonBox):
1119                for b in c.children():
1120                   if isinstance(b,QPushButton):
1121                      avant=b.text()
1122                      if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
1123                      if monEnvQT5 and avant=="&Open": b.setText("Save")
1124         if monEnvQT5 :
1125            mesFiltres= "input Map (*.input);;All Files (*)"
1126         else :
1127            mesFiltres=QStringList()
1128            mesFiltres << "input Map (*.input)" << "All Files (*)"
1129         monDialog.setNameFilters(mesFiltres)
1130         if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1131         BOk=monDialog.exec_()
1132         if BOk==0: return
1133         if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
1134         else : fn=str(monDialog.selectedFiles()[0].toLatin1())
1135         if fn == "" or fn == None : return
1136         if not fn.endswith(".input"):
1137             fn += ".input"
1138         self.monNomFichierInput=fn
1139
1140         if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1141             self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1142             texte=self.get_text_JDC("MAP")
1143             self.writeFile( self.fichierMapInput, txt = texte)
1144
1145         cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1146         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1147         (output, err) = p.communicate()
1148
1149
1150     #-----------------#
1151     def saveRunPSEN(self):
1152     #-----------------#
1153         print "saveRunPSEN"
1154         self.saveFile()
1155         return
1156         if not(self.jdc.isvalid()):
1157            QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1158                                 tr("Un JdC valide est necessaire pour creer un .input")
1159                                  )
1160            return
1161
1162         #print generator.plugins.has_key(self.format)
1163         if generator.plugins.has_key(self.format):
1164              # Le generateur existe on l'utilise
1165              self.generator=generator.plugins[self.format]()
1166              try :
1167                 self.generator.gener(self.jdc)
1168                 self.generator.writeDefault('')
1169              except ValueError,e:
1170                 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1171              if not self.generator.cr.estvide():
1172                 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1173                 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1174                 return ""
1175         else:
1176              # Il n'existe pas c'est une erreur
1177              self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1178              QMessageBox.critical( self, "Format  non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1179              return ""
1180         #print "HELLO"
1181         
1182
1183
1184
1185     #-----------------------------------------#
1186     def cherche_Groupes(self):
1187     #-----------------------------------------#
1188         listeMA,listeNO=self.get_text_JDC("GroupMA")
1189         return listeMA,listeNO
1190
1191     #-----------------------------------------#
1192     def cherche_Dico(self):
1193     #-----------------------------------------#
1194         dicoCourant={}
1195         format =  self.appliEficas.format_fichier
1196         if generator.plugins.has_key(format):
1197            # Le generateur existe on l'utilise
1198            self.generator=generator.plugins[format]()
1199            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1200            dicoCourant=self.generator.dico
1201         return dicoCourant
1202
1203          
1204
1205     #-----------------------------------------#
1206     def handleAjoutGroup(self,listeGroup):
1207     #-----------------------------------------#
1208         try :
1209         #if 1:
1210            from ajoutGroupe import handleAjoutGroupFiltre
1211            #print listeGroup
1212            handleAjoutGroupFiltre(self,listeGroup)
1213            #print "apres handleAjoutGroupFiltre"
1214         except :
1215         #else :
1216            pass
1217
1218     #-----------------------------------------------------------------#
1219     def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1220     #-----------------------------------------------------------------#
1221         """
1222         Public slot to save the text to a file.
1223
1224         @param path directory to save the file in (string or QString)
1225         @return tuple of two values (boolean, string) giving a success indicator and
1226             the name of the saved file
1227         """
1228
1229         self.modified=1
1230         if not self.modified and not saveas:
1231             return (0, None)      # do nothing if text wasn't changed
1232
1233         extension='.py'
1234         if DictExtensions.has_key(self.appli.code) :
1235            extension=DictExtensions[self.appli.code]
1236         else :
1237            extension='.comm'
1238
1239         newName = None
1240         fn = self.fichier
1241         if self.fichier is None or saveas:
1242           if path is None: path=self.CONFIGURATION.savedir
1243           bOK, fn=self.determineNomFichier(path,extension)
1244           if bOK == 0 : return (0, None)
1245           if fn == None : return (0, None)
1246           if fn== '' : return (0, None)
1247
1248           ulfile = os.path.abspath(unicode(fn))
1249           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1250           fn = unicode(QDir.toNativeSeparators(fn))
1251           newName = fn
1252
1253
1254         if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1255         self.fichier = fn
1256         self.modified  = False
1257         if self.fileInfo is None or saveas:
1258            self.fileInfo = QFileInfo(self.fichier)
1259            self.fileInfo.setCaching(0)
1260         self.lastModified = self.fileInfo.lastModified()
1261         if newName is not None:
1262            self.appliEficas.addToRecentList(newName)
1263            self.tree.racine.item.getObject().nom=os.path.basename(newName)
1264            self.tree.racine.update_node_label()
1265
1266         if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1267             self.generator.writeDefault(fn)
1268         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1269             self.generator.writeDefault(fn)
1270
1271         if self.salome :
1272                self.appliEficas.addJdcInSalome( self.fichier)
1273         self.modified = 0
1274         nouveauTitre=self.titre+"              "+str(os.path.basename(self.fichier))
1275         self.appliEficas.setWindowTitle(nouveauTitre)
1276
1277         return (1, self.fichier)
1278 #
1279
1280     #----------------------------------------------#
1281     def sauveLigneFile(self):
1282     #----------------------------------------------#
1283         self.modified=1
1284         return self.saveFile(formatLigne="Ligne")
1285
1286
1287     #----------------------------------------------#
1288     def saveFileAs(self, path = None,fileName=None):
1289     #----------------------------------------------#
1290         """
1291         Public slot to save a file with a new name.
1292
1293         @param path directory to save the file in (string or QString)
1294         @return tuple of two values (boolean, string) giving a success indicator and
1295             the name of the saved file
1296         """
1297         if fileName != None :
1298            self.fichier = fileName
1299            return self.saveFile()
1300         return self.saveFile(path,1,"beautifie")
1301
1302
1303
1304     #---------------------------------------------#
1305     def get_file(self,unite=None,fic_origine = ''):
1306     #---------------------------------------------#
1307     # appele par I_JDC
1308         ulfile  = None
1309         jdcText = ""
1310
1311         titre  = ""
1312
1313         if unite :
1314             titre = tr("Choix unite %d ", unite)
1315             texte = tr("Le fichier %s contient une commande INCLUDE \n",  str(fic_origine)) +"\n"
1316             texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1317             labeltexte = tr('Fichier pour unite ') + repr( unite)
1318         else:
1319             titre = tr("Choix d'un fichier de poursuite")
1320             texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1321             texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1322
1323         QMessageBox.information( self, titre,texte)
1324         fn = QFileDialog.getOpenFileName(self.appliEficas,
1325                    titre,
1326                    self.appliEficas.CONFIGURATION.savedir)
1327
1328         # ce retour est impose par le get_file d'I_JDC
1329         if fn== '' : return None," "
1330         if not fn : return (0, " ")
1331         if monEnvQT5 :  fn=fn[0]
1332
1333         ulfile = os.path.abspath(unicode(fn))
1334         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1335
1336         # On utilise le convertisseur defini par format_fichier
1337         source=self.get_source(ulfile)
1338         if source:
1339             # On a reussia convertir le fichier self.ulfile
1340             jdcText = source
1341         else:
1342             # Une erreur a ete rencontree
1343             jdcText = ''
1344         return ulfile, jdcText
1345
1346     #-------------------------------#
1347     def updateJdc(self, itemApres,texte):
1348     #--------------------------------#
1349         monItem=itemApres
1350         etape=monItem.item.object
1351
1352         CONTEXT.set_current_step(etape)
1353         etape.build_includeInclude(texte)
1354         self.tree.racine.build_children()
1355
1356     #-------------------------------------#
1357     def deleteEtape(self,etape):
1358     #-------------------------------------#
1359         self.jdc.suppentite(etape)
1360
1361     #-------------------------------------#
1362     def deleteMC(self,etape,MCFils,listeAvant=()):
1363     #-------------------------------------#
1364         ouChercher=etape
1365         for mot in listeAvant :
1366               ouChercher=ouChercher.get_child(mot,restreint="oui")
1367         monMC=ouChercher.get_child(MCFils,restreint="oui")
1368         if monMC != None :  ouChercher.suppentite(monMC)
1369         ouChercher.state='changed'
1370         ouChercher.isvalid()
1371
1372     #-------------------------------------#
1373     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1374     #-------------------------------------#
1375         ouChercher=etape
1376         for mot in listeAvant :
1377               ouChercher=ouChercher.get_child(mot,restreint="oui")
1378         monMC=etape.get_child(ouChercher,restreint="oui")
1379         if monMC== None : monMC= ouChercher.addentite(MCFils)
1380         monMC.valeur=valeurs
1381         monMC.val=valeurs
1382         monMC.state='changed'
1383         monMC.isvalid()
1384
1385     #-----------------------------------------------------------#
1386     def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1387     #-----------------------------------------------------------#
1388         ouChercher=etape
1389         for mot in listeAvant :
1390               ouChercher=ouChercher.get_child(mot,restreint="oui")
1391         if ouChercher ==None : print 'SOUCI'; return
1392         monMC=ouChercher.get_child(MCFils,restreint="oui")
1393         if monMC== None : monMC= ouChercher.addentite(MCFils)
1394         monMC.definition.into=valeurs
1395         monMC.state='changed'
1396         monMC.isvalid()
1397
1398     #-------------------------------------#
1399     def changeIntoDefMC(self,etape,listeMC,valeurs):
1400     #-------------------------------------#
1401         definitionEtape=getattr(self.jdc.cata[0],etape)
1402         ouChercher=definitionEtape
1403         if len(listeMC) > 1 :
1404            for mc in listeMC[0:-1]:
1405              mcfact=ouChercher.entites[mc]
1406              ouChercher=mcfact
1407            
1408         mcAccas=ouChercher.entites[listeMC[-1]]
1409         mcAccas.into=valeurs
1410
1411     #-------------------------------------------------------------#
1412     def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1413     #-------------------------------------------------------------#
1414         #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1415         definitionEtape=getattr(self.jdc.cata[0],etape)
1416         ouChercher=definitionEtape
1417         for k in listeAvant : 
1418             ouChercher=ouChercher.entites[k]
1419         MCADetruire=ouChercher.entites[nomDuMC]
1420         ouChercher.ordre_mc.remove(nomDuMC)
1421         del ouChercher.entites[nomDuMC]
1422         del self.dicoNouveauxMC[nomDuMC]
1423
1424
1425     #-------------------------------------------------------------#
1426     def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1427     #-------------------------------------------------------------#
1428         definitionEtape=getattr(self.jdc.cata[0],etape)
1429         ouChercher=definitionEtape
1430         for k in listeAvant : 
1431             ouChercher=ouChercher.entites[k]
1432         from Accas import A_SIMP
1433         Nouveau=A_SIMP.SIMP(typ,**args)
1434         Nouveau.pere=ouChercher
1435         Nouveau.nom=nomDuMC
1436         Nouveau.ordre_mc=[]
1437         ouChercher.entites[nomDuMC]=Nouveau
1438         ouChercher.ordre_mc.append(nomDuMC)
1439         self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1440         #print self.dicoNouveauxMC
1441
1442     #----------------------------------------------------#
1443     def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1444     #----------------------------------------------------#
1445         monMC=etape.get_child(MCFils,restreint="oui")
1446         if monMC== None : monMC= etape.addentite(MCFils)
1447         monMC.definition.into=into
1448         monMC.valeur=valeurs
1449         monMC.val=valeurs
1450         monMC.state='changed'
1451         monMC.isvalid() 
1452
1453     #-------------------------------------#
1454     def ajoutVersionCataDsJDC(self,txt):
1455     #-------------------------------------#
1456         if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1457         ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1458         texte=txt+ligneVersion
1459         return texte
1460
1461     #-------------------------------------#
1462     def verifieVersionCataDuJDC(self,text):
1463     #-------------------------------------#
1464         memeVersion=False
1465         indexDeb=text.find("#VERSION_CATALOGUE:")
1466         indexFin=text.find(":FIN VERSION_CATALOGUE")
1467         if indexDeb < 0 :
1468            self.versionCataDuJDC="sans"
1469            textJDC=text
1470         else :
1471            self.versionCataDuJDC=text[indexDeb+19:indexFin]
1472            textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1473
1474         self.versionCata="sans"
1475         if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1476
1477         if self.versionCata==self.versionCataDuJDC : memeVersion=True
1478         return memeVersion,textJDC
1479
1480     #-------------------------------#
1481     def traduitCatalogue(self,texte):
1482     #-------------------------------#
1483         nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1484         sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1485         try :
1486             traducteur=__import__(nomTraducteur)
1487             monTraducteur=traducteur.MonTraducteur(texte)
1488             nouveauTexte=monTraducteur.traduit()
1489             return nouveauTexte
1490         except :
1491             return texte
1492
1493
1494     #------------------------------#
1495     def verifieCHECKSUM(self,text):
1496     #------------------------------#
1497         indexDeb=text.find("#CHECKSUM:")
1498         if indexDeb < 0 :
1499            return 1, text
1500         indexFin=text.find(":FIN CHECKSUM")
1501         checkAvant=text[indexDeb:indexFin+13]
1502         textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1503         checksum=self.get_checksum(textJDC)
1504         pareil=(checkAvant==checksum)
1505         return pareil, textJDC
1506
1507     #---------------------------#
1508     def get_checksum(self,texte):
1509     #---------------------------#
1510         newtexte=texte.replace('"','\\"')
1511         commande='echo "'+newtexte+'"|md5sum'
1512         a=os.popen(commande)
1513         checksum=a.read()
1514         a.close()
1515         ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1516         return ligne
1517
1518
1519     #---------------------------#
1520     def _new_CF(self):
1521     #---------------------------#
1522         texte="CONDUITE_FORCEE();"
1523         return texte
1524
1525
1526     #---------------------------#
1527     def _newTELEMAC(self):
1528     #---------------------------#
1529         #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1530         texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1531         #texte="TRACERS();"
1532         return texte
1533
1534     #---------------------------#
1535     def _newPSEN(self):
1536     #---------------------------#
1537         texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1538         #texte=""
1539         return texte
1540
1541     #---------------------------#
1542     def _newPSEN_N1(self):
1543     #---------------------------#
1544         texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1545         texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1546         return texte
1547
1548     #---------------------------#
1549
1550     #---------------------------#
1551     def _newZCRACKS(self):
1552     #---------------------------#
1553         texte="MAILLAGES();REMESHING();"
1554         return texte
1555
1556     #---------------------------#
1557     def _newJDCCND(self):
1558     #---------------------------#
1559       extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1560       
1561       #if self.salome == 0 :
1562       QMessageBox.information( self,
1563                       tr("Fichier Med"),
1564                       tr("Veuillez selectionner un fichier Med"))
1565       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1566                         caption='Fichier Med',
1567                         filter=extensions)
1568       if monEnvQT5 : QSfichier=QSfichier[0]
1569       self.fichierMED=QSfichier
1570       from acquiertGroupes import getGroupes
1571       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1572       if erreur != "" : print "a traiter"
1573       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1574       texteSources=""
1575       texteCond=""
1576       texteNoCond=""
1577       texteVcut=""
1578       texteZs=""
1579       for groupe in self.listeGroupes :
1580           if groupe[0:8]=='CURRENT_': 
1581              texteSources +=groupe[8:]+"=SOURCE("
1582              texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1583           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
1584           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
1585           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
1586           if groupe[0:3]=='ZS_':      texteZs      +=groupe[3:]+"=ZS();\n"
1587       texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1588       self.newTexteCND=texte
1589       self.modified=1
1590       return texte
1591
1592
1593     #---------------------------#
1594     def  BoutonFileSelected(self):
1595     #---------------------------#
1596
1597       QSfichier=self.openfile.selectedFiles()[0]
1598       self.fichierMED=str(QSfichier)
1599       from acquiertGroupes import getGroupes
1600       erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1601       if erreur != "" : print "a traiter"
1602
1603     #-----------------------------
1604     def BoutonSalomePressed(self):
1605     #----------------------------
1606       Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1607       self.fichierMED="A_partir_de_SMESH"
1608       self.nomMaillage="A_partir_de_SMESH"
1609       self.openfile.close()
1610
1611
1612     #-----------------------------------------
1613     def initSplitterSizes(self, nbWidget=3):
1614     #-----------------------------------------
1615        #print "je passe ds initSplitterSizes"
1616        if nbWidget==3 :
1617           if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes=[1,1550,150]
1618           elif self.code in [ 'MAP']            : self.splitterSizes=[700,300]
1619           else                                  : self.splitterSizes=[150,800,500]
1620           self.oldSizeWidgetOptionnel = 30
1621        if nbWidget==2 :
1622           if   self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes=[5,1500]
1623           else                                  : self.splitterSizes=[300,1000]
1624           self.oldSizeWidgetOptionnel = 30
1625        self.splitter.setSizes(self.splitterSizes)
1626
1627
1628     #-----------------------------------------
1629     def restoreSplitterSizes(self,nbWidget=3):
1630     #----------------------------------------
1631       #self.inhibeSplitter = 1
1632       
1633       #print 'ds restoreSplitterSizes'
1634       #print self.splitterSizes
1635       if not(hasattr(self,'splitter')) : return
1636       if nbWidget==2 and len(self.splitterSizes) == 3 :
1637          self.splitterSizes[1]+=self.splitterSizes[2]
1638       newSizes=self.splitterSizes[:nbWidget]
1639       self.splitter.setSizes(newSizes)
1640       QApplication.processEvents()
1641       # seule la fentetre du milieu est necessaire
1642       self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1643    
1644     def saveSplitterSizes(self,event):
1645       self.splitterSizes= self.splitter.sizes()
1646
1647     #------------------------
1648     def fermeOptionnel(self):
1649     #------------------------
1650       if self.widgetOptionnel == None : return
1651
1652       self.inhibeSplitter=1
1653       self.splitterSizes[1] = self.splitterSizes[1] + self.splitterSizes[2]
1654       if self.splitterSizes[2]!=0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
1655       self.splitterSizes[2]=0
1656
1657       self.widgetOptionnel.setParent(None)
1658       self.widgetOptionnel.close()
1659       self.widgetOptionnel.deleteLater()
1660       self.widgetOptionnel=None
1661       self.inhibeSplitter=0
1662       self.restoreSplitterSizes(2)
1663       
1664     #------------------------
1665     def ajoutOptionnel(self):
1666     #------------------------
1667       if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1668       else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1669       #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1670       
1671       self.restoreSplitterSizes(3)
1672
1673
1674     #-----------------------------
1675     def getTreeIndex(self,noeud):
1676     #----------------------------
1677       indexNoeud=-1
1678       if noeud in noeud.treeParent.children :
1679           indexNoeud=noeud.treeParent.children.index(noeud)
1680       else :
1681           if hasattr(noeud,'vraiParent') :
1682               noeudVrai = noeud
1683               noeudVraiParent = noeud.vraiParent
1684               while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1685                   noeudVrai = noeudVraiParent
1686                   noeudVraiParent = noeudVraiParent.vraiParent
1687                   pass
1688               if noeudVraiParent == noeud.treeParent :
1689                   indexNoeud=noeud.treeParent.children.index(noeudVrai)
1690                   pass
1691               pass
1692           pass
1693       return indexNoeud
1694
1695 if __name__ == "__main__":
1696     self.code='ASTER'
1697     name='prefs_'+prefs.code
1698     prefsCode=__import__(name)
1699
1700
1701     if hasattr(prefsCode,'encoding'):
1702        # Hack pour changer le codage par defaut des strings
1703        import sys
1704        reload(sys)
1705        sys.setdefaultencoding(prefs.encoding)
1706        del sys.setdefaultencoding
1707        # Fin hack
1708
1709 #    code=options.code
1710 #
1711     app = QApplication(sys.argv)
1712     mw = JDCEditor(None,'azAster.comm')
1713     app.setMainWidget(mw)
1714     app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1715     mw.show()
1716
1717     res = app.exec_loop()
1718     sys.exit(res)