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