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)