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