]> SALOME platform Git repositories - tools/eficas.git/blob - InterfaceQT4/editor.py
Salome HOME
*** empty log message ***
[tools/eficas.git] / InterfaceQT4 / editor.py
1 # -*- coding: utf-8 -*-
2 # ======================================================================
3 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
4 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
5 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
6 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
7 # (AT YOUR OPTION) ANY LATER VERSION.
8 #
9 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
10 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
11 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
12 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
13 #
14 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
15 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
16 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
17 #
18 #
19 # ======================================================================
20
21 import types,sys,os
22 import traceback
23 from PyQt4 import *
24 from PyQt4.QtGui  import *
25 from PyQt4.QtCore import *
26
27 # Modules Eficas
28
29 import convert,generator
30 from Editeur     import session
31 from Editeur     import comploader
32 from Editeur     import Objecttreeitem
33 import browser
34 import readercata
35 import qtCommun
36
37 DictExtensions= {"MAP" : ".map"}
38
39
40
41 class JDCEditor(QSplitter):
42 # -------------------------- #
43     """
44        Editeur de jdc
45     """        
46
47     def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):          
48     #----------------------------------------------------------------------------------------------------------#
49
50         #print "fichier", fichier,"jdc",jdc,"units",units,"include",include
51         QSplitter.__init__(self, QWParent)
52         self.appliEficas = appli
53         self.appli       = appli  #---- attendu par IHM
54         self.vm          = vm
55         self.fichier     = fichier
56         self.jdc         = jdc
57         self.QWParent    = QWParent
58
59         self.test=0
60         VERSION_CODE    = session.d_env.cata
61         if appli != None :
62            self.salome =  self.appliEficas.salome
63            self.format =  self.appliEficas.format_fichier
64         else :
65            self.salome=0
66            print "dans JDC pas d appli ????????"
67
68         self.code = self.appliEficas.CONFIGURATION.code
69         self.version_code = VERSION_CODE
70         self.titre=self.appliEficas.VERSION_EFICAS + ' pour '+ self.code
71
72         self.dict_reels={}
73         self.liste_simp_reel=[]        
74         self.ihm="QT"
75         
76         import prefs
77         nameConf='configuration_'+prefs.code
78         configuration=__import__(nameConf)
79         self.CONFIGURATION = self.appliEficas.CONFIGURATION
80         self.CONFIGStyle =   self.appliEficas.CONFIGStyle
81
82         try:
83           self.CONFIGURATION.generator_module
84           _module = __import__(self.CONFIGURATION.generator_module)
85           info = _module.entryPoint()
86           generator.plugins.addEntryPoint(info)
87         except:
88           pass
89
90         try:
91           self.CONFIGURATION.convert_module
92           _module = __import__(self.CONFIGURATION.convert_module)
93           info = _module.entryPoint()
94           convert.plugins.addEntryPoint(info)
95         except :
96           pass
97
98         self.sb = None
99         if hasattr(self.appliEficas,"statusBar"):
100            self.sb = self.appliEficas.statusBar()
101       
102         self.fileInfo       = None
103         self.lastModified   = 0
104         
105         self.modified   = False
106         self.isReadOnly = False
107         self.tree = None
108         self.node_selected = None
109         self.message=''
110         
111         #if not hasattr( readercata, 'reader' ) :
112         #    readercata.reader = readercata.READERCATA( self, self.appliEficas )
113         #self.readercata = readercata.reader
114         if not hasattr ( self.appliEficas, 'readercata'):
115            self.readercata  = readercata.READERCATA( self, self.appliEficas )
116            self.appliEficas.readercata=self.readercata
117         else :
118            self.readercata=self.appliEficas.readercata
119         if self.readercata.fic_cata == None : return    #Sortie Salome
120         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
121         
122         #------- construction du jdc --------------
123
124         jdc_item = None
125         self.mode_nouv_commande=self.readercata.mode_nouv_commande
126                         
127         nouveau=0
128         if self.fichier is not None:        #  fichier jdc fourni
129             self.fileInfo = QFileInfo(self.fichier)
130             self.fileInfo.setCaching(0)
131             if jdc==None :
132                self.jdc = self.readFile(self.fichier)
133             else :
134                self.jdc=jdc
135             if units is not None:
136                self.jdc.recorded_units=units
137                self.jdc.old_recorded_units=units
138         else: 
139             if not self.jdc:                   #  nouveau jdc
140                 if not include :
141                    self.jdc = self._newJDC(units=units)
142                 else :
143                    self.jdc = self._newJDCInclude(units=units)
144                 nouveau=1
145         
146         if self.jdc:            
147             self.jdc.appli = self
148             txt_exception  = None
149             if not jdc:
150                 self.jdc.analyse()            
151                 txt_exception = self.jdc.cr.get_mess_exception()            
152             if txt_exception:
153                 self.jdc = None
154                 qApp.restoreOverrideCursor()
155                 self.affiche_infos("Erreur fatale au chargement de %s" %fichier,Qt.red)                
156                 QMessageBox.critical( self, "Erreur fatale au chargement d'un fichier", txt_exception)                
157             else:
158                 comploader.charger_composants("QT")
159                 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
160
161                 if (not self.jdc.isvalid()) and (not nouveau) :
162                     self.viewJdcRapport()
163         if jdc_item:                        
164             self.tree = browser.JDCTree( jdc_item,  self )
165         
166     #--------------------------------#
167     def _newJDC( self ,units = None):        
168     #--------------------------------#
169         """
170         Initialise un nouveau JDC vierge
171         """
172         CONTEXT.unset_current_step()        
173         jdc=self.readercata.cata[0].JdC( procedure="",
174                                          appli=self,
175                                          cata=self.readercata.cata,
176                                          cata_ord_dico=self.readercata.cata_ordonne_dico,
177                                          rep_mat=self.CONFIGURATION.rep_mat
178                                         )                         
179         if units is not None:
180            jdc.recorded_units=units
181            jdc.old_recorded_units=units
182         jdc.analyse()        
183         return jdc
184         
185     #--------------------------------#
186     def _newJDCInclude( self ,units = None):        
187     #--------------------------------#
188         """
189         Initialise un nouveau JDC vierge
190         """
191         import Extensions.jdc_include
192         JdC_aux=Extensions.jdc_include.JdC_include
193         CONTEXT.unset_current_step()        
194
195         jaux=self.readercata.cata[0].JdC( procedure="",
196                                appli=self,
197                                cata=self.readercata.cata,
198                                cata_ord_dico=self.readercata.cata_ordonne_dico,
199                                rep_mat=self.CONFIGURATION.rep_mat,
200                               )
201         jaux.analyse()
202
203         J=JdC_aux( procedure="",
204                    appli=self,
205                    cata=self.readercata.cata,
206                    cata_ord_dico=self.readercata.cata_ordonne_dico,
207                    jdc_pere=jaux,
208                    rep_mat=self.CONFIGURATION.rep_mat,
209                    )
210         J.analyse()
211         if units is not None:
212            J.recorded_units=units
213            J.old_recorded_units=units
214         return J
215
216     #-----------------------#
217     def readFile(self, fn):
218     #--------------------------------#
219         """
220         Public slot to read the text from a file.
221         @param fn filename to read from (string or QString)
222         """        
223         fn = unicode(fn)        
224                         
225         # ------------------------------------------------------------------------------------
226         #                         charge le JDC
227         # ------------------------------------------------------------------------------------      
228         
229         jdcName=os.path.basename(fn)
230         # Il faut convertir le contenu du fichier en fonction du format
231         if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
232              # Le convertisseur existe on l'utilise
233              #appli = self 
234              p=convert.plugins[self.appliEficas.format_fichier_in]()
235              p.readfile(fn)         
236              text=p.convert('exec',self.appliEficas)
237              if not p.cr.estvide():                 
238                 self.affiche_infos("Erreur à la conversion",Qt.red)
239         else :
240             self.affiche_infos("Type de fichier non reconnu",Qt.red)
241             QMessageBox.critical( self, "Type de fichier non reconnu","EFICAS ne sait pas ouvrir ce type de fichier")            
242             return None
243         
244         CONTEXT.unset_current_step()
245         jdc=self.readercata.cata[0].JdC(procedure=text,
246                                     appli=self,
247                                     cata=self.readercata.cata,
248                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
249                                     nom=jdcName,
250                                     rep_mat=self.CONFIGURATION.rep_mat
251                                    )
252         # ----------------------------------------------------
253         #      charge le JDC fin
254         # ----------------------------------------------------
255         self.modified = False
256                         
257 #        qApp.restoreOverrideCursor()        
258         if self.fileInfo!= None : 
259            self.lastModified = self.fileInfo.lastModified()
260         else :
261            self.lastModified = 1
262         return jdc
263         
264
265     #-----------------------#
266     def get_source(self,file):
267     #-----------------------#
268         format=self.appliEficas.format_fichier
269
270         # Il faut convertir le contenu du fichier en fonction du format
271         if convert.plugins.has_key(format):
272             # Le convertisseur existe on l'utilise
273             p=convert.plugins[format]()
274             p.readfile(file)
275             text=p.convert('execnoparseur')
276             if not p.cr.estvide():
277                 self.affiche_infos("Erreur a la conversion",Qt.red)
278             return text
279         else:
280             # Il n'existe pas c'est une erreur
281             self.affiche_infos("Type de fichier non reconnu",Qt.red)
282             QMessageBox.critical( self, "Type de fichier non reconnu","EFICAS ne sait pas ouvrir ce type de fichier")            
283             return None
284
285     #----------------------------------------------#
286     def _viewText(self, txt, caption = "FILE_VIEWER"):    
287     #----------------------------------------------#
288         w = qtCommun.ViewText( self.QWParent )
289         w.setWindowTitle( caption )
290         w.setText(txt)
291         w.show()
292         
293     #-----------------------#
294     def viewJdcSource(self):        
295     #-----------------------#
296         format = self.appliEficas.format_fichier
297         f=open(self.fichier,'r')
298         texteSource=f.read()
299         f.close()
300         self._viewText(texteSource, "JDC_SOURCE")
301                 
302     #-----------------------#
303     def viewJdcPy(self):        
304     #-----------------------#
305         format = self.appliEficas.format_fichier
306         strSource = str( self.get_text_JDC(format) )       
307         self._viewText(strSource, "JDC_RESULTAT")
308                  
309     #-----------------------#
310     def viewJdcRapport(self):
311     #-----------------------#
312         strRapport = str( self.jdc.report() )
313         self._viewText(strRapport, "JDC_RAPPORT")        
314         
315     #----------------#
316     def closeIt(self):
317     #----------------#
318         """
319         Public method called by the viewmanager to finally get rid of us.
320         """
321         if self.jdc:
322             self.jdc.supprime()
323         self.close()
324     
325     #----------------------------------------------#
326     def affiche_infos(self,message,couleur=Qt.black):
327     #----------------------------------------------#
328         if self.sb:
329            mapalette=self.sb.palette()
330            from PyQt4.QtGui import QPalette
331            mapalette.setColor( QPalette.WindowText, couleur )
332            self.sb.setPalette( mapalette );
333            self.sb.showMessage(QString.fromUtf8(message))#,2000)
334
335     #------------------------------#
336     def affiche_alerte(self,titre,message):
337     #------------------------------#
338     # appele par I_MACRO_ETAPE
339         QMessageBox.information( self, titre, message)
340
341     #-------------------#
342     def init_modif(self):
343     #-------------------#
344       """
345           Met l'attribut modified a 'o' : utilise par Eficas pour savoir
346           si un JDC doit etre sauvegarde avant destruction ou non
347       """
348       self.modified = True
349
350     #---------------------------------------#
351     def chercheNoeudSelectionne(self,copie=1):
352     #---------------------------------------#
353       """
354         appele par Cut et Copy pour positionner self.node_selected
355       """
356       self.node_selected=None
357       if len(self.tree.selectedItems()) == 0 : return
358       if len(self.tree.selectedItems()) != 1 :
359           QMessageBox.information( self, 
360                       "Copie impossible",
361                       "Cette version d'EFICAS permet uniquement la copie d un seul objet")
362           return
363       self.node_selected=self.tree.selectedItems()[0]
364       if copie == 0 : return
365     
366     
367     #---------------------#
368     def handleSupprimer(self):
369     #---------------------#
370       #print "handleSupprimer"
371       self.chercheNoeudSelectionne()
372       self.node_selected.delete()
373     
374     #---------------------#
375     def handleEditCut(self):
376     #---------------------#
377       """
378       Stocke dans Eficas.noeud_a_editer le noeud à couper
379       """
380       #print "handleEditCut"
381       self.chercheNoeudSelectionne()
382       self.QWParent.edit="couper"
383       self.QWParent.noeud_a_editer = self.node_selected      
384     
385     #-----------------------#
386     def handleEditCopy(self):
387     #-----------------------#
388       """
389       Stocke dans Eficas.noeud_a_editer le noeud a copier
390       """
391       #print "handleEditCut"
392       self.chercheNoeudSelectionne()
393       self.QWParent.edit="copier"
394       self.QWParent.noeud_a_editer = self.node_selected
395     
396     #------------------------#
397     def handleEditPaste(self):
398     #------------------------#
399       """
400       Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
401       Ne permet que la copie d'objets de type Commande ou MCF
402       """
403       #print "handleEditPaste"
404       self.chercheNoeudSelectionne()
405       try :
406           index_noeud_a_couper=self.QWParent.noeud_a_editer.treeParent.children.index(self.QWParent.noeud_a_editer)
407       except :
408           QMessageBox.information( self, 
409                       "Copie impossible",
410                       "Aucun Objet n a ete copie ou coupe ")
411           return
412       child=0
413       try:
414          child=self.QWParent.noeud_a_editer.doPaste(self.node_selected)
415       except:
416          traceback.print_exc()
417          QMessageBox.information( self, 
418                      "Copie refusee",         
419                      "Copie refusee pour ce type d objet a cet endroit")
420          self.message = ''
421          self.affiche_infos("Copie refusée")
422          return
423      
424       if child == 0 or child == None:
425           QMessageBox.critical( self, "Copie refusee",'Copie refusee pour ce type d objet')
426           self.message = ''
427           self.affiche_infos("Copie refusée",Qt.red)
428           return
429     
430       # il faut declarer le JDCDisplay_courant modifie
431       self.init_modif()
432       # suppression eventuelle du noeud selectionne
433       # si possible on renomme l objet comme le noeud couper
434
435       if self.QWParent.edit == "couper":
436          index_ajoute=child.treeParent.children.index(child)
437          if index_ajoute <= index_noeud_a_couper :
438             index_noeud_a_couper=index_noeud_a_couper + 1
439          item=self.QWParent.noeud_a_editer.item
440          noeud_a_supprimer=self.QWParent.noeud_a_editer.treeParent.children[index_noeud_a_couper]
441          noeud_a_supprimer.delete()
442          child.item.update(item)
443          #test,mess = child.item.nomme_sd(nom)
444          child.select()
445
446       # on rend la copie a nouveau possible en liberant le flag edit
447       self.QWParent.edit="copier"
448           
449     #---------------------#
450     def getFileName(self):
451     #---------------------#
452       return self.fichier
453
454     #---------------------------#
455     def get_file_variable(self) :
456     #---------------------------#
457      titre = "Choix d'un fichier XML"
458      texte = "Le fichier contient une commande MODEL\n"
459      texte = texte+'Donnez le nom du fichier XML qui contient la description des variables'
460      QMessageBox.information( self, titre,texte)
461                                         
462      fichier = QFileDialog.getOpenFileName(self.appliEficas,
463                    self.appliEficas.trUtf8('Ouvrir Fichier'),
464                    self.appliEficas.CONFIGURATION.savedir,
465                    self.appliEficas.trUtf8('Wrapper Files (*.xml);;''All Files (*)'))
466      return  fichier
467       
468     #----------------------------------#
469     def writeFile(self, fn, txt = None):
470     #----------------------------------#
471         """
472         Public slot to write the text to a file.
473         
474         @param fn filename to write to (string or QString)
475         @return flag indicating success
476         """
477
478         fn = unicode(fn)
479
480         if txt == None :
481             txt = self.get_text_JDC(self.appliEficas.format_fichier)
482             eol = '\n'        
483             if len(txt) >= len(eol):
484                if txt[-len(eol):] != eol:
485                   txt += eol
486             else:
487                 txt += eol        
488         try:
489             f = open(fn, 'wb')
490             f.write(txt)
491             f.close()
492             return 1
493         except IOError, why:
494             QMessageBox.critical(self, self.trUtf8('Save File'),
495                 self.trUtf8('The file <b>%1</b> could not be saved.<br>Reason: %2')
496                     .arg(unicode(fn)).arg(str(why)))
497             return 0
498
499     #-----------------------------#
500     def get_text_JDC(self,format):
501     #-----------------------------#
502       if generator.plugins.has_key(format):
503          # Le generateur existe on l'utilise
504          self.generator=generator.plugins[format]()
505          jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
506          if not self.generator.cr.estvide():            
507             self.affiche_infos("Erreur à la generation",Qt.red)
508             QMessageBox.critical( self, "Erreur a la generation","EFICAS ne sait pas convertir ce JDC")
509             return ""
510          else:
511             return jdc_formate
512       else:         
513          # Il n'existe pas c'est une erreur
514          self.affiche_infos("Format %s non reconnu" % format,Qt.red)
515          QMessageBox.critical( self, "Format "+format+" non reconnu","EFICAS ne sait pas convertir le JDC selon le format "+format)
516          return ""
517
518     #-----------------------------#
519     def run(self,execution="oui"):
520     #-----------------------------#
521       format=self.appliEficas.format_fichier
522       self.textePython=""
523       if generator.plugins.has_key(format):
524          # Le generateur existe on l'utilise
525          self.generator=generator.plugins[format]()
526          self.textePython =self.generator.generRUN(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
527       if execution=="oui" :
528          os.system(self.textePython)
529       else:
530          return self.textePython
531
532     #------------------------------------------------#
533     def runYACS(self,execution="oui",nomFichier=None):
534     #------------------------------------------------#
535       format=self.appliEficas.format_fichier
536       if generator.plugins.has_key(format):
537          # Le generateur existe on l'utilise
538          self.generator=generator.plugins[format]()
539          self.generator.generRUNYACS(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION,nomFichier=nomFichier)
540       if execution=="oui" :
541          print "il faut faire le run dans Salome"
542     
543     #-----------------------------#
544     def saveRun(self):
545     #-----------------------------#
546         texte=self.run(execution="non")
547         path=self.CONFIGURATION.savedir
548         fn = QFileDialog.getSaveFileName( self,
549              self.trUtf8("sauvegarde"), path,
550              self.trUtf8("JDC (*.sh);;" "All Files (*)"),None,
551              QFileDialog.DontConfirmOverwrite)
552         if fn.isNull(): return 
553         ext = QFileInfo(fn).suffix()
554         if ext.isEmpty(): fn.append(".xml")
555
556         if QFileInfo(fn).exists():
557                 abort = QMessageBox.warning(self,
558                        self.trUtf8("Sauvegarde du Fichier"),
559                        self.trUtf8("Le fichier <b>%1</b> existe deja.").arg(fn),
560                        self.trUtf8("&Ecraser"),
561                        self.trUtf8("&Abandonner"))
562                 if abort == 1 :  return
563
564         fn = unicode(QDir.convertSeparators(fn))
565         self.writeFile( fn, txt = texte)
566     
567     #-----------------------------#
568     def saveYACS(self):
569     #-----------------------------#
570         path=self.CONFIGURATION.savedir
571         fn = QFileDialog.getSaveFileName( self,
572              self.trUtf8("sauvegarde"), path,
573              self.trUtf8("JDC (*.xml);;" "All Files (*)"),None,
574              QFileDialog.DontConfirmOverwrite)
575         if fn.isNull(): return 
576         ext = QFileInfo(fn).suffix()
577         if ext.isEmpty(): fn.append(".xml")
578
579         if QFileInfo(fn).exists():
580                 abort = QMessageBox.warning(self,
581                        self.trUtf8("Sauvegarde du Fichier"),
582                        self.trUtf8("Le fichier <b>%1</b> existe deja.").arg(fn),
583                        self.trUtf8("&Ecraser"),
584                        self.trUtf8("&Abandonner"))
585                 if abort == 1 :  return
586         fn = unicode(QDir.convertSeparators(fn))
587
588         texte=self.runYACS(execution="non",nomFichier=fn)
589         #self.writeFile( fn, txt = texte)
590       
591     #-----------------------------------------#
592     def cherche_Groupes(self):
593     #-----------------------------------------#
594         listeMA,listeNO=self.get_text_JDC("GroupMA")
595         return listeMA,listeNO
596
597     #-----------------------------------------#
598     def saveFile(self, path = None, saveas= 0):
599     #-----------------------------------------#
600         """
601         Public slot to save the text to a file.
602         
603         @param path directory to save the file in (string or QString)
604         @return tuple of two values (boolean, string) giving a success indicator and
605             the name of the saved file
606         """        
607                 
608         if not self.modified and not saveas:
609             return (0, None)      # do nothing if text wasn't changed
610             
611         newName = None
612         if self.fichier is None or saveas:
613           if path is None: 
614              path=self.CONFIGURATION.savedir
615           selectedFilter = QString('')
616           if DictExtensions.has_key(self.appli.code) :
617                chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
618                extensions= self.trUtf8(chaine1+ "All Files (*)")
619           else :
620                extensions= self.trUtf8("JDC (*.comm);;" "All Files (*)")
621           fn = QFileDialog.getSaveFileName( self,
622                self.trUtf8("sauvegarde"), path,
623                extensions,None,
624                QFileDialog.DontConfirmOverwrite)
625           if fn.isNull(): return (0, None)
626           ulfile = os.path.abspath(unicode(fn))
627           self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
628
629           ext = QFileInfo(fn).suffix()
630           if ext.isEmpty():
631              if DictExtensions.has_key(self.appli.code) :
632                 fn.append(DictExtensions[self.appli.code])
633              else :
634                 fn.append(".comm")
635
636           if QFileInfo(fn).exists():
637                 abort = QMessageBox.warning(self,
638                        self.trUtf8("Sauvegarde du Fichier"),
639                        self.trUtf8("Le fichier <b>%1</b> existe deja.").arg(fn),
640                        self.trUtf8("&Ecraser"),
641                        self.trUtf8("&Abandonner"))
642                 if abort == 1 :  return (0, None)
643
644           fn = unicode(QDir.convertSeparators(fn))
645           newName = fn
646
647         else:
648             fn = self.fichier
649         
650         if self.writeFile(fn):
651             self.fichier = fn
652             self.modified  = False                        
653             if self.fileInfo is None or saveas:
654                 self.fileInfo = QFileInfo(self.fichier)
655                 self.fileInfo.setCaching(0)
656             self.lastModified = self.fileInfo.lastModified()
657             if newName is not None:
658                 self.appliEficas.addToRecentList(newName)
659                 self.tree.racine.item.getObject().nom=os.path.basename(newName)
660                 self.tree.racine.update_node_label()
661                
662             if self.jdc.isvalid() != 0 :
663                try : 
664                   fileXML = fn[:fn.rfind(".")] + '.xml'
665                   self.generator.writeOpenturnsXML( fileXML )
666                except :
667                   pass
668                
669                try : 
670                   fileSTD = fn[:fn.rfind(".")] + '.py'
671                   self.generator.writeOpenturnsSTD( fileSTD )
672                except :
673                   pass
674
675                try:
676                  self.generator.writeDefault(fn)
677                except:
678                  pass
679
680                try : 
681                   fileCuve2DG = fn[:fn.rfind(".")] + '.don'
682                   self.generator.writeCuve2DG(fileCuve2DG)
683                except :
684                   pass
685
686
687             if self.salome : 
688                self.appliEficas.addJdcInSalome( self.fichier)
689
690             return (1, self.fichier)
691         else:
692             return (0, None)
693 #
694     #---------------------------------#
695     def saveFileAs(self, path = None):
696     #---------------------------------#
697         """
698         Public slot to save a file with a new name.
699         
700         @param path directory to save the file in (string or QString)
701         @return tuple of two values (boolean, string) giving a success indicator and
702             the name of the saved file
703         """
704         return self.saveFile(path,1)
705
706    
707         
708     #---------------------------------------------#
709     def get_file(self,unite=None,fic_origine = ''):
710     #---------------------------------------------#
711     # appele par I_JDC
712         ulfile  = None
713         jdcText = ""
714       
715         titre  = ""
716         
717         if unite :
718             titre = "Choix unite %d " %unite
719             texte = "Le fichier %s contient une commande INCLUDE \n" % fic_origine
720             texte = texte+'Donnez le nom du fichier correspondant\n à l unité logique %d' % unite
721             labeltexte = 'Fichier pour unite %d :' % unite
722         else:
723             titre = "Choix d'un fichier de poursuite"
724             texte = "Le fichier %s contient une commande %s\n" %(fic_origine,'POURSUITE')
725             texte = texte+'Donnez le nom du fichier dont vous \n voulez faire une poursuite'
726                                         
727         QMessageBox.information( self, titre,QString.fromUtf8(texte))
728         fn = QFileDialog.getOpenFileName(self.appliEficas,
729                    titre,
730                    self.appliEficas.CONFIGURATION.savedir)
731         
732         if fn.isNull(): 
733         # ce retour est impose par le get_file d'I_JDC
734            return None," "
735             
736         ulfile = os.path.abspath(unicode(fn))
737         self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
738        
739         # On utilise le convertisseur défini par format_fichier
740         source=self.get_source(ulfile)
741         if source:
742             # On a réussi à convertir le fichier self.ulfile                
743             jdcText = source
744         else:
745             # Une erreur a été rencontrée
746             jdcText = ''
747         return ulfile, jdcText
748
749         
750 if __name__=='__main__':    
751     import prefs # dans main
752     name='prefs_'+prefs.code
753     prefsCode=__import__(name)
754
755     if hasattr(prefsCode,'encoding'):
756        # Hack pour changer le codage par defaut des strings
757        import sys
758        reload(sys)
759        sys.setdefaultencoding(prefs.encoding)
760        del sys.setdefaultencoding
761        # Fin hack
762
763 #    #CS_pbruno note: fait implicitement des trucs ces imports (grr)
764 #    import styles
765 #    import import_code
766 #    import session
767 #
768 #    # Analyse des arguments de la ligne de commande
769 #    options=session.parse(sys.argv)
770 #    code=options.code
771 #        
772     app = QApplication(sys.argv)    
773     mw = JDCEditor(None,'azAster.comm')
774     app.setMainWidget(mw)
775     app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
776     mw.show()
777             
778     res = app.exec_loop()
779     sys.exit(res)