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