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