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