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