InterfaceQT4/editorSsIhm.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
  34 import traceback
  35
  36 # Modules Eficas
  37
  38 import convert, generator
  39 from Editeur        import session
  40 from Editeur        import comploader
  41 from Editeur        import Objecttreeitem
  42
  43 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
  44 debug = False
  45
  46
  47
  48 class JDCEditorSsIhm :
  49 # ------------------- #
  50     """
  51        Editeur de jdc
  52     """
  53
  54 # ---------------------------------------------
  55 # Methodes Communes ou appelees depuis avec Ihm
  56 # ---------------------------------------------
  57
  58     def __init__ (self,appli,fichier = None, jdc = None,  units = None, include=0 ):
  59     #------------------------------------------------------------------------------#
  60     # paticularisee avec Ihm
  61
  62         if debug : print ('dans le init de JDCEditorSsIhm')
  63         self.appliEficas = appli
  64         self.appli       = appli
  65         self.fichier     = fichier
  66         self.fichierComplet  = fichier
  67         self.jdc         = jdc
  68         self.first       = True
  69         self.jdc_item    = None
  70         self.dicoNouveauxMC   = {}
  71         self.dicoNouveauxFact = {}
  72         self.dict_reels       = {}
  73         self.liste_simp_reel  = []
  74
  75         if appli != None : self.salome =  self.appliEficas.salome
  76         else             : self.salome =  0
  77
  78         # ces attributs sont mis a jour par definitCode appelee par newEditor
  79         self.code              = self.appliEficas.maConfiguration.code
  80         self.maConfiguration   = self.appliEficas.maConfiguration
  81
  82         self.version_code = session.d_env.cata
  83
  84
  85         if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.readercata.demandeCatalogue==True or self.appliEficas.multi==True:
  86            if self.maConfiguration.typeDeCata == 'XML' :
  87               from InterfaceQT4   import readercataXML as readercata
  88            else :
  89               from InterfaceQT4   import readercata
  90            self.readercata  = readercata.ReaderCata( self, self.appliEficas )
  91            self.appliEficas.readercata=self.readercata
  92            self.appliEficas.code=self.code
  93         else :
  94            self.readercata=self.appliEficas.readercata
  95         if self.readercata.fic_cata == None : return    #Sortie Salome
  96         self.titre=self.readercata.titre
  97
  98         self.format =  self.appliEficas.format_fichier
  99
 100         if self.appliEficas.maConfiguration.dumpXSD==True : self.appliEficas.dumpXsd()
 101         self.dict_reels={}
 102         self.liste_simp_reel=[]
 103         self.dicoNouveauxMC={}
 104         self.dicoNouveauxFact={}
 105
 106
 107         try:
 108           self.maConfiguration.generator_module
 109           _module = __import__(self.maConfiguration.generator_module)
 110           info    = _module.entryPoint()
 111           generator.plugins.addEntryPoint(info)
 112         except:
 113           pass
 114
 115         try:
 116           self.maConfiguration.convert_module
 117           #print self.maConfiguration.convert_module
 118           _module = __import__(self.maConfiguration.convert_module)
 119           info = _module.entryPoint()
 120           convert.plugins.addEntryPoint(info)
 121         except :
 122           pass
 123
 124         self.maConfiguration.mesGenerators     = generator
 125         self.maConfiguration.mesconvertisseurs = convert
 126
 127         self.fileInfo       = None
 128         self.lastModified   = 0
 129
 130         self.modified   = False
 131         self.isReadOnly = False
 132
 133         #------- construction du jdc --------------
 134
 135
 136         self.nouveau=0
 137         if self.fichier is not None:        #  fichier jdc fourni
 138             if jdc==None :
 139                #print ('PNPN : chgt try en if')
 140                try :
 141                #if 1 :
 142                    self.jdc = self.readFile(self.fichier)
 143                except :
 144                    print ("mauvaise lecture du fichier")
 145                if self.salome :
 146                   try :
 147                      self.appliEficas.addJdcInSalome( self.fichier)
 148                   except :
 149                      print ("mauvais enregistrement dans Salome")
 150             else :
 151                self.jdc=jdc
 152
 153             if self.jdc is not None and units is not None:
 154                self.jdc.recorded_units=units
 155                self.jdc.old_recorded_units=units
 156
 157         else:
 158             if not self.jdc:                   #  nouveau jdc
 159                 if not include :
 160                    self.jdc = self._newJDC(units=units)
 161                 else :
 162                    self.jdc = self._newJDCInclude(units=units)
 163                 self.nouveau=1
 164
 165         if self.jdc:
 166             self.jdc.appli = self # a resorber
 167             self.jdc.editor = self
 168             self.jdc.lang    = self.appli.langue
 169             self.jdc.aReafficher=False
 170             txt_exception  = None
 171             if not jdc:
 172                 self.jdc.analyse()
 173                 txt_exception = self.jdc.cr.getMessException()
 174             if txt_exception :
 175                 self.jdc = None
 176                 self.informe('pb chargement jdc',txt_exception)
 177             else:
 178                 comploader.chargerComposants()
 179                 self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
 180
 181     #-------------------------------#
 182     def readFile(self, fn):
 183     #--------------------------------#
 184         """
 185         Public slot to read the text from a file.
 186         @param fn filename to read from (string or QString)
 187         """
 188
 189         # charge un JDC
 190         # paticularisee avec Ihm
 191
 192         fn = six.text_type(fn)
 193         jdcName=os.path.basename(fn)
 194
 195         # Il faut convertir le contenu du fichier en fonction du format
 196         if self.appliEficas.format_fichier_in in convert.plugins:
 197              # Le convertisseur existe on l'utilise
 198
 199              p=convert.plugins[self.appliEficas.format_fichier_in]()
 200              p.readfile(fn)
 201
 202              if p.text=="" : self.nouveau=1
 203              #print ('PNPN --> CIST a faire')
 204
 205              pareil,texteNew=self.verifieChecksum(p.text)
 206              if  not pareil :
 207                 self.informe(("fichier modifie"),("Attention! fichier change hors EFICAS"),False)
 208
 209              p.text=texteNew
 210              memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
 211              if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
 212              p.text=texteNew
 213
 214              text=p.convert('exec',self.appliEficas)
 215
 216              if not p.cr.estvide(): self.afficheInfos("Erreur a la conversion",'red')
 217         else :
 218             self.afficheInfos("Type de fichier non reconnu",'red')
 219             self.informe( "Type de fichier non reconnu",
 220                     "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
 221             return None
 222
 223         CONTEXT.unsetCurrentStep()
 224
 225         #jdc=self.readercata.cata[0].JdC(procedure=text,
 226         jdc=self.readercata.cata.JdC(procedure=text,
 227                                     appli=self,
 228                                     cata=self.readercata.cata,
 229                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
 230                                     nom=jdcName,
 231                                     rep_mat=self.maConfiguration.rep_mat
 232                                    )
 233         self.modified = False
 234         return jdc
 235
 236
 237     #--------------------------------#
 238     def _newJDC( self ,units = None):
 239     #--------------------------------#
 240         """
 241         Initialise un nouveau JDC vierge
 242         """
 243         self.modified=1
 244         CONTEXT.unsetCurrentStep()
 245
 246         texte=""
 247         if self.code == "CARMELCND" : texte=self._newJDCCND()
 248         if self.code == "ZCRACKS" : texte=self._newZCRACKS()
 249         if self.code == "PSEN"    : texte = self._newPSEN()
 250         if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
 251
 252         #if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
 253         if hasattr(self.readercata.cata,'TEXTE_NEW_JDC') : texte=self.readercata.cata.TEXTE_NEW_JDC
 254
 255
 256         #jdc=self.readercata.cata[0].JdC( procedure =texte,
 257         #print (self.readercata.cata)
 258         jdc=self.readercata.cata.JdC( procedure =texte,
 259                                          appli=self,
 260                                          cata=self.readercata.cata,
 261                                          cata_ord_dico=self.readercata.cata_ordonne_dico,
 262                                          rep_mat=self.maConfiguration.rep_mat
 263                                         )
 264
 265         jdc.lang    = self.appli.langue
 266         if units is not None:
 267            jdc.recorded_units=units
 268            jdc.old_recorded_units=units
 269         ## PNPN est ce que la ligne suivante est bien utile ?
 270         # elle positionne le contexte
 271         # est ce qu on ne doit pas changer le format en Accas si on vient d accas ?
 272         if self.format == 'xml' : return jdc
 273         if texte == "" :
 274            jdc.editor=self
 275            jdc.analyse()
 276         return jdc
 277
 278    #--------------------------------#
 279     def _newJDCInclude( self ,units = None):
 280     #--------------------------------#
 281         """
 282         Initialise un nouveau JDC vierge
 283         """
 284         import Extensions.jdc_include
 285         JdC_aux=Extensions.jdc_include.JdC_include
 286         CONTEXT.unsetCurrentStep()
 287
 288         #jaux=self.readercata.cata[0].JdC( procedure="",
 289         jaux=self.readercata.cata.JdC( procedure="",
 290                                appli=self,
 291                                cata=self.readercata.cata,
 292                                cata_ord_dico=self.readercata.cata_ordonne_dico,
 293                                rep_mat=self.maConfiguration.rep_mat,
 294                               )
 295         jaux.analyse()
 296
 297         J=JdC_aux( procedure="",
 298                    appli=self,
 299                    cata=self.readercata.cata,
 300                    cata_ord_dico=self.readercata.cata_ordonne_dico,
 301                    jdc_pere=jaux,
 302                    rep_mat=self.maConfiguration.rep_mat,
 303                    )
 304         J.analyse()
 305         if units is not None:
 306            J.recorded_units=units
 307            J.old_recorded_units=units
 308         return J
 309
 310
 311
 312     #-----------------------#
 313     def getSource(self,file):
 314     #-----------------------#
 315
 316         # Il faut convertir le contenu du fichier en fonction du format
 317         if self.format in convert.plugins :
 318             # Le convertisseur existe on l'utilise
 319             p=convert.plugins[self.format]()
 320             p.readfile(file)
 321             text=p.convert('execnoparseur')
 322             if not p.cr.estvide():
 323                 self.afficheInfos("Erreur a la conversion",'red')
 324             return text
 325         else:
 326             # Il n'existe pas c'est une erreur
 327             self.afficheInfos("Type de fichier non reconnu",'red')
 328             self.informe( "Type de fichier non reconnu",
 329                     "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
 330             return None
 331
 332     #----------------------------------------------#
 333     def __generateTempFilename(self, prefix, suffix):
 334     #----------------------------------------------#
 335         import tempfile
 336         (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
 337         os.close(fd)
 338         return filename
 339
 340     #-----------------------#
 341     def generDico(self):
 342     #-----------------------#
 343        if 'dico' in generator.plugins:
 344          self.generator=generator.plugins['dico']()
 345          #print (self.generator)
 346          jdc_formate=self.generator.gener(self.jdc)
 347          #print (jdc_formate)
 348          dico=self.generator.Dico
 349          #print (dico)
 350          return dico
 351
 352     #-----------------------#
 353     def viewJdcSource(self):
 354     #-----------------------#
 355         if self.fichier == None : return
 356         f=open(self.fichier,'r')
 357         texteSource=f.read()
 358         f.close()
 359         self._viewText(texteSource, "JDC_SOURCE")
 360
 361     #-----------------------#
 362     def viewJdcPy(self):
 363     #-----------------------#
 364         strSource = str( self.getTextJDC(self.format) )
 365         self._viewText(strSource, "JDC_RESULTAT")
 366
 367     #-----------------------#
 368     def viewJdcRapport(self):
 369     #-----------------------#
 370         # on ajoute les regles
 371         strRapport = six.text_type( self.jdc.report() )
 372         self._viewText(strRapport, "JDC_RAPPORT")
 373
 374     #-----------------------#
 375     def viewJdcRegles(self):
 376     #-----------------------#
 377         # on ajoute les regles
 378         texte_global, test_global =  self.jdc.verifRegles()
 379         self._viewText(texte_global, "JDC_REGLES")
 380
 381     #-----------------------#
 382     def getJdcRapport(self):
 383     #-----------------------#
 384         # on ajoute les regles
 385         strRapport = six.text_type( self.jdc.report() )
 386         return strRapport
 387
 388     #---------------------#
 389     def getFileName(self):
 390     #---------------------#
 391       return self.fichier
 392
 393     #-------------------#
 394     def initModif(self):
 395     #-------------------#
 396       """
 397           Met l'attribut modified a 'o' : utilise par Eficas pour savoir
 398           si un JDC doit etre sauvegarde avant destruction ou non
 399       """
 400       self.modified = True
 401
 402
 403     #--------------------------------------------------#
 404     def writeFile(self, fn, txt = None,formatLigne="beautifie"):
 405     #--------------------------------------------------#
 406         """
 407         Public slot to write the text to a file.
 408
 409         @param fn filename to write to string
 410         @return flag indicating success
 411         """
 412
 413         fn = six.text_type(fn)
 414
 415         if txt == None :
 416             txt = self.getTextJDC(self.format,formatLigne=formatLigne)
 417             eol = '\n'
 418             if len(txt) >= len(eol):
 419                if txt[-len(eol):] != eol:
 420                   txt += eol
 421             else:
 422                 txt += eol
 423             txt=self.ajoutVersionCataDsJDC(txt)
 424             if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
 425             else : checksum=''
 426             txt=txt+checksum
 427         if self.code=="TELEMAC" : return 1
 428         try:
 429             f = open(fn, 'w')
 430             f.write(txt)
 431             f.close()
 432             return 1
 433         except IOError as why:
 434             self.afficheInfos('Sauvegarde du Fichier', 'Le fichier'+str(fn) + 'n a pas pu etre sauvegarde :'  + str(why))
 435             return 0
 436
 437     #-----------------------------------------------------------#
 438     def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
 439     #-----------------------------------------------------------#
 440       if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
 441       if format in generator.plugins:
 442
 443          # Le generateur existe on l'utilise
 444          self.generator=generator.plugins[format]()
 445          try :
 446             jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
 447             if pourRun : jdc_formate=self.generator.textePourRun
 448             if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
 449          except ValueError as e:
 450             self.informe( "Erreur a la generation",str(e),'red')
 451             return
 452
 453          if not self.generator.cr.estvide():
 454             self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
 455             return ""
 456          else:
 457             return jdc_formate
 458       else:
 459          # Il n'existe pas c'est une erreur
 460          self.informe("Format inconnu", self.format +  " non reconnu" )
 461          return ""
 462
 463     #------------------------------#
 464     def verifieChecksum(self,text):
 465     #------------------------------#
 466     # Attention : souci sous Windows
 467     #
 468         indexDeb=text.find("#CHECKSUM:")
 469         if indexDeb < 0 : return 1, text
 470         indexFin=text.find(":FIN CHECKSUM")
 471         checkAvant=text[indexDeb:indexFin+13]
 472         textJDC=text[0:indexDeb]+text[indexFin+13:-1]
 473         if self.code != 'PSEN'  and self.code != 'PSEN_N1':
 474            checksum=self.getChecksum(textJDC)
 475            pareil=(checkAvant==checksum)
 476         else :
 477            pareil=1
 478         return pareil, textJDC
 479
 480     #---------------------------#
 481     def getChecksum(self,texte):
 482     #---------------------------#
 483         try :
 484            import haslib
 485            newtexte=texte.replace('"','\\"')
 486            hash_checksum = hashlib.md5()
 487            hash_checksum.update(newtexte.encode('utf-8'))
 488            checksum = hash_checksum.hexdigest()
 489            ligne = "#CHECKSUM:"+checksum+":FIN CHECKSUM"
 490         except :
 491            try :
 492               newtexte=texte.replace('"','\\"')
 493               commande='echo "'+newtexte+'"|md5sum'
 494               a=os.popen(commande)
 495               checksum=a.read()
 496               a.close()
 497            except :
 498               checksum='Fichier trop long \n'
 499            ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
 500            return ligne
 501
 502     #----------------------#
 503     def getDico(self):
 504     #---------------------#
 505       if 'dicoImbrique' in generator.plugins:
 506          self.generator=generator.plugins['dicoImbrique']()
 507          #print (self.generator)
 508          jdc_formate=self.generator.gener(self.jdc)
 509          dico=self.generator.Dico
 510          return dico
 511       else :
 512          self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
 513          return ""
 514
 515    #-----------------------------------------#
 516     def chercheGroupes(self):
 517     #-----------------------------------------#
 518         listeMA,listeNO=self.getTextJDC("GroupMA")
 519         return listeMA,listeNO
 520
 521     #-----------------------------------------#
 522     def chercheDico(self):
 523     #-----------------------------------------#
 524         dicoCourant={}
 525         format =  self.appliEficas.format_fichier
 526         if format in generator.plugins:
 527            # Le generateur existe on l'utilise
 528            self.generator=generator.plugins[format]()
 529            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
 530            dicoCourant=self.generator.dico
 531         return dicoCourant
 532
 533     #-----------------------------------------------------------------#
 534     def saveFileLegerAs(self, fileName = None) :
 535     #-----------------------------------------------------------------#
 536         if fileName != None :
 537            self.fichier = fileName
 538            return self.saveFileLeger(fileName)
 539         return self.saveFileLeger()
 540
 541     #-----------------------------------------------------------------#
 542     def saveFileComplet(self, fichier = None, formatLigne="beautifie"):
 543     #-----------------------------------------------------------------#
 544         fn = fichier
 545         self.generator=generator.plugins[self.format]()
 546         print (self.generator)
 547         if hasattr(self.generator, "writeComplet"):
 548             self.generator.writeComplet(fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
 549
 550
 551 # ---------------------------------------------
 552 # Methodes Surchargees par avecIhm
 553 # ---------------------------------------------
 554
 555     #--------------------------------#
 556     def ajoutCommentaire(self):
 557     #--------------------------------#
 558       print ('pas programme sans Ihm')
 559       print ('prevenir la maintenance du besoin')
 560
 561
 562     #--------------------------------------#
 563     def informe(self,titre,txt,critique=True):
 564     #--------------------------------------#
 565     # methode differenre avec et sans ihm
 566       if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
 567       print (titre)
 568       print (txt)
 569       if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
 570
 571     #--------------------------------------#
 572     def afficheInfos(self,txt,couleur=None):
 573     #--------------------------------------#
 574     # methode differenre avec et sans ihm
 575       print (txt)
 576
 577     #-----------------------------------------------------------------------#
 578     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
 579     #--------------------------------------------------------------------#
 580         print ('_____________________________')
 581         print (txt)
 582         print ('_____________________________')
 583
 584
 585     #-----------------------------------------------------------------#
 586     def saveFile(self, fichier, formatLigne="beautifie"):
 587     #-----------------------------------------------------------------#
 588         """
 589         Public slot to save the text to a file.
 590
 591         @param path directory to save the file in (string or QString)
 592         @return tuple of two values (boolean, string) giving a success indicator and
 593             the name of the saved file
 594         """
 595
 596
 597         if not (self.writeFile(fichier,formatLigne=formatLigne)): return (0, None)
 598         self.fichierOut = fichier
 599
 600         if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
 601             self.generator.writeDefault(fichier)
 602         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
 603             self.generator.writeDefault(fichier)
 604
 605         self.modified = 0
 606
 607         return (1, self.fichier)
 608 #
 609
 610     #----------------------------------------------#
 611     def sauveLigneFile(self):
 612     #----------------------------------------------#
 613         self.modified=1
 614         return self.saveFile(formatLigne="Ligne")
 615
 616
 617     #-----------------------------------#
 618     def updateJdc(self, itemApres,texte):
 619     #------------------------------------#
 620     # ajoute une etape  de JdC a partir d un texte
 621         monItem=itemApres
 622         etape=monItem.item.object
 623         CONTEXT.setCurrentStep(etape)
 624         etape.buildIncludeInclude(texte)
 625         self.tree.racine.buildChildren()
 626
 627     #-----------------------------------#
 628     def updateJdcEtape(self, itemApres,texte):
 629     #------------------------------------#
 630     # ajoute une etape  de JdC a partir d un texte
 631         monItem=itemApres
 632         etape=monItem.item.object
 633         CONTEXT.set_current_step(etape)
 634         try :
 635           ok=etape.build_includeEtape(texte)
 636         except :
 637           ok=0
 638         if not ok :
 639            QMessageBox.information( self,
 640                       tr("Import texte"),
 641                       tr("Impossible d importer le texte"))
 642         self.tree.racine.build_children()
 643         return ok
 644
 645
 646
 647     #-------------------------------------#
 648     def deleteEtape(self,etape):
 649     #-------------------------------------#
 650     # dans le JDC
 651         self.jdc.suppentite(etape)
 652
 653     #-------------------------------------#
 654     def deleteMC(self,etape,MCFils,listeAvant=()):
 655     #-------------------------------------#
 656     # dans le JDC
 657         ouChercher=etape
 658         for mot in listeAvant :
 659               ouChercher=ouChercher.getChild(mot,restreint="oui")
 660         monMC=ouChercher.getChild(MCFils,restreint="oui")
 661         if monMC != None :  ouChercher.suppentite(monMC)
 662         ouChercher.state='changed'
 663         ouChercher.isvalid()
 664
 665     #--------------------------------------------------------#
 666     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
 667     #--------------------------------------------------------#
 668     # dans le JDC
 669         debug=False
 670         if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
 671         ouChercher=etape
 672         if debug : print (ouChercher)
 673         for mot in listeAvant :
 674            ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
 675         monMC=ouChercher.getChild(MCFils,restreint="oui")
 676         if monMC == None : monMC = ouChercher.addEntite(MCFils)
 677         monMC.valeur=valeurs
 678         monMC.val=valeurs
 679         monMC.state='changed'
 680         monMC.isvalid()
 681         return 1
 682
 683     #--------------------------------------------------------#
 684     def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
 685     # Attention si +sieursMCFACT
 686     #--------------------------------------------------------#
 687     # dans le JDC
 688         debug=False
 689         if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
 690         ouChercher=etape
 691         if debug : print (ouChercher)
 692         for mot in listeAvant :
 693            ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
 694         # Attention si +sieursMCFACT
 695         ouChercher=ouChercher[0]
 696         if debug : print (ouChercher)
 697         monMC=ouChercher.getChild(MCFils,restreint="oui")
 698         if monMC == None : monMC = ouChercher.addEntite(MCFils)
 699         monMC.valeur=valeurs
 700         monMC.val=valeurs
 701         monMC.state='changed'
 702         monMC.isValid()
 703         return 1
 704
 705     #----------------------------------------------#
 706     def ajoutMCFact(self,etape,MCFils,listeAvant=()):
 707     #----------------------------------------------#
 708     # dans le JDC
 709         ouChercher=etape
 710         for mot in listeAvant :
 711               ouChercher=ouChercher.getChild(mot,restreint="oui")
 712         monMC=etape.getChild(ouChercher,restreint="oui")
 713         if monMC== None : monMC= ouChercher.addEntite(MCFils)
 714         monMC.isvalid()
 715
 716     #-----------------------------------------------------------------#
 717     def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
 718     #-----------------------------------------------------------------#
 719     # pour VP
 720         monObj=etape
 721         for mot in listeAvant :
 722               monObj=monObj.getChild(mot,restreint="oui")
 723               if monObj==None : return False
 724         if monObj == None : return False
 725         if monObj.valeur != valeur :
 726            # PNPN le setValeur fait des bugs --> pourquoi
 727            #monObj.setValeur(valeur)
 728            monObj.valeur=valeur
 729            monObj.isValid()
 730         return True
 731
 732     #-------------------------------------------------#
 733     def getValeur(self,nomEtape,MCFils,listeAvant=()):
 734     #-------------------------------------------------#
 735     # dans le JDC
 736
 737         debug=0
 738         ouChercher=None
 739         for e in self.jdc.etapes:
 740             if e.nom == nomEtape : ouChercher=e; break
 741         if debug : print ('etape trouvee', ouChercher)
 742         if ouChercher==None : return None
 743         for mot in listeAvant :
 744               ouChercher=ouChercher.getChild(mot,restreint="oui")
 745               if debug : print (mot, ouChercher)
 746               if ouChercher==None : return None
 747         monMC=ouChercher.getChild(MCFils,restreint="oui")
 748         if debug : print ('monMC', monMC)
 749         if monMC== None : return None
 750         return monMC.valeur
 751
 752     #-------------------------------------------------#
 753     def getMCDsEtape(self,etape,MCFils,listeAvant=()):
 754     #-------------------------------------------------#
 755     # dans le JDC
 756
 757         if etape==None : return None
 758         ouChercher=etape
 759         debug=0
 760         for mot in listeAvant :
 761               ouChercher=ouChercher.getChild(mot,restreint="oui")
 762               if debug : print (mot, ouChercher)
 763               if ouChercher==None : return None
 764         monMC=ouChercher.getChild(MCFils,restreint="oui")
 765         if debug : print ('monMC', monMC)
 766         return monMC
 767
 768     #-----------------------------------------------------------#
 769     def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
 770     #--------------------------------------------------------#
 771     # dans le JDC
 772
 773         ouChercher=None
 774         for e in self.jdc.etapes:
 775             if e.nom == nomEtape : ouChercher=e; break
 776         if ouChercher==None : return None
 777         for mot in listeAvant :
 778               ouChercher=ouChercher.getChild(mot,restreint="oui")
 779               #print (mot, ouChercher)
 780               if ouChercher==None : return None
 781         monMC=ouChercher.getChild(MCFils,restreint="oui")
 782         monMC.set_valeur(valeur)
 783         monMC.isvalid()
 784
 785     #-----------------------------------------------------------#
 786     def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
 787     #-----------------------------------------------------------#
 788     # dans le JDC
 789         ouChercher=etape
 790         if isinstance (etape, str):
 791            ouChercher=None
 792            for e in self.jdc.etapes:
 793               if e.nom == etape : ouChercher=e; break
 794         if ouChercher==None : return
 795
 796         for mot in listeAvant :
 797               ouChercher=ouChercher.getChild(mot,restreint="oui")
 798               if ouChercher==None : return
 799         monMC=ouChercher.getChild(MCFils,restreint="oui")
 800         if monMC== None : monMC= ouChercher.addEntite(MCFils)
 801
 802         monMC.definition.into=valeurs
 803         from Noyau.N_VALIDATOR import  IntoProtocol
 804         monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
 805         monMC.state='changed'
 806         monMC.isvalid()
 807
 808     #-------------------------------------------------------------------#
 809     def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
 810     #-------------------------------------------------------------------#
 811     # dans le JDC
 812         for e in self.jdc.etapes:
 813             if e.nom == nomEtape : ouChercher=e; break
 814
 815         for mot in listeAvant :
 816             try :
 817               ouChercher=ouChercher.getChild(mot,restreint="oui")
 818             # Le mot clef n est pas la
 819             except : return 0
 820         try :
 821            monMC=ouChercher.getChild(MCFils,restreint="oui")
 822         # Le mot clef n est pas la
 823         except : return 0
 824         if monMC == None : return 0
 825
 826         if hasattr(monMC.definition,'into') :
 827            if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
 828            else : maListeDeValeur=monMC.definition.into
 829         else :
 830            return 0
 831
 832         monMC.state='changed'
 833         return 1
 834
 835     #-------------------------------------#
 836     def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
 837     #-------------------------------------#
 838     # dans le MDD
 839
 840         #if isinstance (etape, str):
 841         #  for e in self.jdc.etapes:
 842         #    if e.nom == etape : etape=e; break
 843         #if etape == None : return
 844         definitionEtape=getattr(self.jdc.cata,nomEtape)
 845         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 846         ouChercher=definitionEtape
 847         if len(listeMC) > 1 :
 848
 849            for mc in listeMC[0:-1]:
 850              mcfact=ouChercher.entites[mc]
 851              ouChercher=mcfact
 852
 853         mcAccas=ouChercher.entites[listeMC[-1]]
 854         mcAccas.defaut=valeurs
 855         return 1
 856
 857     #------------------------------------------------#
 858     def changeIntoDefMC(self,etape,listeMC,valeurs):
 859     #------------------------------------------------#
 860     # dans le MDD
 861         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 862         #definitionEtape=getattr(self.jdc.cata,nomEtape)
 863         print ( 'changeIntoDefMC ',etape,listeMC,valeurs)
 864         ouChercher=getattr(self.jdc.cata,etape.nom)
 865
 866         #if len(listeMC) > 1 :
 867         #   for mc in listeMC[0:-1]:
 868         #     mcfact=ouChercher.entites[mc]
 869         #     ouChercher=mcfact
 870         #mcAccas=ouChercher.entites[listeMC[-1]]
 871
 872         for mc in listeMC :
 873             mcAccas=ouChercher.entites[mc]
 874             ouChercher=mcAccas
 875             if ouChercher == None : return 0
 876
 877         if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
 878         else : oldValeurs=None
 879
 880         if oldValeurs==valeurs : return 1
 881         mcAccas.into=valeurs
 882         from Noyau.N_VALIDATOR import  IntoProtocol
 883         mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
 884         return 1
 885
 886     #-------------------------------------------------------------#
 887     def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
 888     #-------------------------------------------------------------#
 889     # dans le MDD
 890         #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
 891         if isinstance (etape, str):
 892           for e in self.jdc.etapes:
 893             if e.nom == etape : etape=e; break
 894         if etape == None : return
 895         #definitionEtape=getattr(self.jdc.cata[0],etape)
 896         definitionEtape=getattr(self.jdc.cata,etape)
 897         ouChercher=definitionEtape
 898         for k in listeAvant :
 899             ouChercher=ouChercher.entites[k]
 900         MCADetruire=ouChercher.entites[nomDuMC]
 901         ouChercher.ordre_mc.remove(nomDuMC)
 902         print ('remove de ', nomDuMC)
 903         del ouChercher.entites[nomDuMC]
 904         del self.dicoNouveauxMC[nomDuMC]
 905
 906
 907     #-------------------------------------------------------------#
 908     def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
 909     #-------------------------------------------------------------#
 910     # dans le MDD
 911         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 912         definitionEtape=getattr(self.jdc.cata,nomEtape)
 913         ouChercher=definitionEtape
 914         for k in listeAvant :
 915             ouChercher=ouChercher.entites[k]
 916         from Accas import A_SIMP
 917         Nouveau=A_SIMP.SIMP(typ,**args)
 918         Nouveau.pere=ouChercher
 919         Nouveau.nom=nomDuMC
 920         #Nouveau.ordre_mc=[]
 921         ouChercher.entites[nomDuMC]=Nouveau
 922         ouChercher.ordre_mc.append(nomDuMC)
 923         #print ('ajout de ', nomDuMC)
 924         #traceback.print_stack()
 925         # ajout CIST sauvegarde
 926         if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
 927         self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
 928         #print self.dicoNouveauxMC
 929
 930     #---------------------------------------------------------------------#
 931     def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
 932     #---------------------------------------------------------------------#
 933     # dans le MDD
 934         print ('ajoutDefinitionMCFact', nomDuMC)
 935         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 936         definitionEtape=getattr(self.jdc.cata,nomEtape)
 937         ouChercher=definitionEtape
 938         for k in listeAvant :
 939             ouChercher=ouChercher.entites[k]
 940         from Accas import A_SIMP
 941         for mc in listeMC :
 942             nomMC=mc[0]
 943             typMC=mc[1]
 944             argsMC=mc[2]
 945             nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
 946             nouveauMC.nom=nomMC
 947             args[nomMC]=nouveauMC
 948         from Accas import A_FACT
 949         nouveauFact=A_FACT.FACT(**args)
 950         nouveauFact.pere=ouChercher
 951         nouveauFact.nom=nomDuMC
 952         from Editeur.autre_analyse_cata import traite_entite
 953         traite_entite(nouveauFact,[])
 954         ouChercher.entites[nomDuMC]=nouveauFact
 955         ouChercher.ordre_mc.append(nomDuMC)
 956         self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
 957         #print self.dicoNouveauxMC
 958
 959     #----------------------------------------------------#
 960
 961     #----------------------------------------------------#
 962     def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
 963     #----------------------------------------------------#
 964     # dans le MDD et le JDC
 965
 966         self.changeIntoDefMC(etape,listeMC,into)
 967
 968         if isinstance (etape, str):
 969           for e in self.jdc.etapes:
 970             if e.nom == etape : etape=e; break
 971         if etape == None : return
 972
 973         ouChercher = etape
 974         for mot in listeMC[:-1] :
 975             ouChercher=ouChercher.getChild(mot,restreint="oui")
 976             if ouChercher==None : return
 977         MCFils=listeMC[-1]
 978         monMC=ouChercher.getChild(MCFils,restreint="oui")
 979         if monMC== None : monMC= etape.addEntite(MCFils)
 980
 981         monMC.definition.into=into
 982         monMC.valeur=valeurs
 983         monMC.val=valeurs
 984         monMC.state='changed'
 985         monMC.isvalid()
 986
 987     #-------------------------------------#
 988     def ajoutVersionCataDsJDC(self,txt):
 989     #-------------------------------------#
 990         #if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
 991         if not hasattr(self.readercata.cata,'VERSION_CATALOGUE'): return txt
 992         ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata.VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
 993         texte=txt+ligneVersion
 994         return texte
 995
 996     #-------------------------------------#
 997     def verifieVersionCataDuJDC(self,text):
 998     #-------------------------------------#
 999         memeVersion=False
1000         indexDeb=text.find("#VERSION_CATALOGUE:")
1001         indexFin=text.find(":FIN VERSION_CATALOGUE")
1002         if indexDeb < 0 :
1003            self.versionCataDuJDC="sans"
1004            textJDC=text
1005         else :
1006            self.versionCataDuJDC=text[indexDeb+19:indexFin]
1007            textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1008
1009         self.versionCata="sans"
1010         if hasattr(self.readercata.cata,'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata.VERSION_CATALOGUE
1011
1012         if self.versionCata==self.versionCataDuJDC : memeVersion=True
1013         return memeVersion,textJDC
1014
1015     #-------------------------------#
1016     def traduitCatalogue(self,texte):
1017     #-------------------------------#
1018         nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1019         sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1020         try :
1021             traducteur=__import__(nomTraducteur)
1022             monTraducteur=traducteur.MonTraducteur(texte)
1023             nouveauTexte=monTraducteur.traduit()
1024             return nouveauTexte
1025         except :
1026             return texte
1027
1028
1029 # Methodes a resorber
1030 # il faut mettre a jour les catalogues avec
1031 # TEXTE_NEW_JDC
1032 #
1033
1034     #---------------------------#
1035     def _new_CF(self):
1036     #---------------------------#
1037         texte="CONDUITE_FORCEE();"
1038         return texte
1039
1040     #---------------------------#
1041     def _newPSEN(self):
1042     #---------------------------#
1043         texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1044         #texte=""
1045         return texte
1046
1047     #---------------------------#
1048     def _newPSEN_N1(self):
1049     #---------------------------#
1050         texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1051         #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1052         return texte
1053
1054     #---------------------------#
1055     def _newZCRACKS(self):
1056     #---------------------------#
1057         texte="MAILLAGES();REMESHING();"
1058         return texte
1059
1060
1061     #---------------------------#
1062     def _newJDCCND(self):
1063     #---------------------------#
1064       extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1065
1066       #if self.salome == 0 :
1067       QMessageBox.information( self,
1068                       tr("Fichier Med"),
1069                       tr("Veuillez selectionner un fichier Med"))
1070       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1071                         caption='Fichier Med',
1072                         filter=extensions)
1073       QSfichier=QSfichier[0]
1074       self.fichierMED=QSfichier
1075       from acquiertGroupes import getGroupes
1076       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1077       if erreur != "" : print ("a traiter")
1078       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1079       texteSources=""
1080       texteCond=""
1081       texteNoCond=""
1082       texteVcut=""
1083       texteZs=""
1084       for groupe in self.listeGroupes :
1085           if groupe[0:8]=='CURRENT_':
1086              texteSources +=groupe[8:]+"=SOURCE("
1087              texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1088           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
1089           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
1090           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
1091           if groupe[0:3]=='ZS_':      texteZs      +=groupe[3:]+"=ZS();\n"
1092       texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1093       self.newTexteCND=texte
1094       self.modified=1
1095       return texte
1096
1097
1098 if __name__ == "__main__":
1099    print ('a faire')