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