InterfaceQT4/editor.py

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