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            newtexte=texte.replace('"','\\"')
 485            commande='echo "'+newtexte+'"|md5sum'
 486            a=os.popen(commande)
 487            checksum=a.read()
 488            a.close()
 489         except :
 490            checksum='Fichier trop long \n'
 491         ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
 492         return ligne
 493
 494     #----------------------#
 495     def getDico(self):
 496     #---------------------#
 497       if 'dicoImbrique' in generator.plugins:
 498          self.generator=generator.plugins['dicoImbrique']()
 499          #print (self.generator)
 500          jdc_formate=self.generator.gener(self.jdc)
 501          dico=self.generator.Dico
 502          return dico
 503       else :
 504          self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
 505          return ""
 506
 507    #-----------------------------------------#
 508     def chercheGroupes(self):
 509     #-----------------------------------------#
 510         listeMA,listeNO=self.getTextJDC("GroupMA")
 511         return listeMA,listeNO
 512
 513     #-----------------------------------------#
 514     def chercheDico(self):
 515     #-----------------------------------------#
 516         dicoCourant={}
 517         format =  self.appliEficas.format_fichier
 518         if format in generator.plugins:
 519            # Le generateur existe on l'utilise
 520            self.generator=generator.plugins[format]()
 521            jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
 522            dicoCourant=self.generator.dico
 523         return dicoCourant
 524
 525     #-----------------------------------------------------------------#
 526     def saveFileLegerAs(self, fileName = None) :
 527     #-----------------------------------------------------------------#
 528         if fileName != None :
 529            self.fichier = fileName
 530            return self.saveFileLeger(fileName)
 531         return self.saveFileLeger()
 532
 533     #-----------------------------------------------------------------#
 534     def saveFileComplet(self, fichier = None, formatLigne="beautifie"):
 535     #-----------------------------------------------------------------#
 536         fn = fichier
 537         self.generator=generator.plugins[self.format]()
 538         print (self.generator)
 539         if hasattr(self.generator, "writeComplet"):
 540             self.generator.writeComplet(fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
 541
 542
 543 # ---------------------------------------------
 544 # Methodes Surchargees par avecIhm
 545 # ---------------------------------------------
 546
 547     #--------------------------------#
 548     def ajoutCommentaire(self):
 549     #--------------------------------#
 550       print ('pas programme sans Ihm')
 551       print ('prevenir la maintenance du besoin')
 552
 553
 554     #--------------------------------------#
 555     def informe(self,titre,txt,critique=True):
 556     #--------------------------------------#
 557     # methode differenre avec et sans ihm
 558       if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
 559       print (titre)
 560       print (txt)
 561       if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
 562
 563     #--------------------------------------#
 564     def afficheInfos(self,txt,couleur=None):
 565     #--------------------------------------#
 566     # methode differenre avec et sans ihm
 567       print (txt)
 568
 569     #-----------------------------------------------------------------------#
 570     def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
 571     #--------------------------------------------------------------------#
 572         print ('_____________________________')
 573         print (txt)
 574         print ('_____________________________')
 575
 576
 577     #-----------------------------------------------------------------#
 578     def saveFile(self, fichier, formatLigne="beautifie"):
 579     #-----------------------------------------------------------------#
 580         """
 581         Public slot to save the text to a file.
 582
 583         @param path directory to save the file in (string or QString)
 584         @return tuple of two values (boolean, string) giving a success indicator and
 585             the name of the saved file
 586         """
 587
 588
 589         if not (self.writeFile(fichier,formatLigne=formatLigne)): return (0, None)
 590         self.fichierOut = fichier
 591
 592         if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
 593             self.generator.writeDefault(fichier)
 594         elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
 595             self.generator.writeDefault(fichier)
 596
 597         self.modified = 0
 598
 599         return (1, self.fichier)
 600 #
 601
 602     #----------------------------------------------#
 603     def sauveLigneFile(self):
 604     #----------------------------------------------#
 605         self.modified=1
 606         return self.saveFile(formatLigne="Ligne")
 607
 608
 609     #-----------------------------------#
 610     def updateJdc(self, itemApres,texte):
 611     #------------------------------------#
 612     # ajoute une etape  de JdC a partir d un texte
 613         monItem=itemApres
 614         etape=monItem.item.object
 615         CONTEXT.setCurrentStep(etape)
 616         etape.buildIncludeInclude(texte)
 617         self.tree.racine.buildChildren()
 618
 619     #-----------------------------------#
 620     def updateJdcEtape(self, itemApres,texte):
 621     #------------------------------------#
 622     # ajoute une etape  de JdC a partir d un texte
 623         monItem=itemApres
 624         etape=monItem.item.object
 625         CONTEXT.set_current_step(etape)
 626         try :
 627           ok=etape.build_includeEtape(texte)
 628         except :
 629           ok=0
 630         if not ok :
 631            QMessageBox.information( self,
 632                       tr("Import texte"),
 633                       tr("Impossible d importer le texte"))
 634         self.tree.racine.build_children()
 635         return ok
 636
 637
 638
 639     #-------------------------------------#
 640     def deleteEtape(self,etape):
 641     #-------------------------------------#
 642     # dans le JDC
 643         self.jdc.suppentite(etape)
 644
 645     #-------------------------------------#
 646     def deleteMC(self,etape,MCFils,listeAvant=()):
 647     #-------------------------------------#
 648     # dans le JDC
 649         ouChercher=etape
 650         for mot in listeAvant :
 651               ouChercher=ouChercher.getChild(mot,restreint="oui")
 652         monMC=ouChercher.getChild(MCFils,restreint="oui")
 653         if monMC != None :  ouChercher.suppentite(monMC)
 654         ouChercher.state='changed'
 655         ouChercher.isvalid()
 656
 657     #--------------------------------------------------------#
 658     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
 659     #--------------------------------------------------------#
 660     # dans le JDC
 661         debug=False
 662         if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
 663         ouChercher=etape
 664         if debug : print (ouChercher)
 665         for mot in listeAvant :
 666            ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
 667         monMC=ouChercher.getChild(MCFils,restreint="oui")
 668         if monMC == None : monMC = ouChercher.addEntite(MCFils)
 669         monMC.valeur=valeurs
 670         monMC.val=valeurs
 671         monMC.state='changed'
 672         monMC.isvalid()
 673         return 1
 674
 675     #--------------------------------------------------------#
 676     def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
 677     # Attention si +sieursMCFACT
 678     #--------------------------------------------------------#
 679     # dans le JDC
 680         debug=False
 681         if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
 682         ouChercher=etape
 683         if debug : print (ouChercher)
 684         for mot in listeAvant :
 685            ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
 686         # Attention si +sieursMCFACT
 687         ouChercher=ouChercher[0]
 688         if debug : print (ouChercher)
 689         monMC=ouChercher.getChild(MCFils,restreint="oui")
 690         if monMC == None : monMC = ouChercher.addEntite(MCFils)
 691         monMC.valeur=valeurs
 692         monMC.val=valeurs
 693         monMC.state='changed'
 694         monMC.isValid()
 695         return 1
 696
 697     #----------------------------------------------#
 698     def ajoutMCFact(self,etape,MCFils,listeAvant=()):
 699     #----------------------------------------------#
 700     # dans le JDC
 701         ouChercher=etape
 702         for mot in listeAvant :
 703               ouChercher=ouChercher.getChild(mot,restreint="oui")
 704         monMC=etape.getChild(ouChercher,restreint="oui")
 705         if monMC== None : monMC= ouChercher.addEntite(MCFils)
 706         monMC.isvalid()
 707
 708     #-----------------------------------------------------------------#
 709     def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
 710     #-----------------------------------------------------------------#
 711     # pour VP
 712         monObj=etape
 713         for mot in listeAvant :
 714               monObj=monObj.getChild(mot,restreint="oui")
 715               if monObj==None : return False
 716         if monObj == None : return False
 717         if monObj.valeur != valeur :
 718            # PNPN le setValeur fait des bugs --> pourquoi
 719            #monObj.setValeur(valeur)
 720            monObj.valeur=valeur
 721            monObj.isValid()
 722         return True
 723
 724     #-------------------------------------------------#
 725     def getValeur(self,nomEtape,MCFils,listeAvant=()):
 726     #-------------------------------------------------#
 727     # dans le JDC
 728
 729         debug=0
 730         ouChercher=None
 731         for e in self.jdc.etapes:
 732             if e.nom == nomEtape : ouChercher=e; break
 733         if debug : print ('etape trouvee', ouChercher)
 734         if ouChercher==None : return None
 735         for mot in listeAvant :
 736               ouChercher=ouChercher.getChild(mot,restreint="oui")
 737               if debug : print (mot, ouChercher)
 738               if ouChercher==None : return None
 739         monMC=ouChercher.getChild(MCFils,restreint="oui")
 740         if debug : print ('monMC', monMC)
 741         if monMC== None : return None
 742         return monMC.valeur
 743
 744     #-------------------------------------------------#
 745     def getMCDsEtape(self,etape,MCFils,listeAvant=()):
 746     #-------------------------------------------------#
 747     # dans le JDC
 748
 749         if etape==None : return None
 750         ouChercher=etape
 751         debug=0
 752         for mot in listeAvant :
 753               ouChercher=ouChercher.getChild(mot,restreint="oui")
 754               if debug : print (mot, ouChercher)
 755               if ouChercher==None : return None
 756         monMC=ouChercher.getChild(MCFils,restreint="oui")
 757         if debug : print ('monMC', monMC)
 758         return monMC
 759
 760     #-----------------------------------------------------------#
 761     def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
 762     #--------------------------------------------------------#
 763     # dans le JDC
 764
 765         ouChercher=None
 766         for e in self.jdc.etapes:
 767             if e.nom == nomEtape : ouChercher=e; break
 768         if ouChercher==None : return None
 769         for mot in listeAvant :
 770               ouChercher=ouChercher.getChild(mot,restreint="oui")
 771               #print (mot, ouChercher)
 772               if ouChercher==None : return None
 773         monMC=ouChercher.getChild(MCFils,restreint="oui")
 774         monMC.set_valeur(valeur)
 775         monMC.isvalid()
 776
 777     #-----------------------------------------------------------#
 778     def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
 779     #-----------------------------------------------------------#
 780     # dans le JDC
 781         ouChercher=etape
 782         if isinstance (etape, str):
 783            ouChercher=None
 784            for e in self.jdc.etapes:
 785               if e.nom == etape : ouChercher=e; break
 786         if ouChercher==None : return
 787
 788         for mot in listeAvant :
 789               ouChercher=ouChercher.getChild(mot,restreint="oui")
 790               if ouChercher==None : return
 791         monMC=ouChercher.getChild(MCFils,restreint="oui")
 792         if monMC== None : monMC= ouChercher.addEntite(MCFils)
 793
 794         monMC.definition.into=valeurs
 795         from Noyau.N_VALIDATOR import  IntoProtocol
 796         monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
 797         monMC.state='changed'
 798         monMC.isvalid()
 799
 800     #-------------------------------------------------------------------#
 801     def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
 802     #-------------------------------------------------------------------#
 803     # dans le JDC
 804         for e in self.jdc.etapes:
 805             if e.nom == nomEtape : ouChercher=e; break
 806
 807         for mot in listeAvant :
 808             try :
 809               ouChercher=ouChercher.getChild(mot,restreint="oui")
 810             # Le mot clef n est pas la
 811             except : return 0
 812         try :
 813            monMC=ouChercher.getChild(MCFils,restreint="oui")
 814         # Le mot clef n est pas la
 815         except : return 0
 816         if monMC == None : return 0
 817
 818         if hasattr(monMC.definition,'into') :
 819            if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
 820            else : maListeDeValeur=monMC.definition.into
 821         else :
 822            return 0
 823
 824         monMC.state='changed'
 825         return 1
 826
 827     #-------------------------------------#
 828     def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
 829     #-------------------------------------#
 830     # dans le MDD
 831
 832         #if isinstance (etape, str):
 833         #  for e in self.jdc.etapes:
 834         #    if e.nom == etape : etape=e; break
 835         #if etape == None : return
 836         definitionEtape=getattr(self.jdc.cata,nomEtape)
 837         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 838         ouChercher=definitionEtape
 839         if len(listeMC) > 1 :
 840
 841            for mc in listeMC[0:-1]:
 842              mcfact=ouChercher.entites[mc]
 843              ouChercher=mcfact
 844
 845         mcAccas=ouChercher.entites[listeMC[-1]]
 846         mcAccas.defaut=valeurs
 847         return 1
 848
 849     #------------------------------------------------#
 850     def changeIntoDefMC(self,etape,listeMC,valeurs):
 851     #------------------------------------------------#
 852     # dans le MDD
 853         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 854         #definitionEtape=getattr(self.jdc.cata,nomEtape)
 855         print ( 'changeIntoDefMC ',etape,listeMC,valeurs)
 856         ouChercher=getattr(self.jdc.cata,etape.nom)
 857
 858         #if len(listeMC) > 1 :
 859         #   for mc in listeMC[0:-1]:
 860         #     mcfact=ouChercher.entites[mc]
 861         #     ouChercher=mcfact
 862         #mcAccas=ouChercher.entites[listeMC[-1]]
 863
 864         for mc in listeMC :
 865             mcAccas=ouChercher.entites[mc]
 866             ouChercher=mcAccas
 867             if ouChercher == None : return 0
 868
 869         if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
 870         else : oldValeurs=None
 871
 872         if oldValeurs==valeurs : return 1
 873         mcAccas.into=valeurs
 874         from Noyau.N_VALIDATOR import  IntoProtocol
 875         mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
 876         return 1
 877
 878     #-------------------------------------------------------------#
 879     def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
 880     #-------------------------------------------------------------#
 881     # dans le MDD
 882         #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
 883         if isinstance (etape, str):
 884           for e in self.jdc.etapes:
 885             if e.nom == etape : etape=e; break
 886         if etape == None : return
 887         #definitionEtape=getattr(self.jdc.cata[0],etape)
 888         definitionEtape=getattr(self.jdc.cata,etape)
 889         ouChercher=definitionEtape
 890         for k in listeAvant :
 891             ouChercher=ouChercher.entites[k]
 892         MCADetruire=ouChercher.entites[nomDuMC]
 893         ouChercher.ordre_mc.remove(nomDuMC)
 894         print ('remove de ', nomDuMC)
 895         del ouChercher.entites[nomDuMC]
 896         del self.dicoNouveauxMC[nomDuMC]
 897
 898
 899     #-------------------------------------------------------------#
 900     def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
 901     #-------------------------------------------------------------#
 902     # dans le MDD
 903         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 904         definitionEtape=getattr(self.jdc.cata,nomEtape)
 905         ouChercher=definitionEtape
 906         for k in listeAvant :
 907             ouChercher=ouChercher.entites[k]
 908         from Accas import A_SIMP
 909         Nouveau=A_SIMP.SIMP(typ,**args)
 910         Nouveau.pere=ouChercher
 911         Nouveau.nom=nomDuMC
 912         #Nouveau.ordre_mc=[]
 913         ouChercher.entites[nomDuMC]=Nouveau
 914         ouChercher.ordre_mc.append(nomDuMC)
 915         #print ('ajout de ', nomDuMC)
 916         #traceback.print_stack()
 917         # ajout CIST sauvegarde
 918         if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
 919         self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
 920         #print self.dicoNouveauxMC
 921
 922     #---------------------------------------------------------------------#
 923     def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
 924     #---------------------------------------------------------------------#
 925     # dans le MDD
 926         print ('ajoutDefinitionMCFact', nomDuMC)
 927         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
 928         definitionEtape=getattr(self.jdc.cata,nomEtape)
 929         ouChercher=definitionEtape
 930         for k in listeAvant :
 931             ouChercher=ouChercher.entites[k]
 932         from Accas import A_SIMP
 933         for mc in listeMC :
 934             nomMC=mc[0]
 935             typMC=mc[1]
 936             argsMC=mc[2]
 937             nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
 938             nouveauMC.nom=nomMC
 939             args[nomMC]=nouveauMC
 940         from Accas import A_FACT
 941         nouveauFact=A_FACT.FACT(**args)
 942         nouveauFact.pere=ouChercher
 943         nouveauFact.nom=nomDuMC
 944         from Editeur.autre_analyse_cata import traite_entite
 945         traite_entite(nouveauFact,[])
 946         ouChercher.entites[nomDuMC]=nouveauFact
 947         ouChercher.ordre_mc.append(nomDuMC)
 948         self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
 949         #print self.dicoNouveauxMC
 950
 951     #----------------------------------------------------#
 952
 953     #----------------------------------------------------#
 954     def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
 955     #----------------------------------------------------#
 956     # dans le MDD et le JDC
 957
 958         self.changeIntoDefMC(etape,listeMC,into)
 959
 960         if isinstance (etape, str):
 961           for e in self.jdc.etapes:
 962             if e.nom == etape : etape=e; break
 963         if etape == None : return
 964
 965         ouChercher = etape
 966         for mot in listeMC[:-1] :
 967             ouChercher=ouChercher.getChild(mot,restreint="oui")
 968             if ouChercher==None : return
 969         MCFils=listeMC[-1]
 970         monMC=ouChercher.getChild(MCFils,restreint="oui")
 971         if monMC== None : monMC= etape.addEntite(MCFils)
 972
 973         monMC.definition.into=into
 974         monMC.valeur=valeurs
 975         monMC.val=valeurs
 976         monMC.state='changed'
 977         monMC.isvalid()
 978
 979     #-------------------------------------#
 980     def ajoutVersionCataDsJDC(self,txt):
 981     #-------------------------------------#
 982         #if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
 983         if not hasattr(self.readercata.cata,'VERSION_CATALOGUE'): return txt
 984         ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata.VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
 985         texte=txt+ligneVersion
 986         return texte
 987
 988     #-------------------------------------#
 989     def verifieVersionCataDuJDC(self,text):
 990     #-------------------------------------#
 991         memeVersion=False
 992         indexDeb=text.find("#VERSION_CATALOGUE:")
 993         indexFin=text.find(":FIN VERSION_CATALOGUE")
 994         if indexDeb < 0 :
 995            self.versionCataDuJDC="sans"
 996            textJDC=text
 997         else :
 998            self.versionCataDuJDC=text[indexDeb+19:indexFin]
 999            textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1000
1001         self.versionCata="sans"
1002         if hasattr(self.readercata.cata,'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata.VERSION_CATALOGUE
1003
1004         if self.versionCata==self.versionCataDuJDC : memeVersion=True
1005         return memeVersion,textJDC
1006
1007     #-------------------------------#
1008     def traduitCatalogue(self,texte):
1009     #-------------------------------#
1010         nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1011         sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1012         try :
1013             traducteur=__import__(nomTraducteur)
1014             monTraducteur=traducteur.MonTraducteur(texte)
1015             nouveauTexte=monTraducteur.traduit()
1016             return nouveauTexte
1017         except :
1018             return texte
1019
1020
1021 # Methodes a resorber
1022 # il faut mettre a jour les catalogues avec
1023 # TEXTE_NEW_JDC
1024 #
1025
1026     #---------------------------#
1027     def _new_CF(self):
1028     #---------------------------#
1029         texte="CONDUITE_FORCEE();"
1030         return texte
1031
1032     #---------------------------#
1033     def _newPSEN(self):
1034     #---------------------------#
1035         texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1036         #texte=""
1037         return texte
1038
1039     #---------------------------#
1040     def _newPSEN_N1(self):
1041     #---------------------------#
1042         texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1043         #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1044         return texte
1045
1046     #---------------------------#
1047     def _newZCRACKS(self):
1048     #---------------------------#
1049         texte="MAILLAGES();REMESHING();"
1050         return texte
1051
1052
1053     #---------------------------#
1054     def _newJDCCND(self):
1055     #---------------------------#
1056       extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1057
1058       #if self.salome == 0 :
1059       QMessageBox.information( self,
1060                       tr("Fichier Med"),
1061                       tr("Veuillez selectionner un fichier Med"))
1062       QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1063                         caption='Fichier Med',
1064                         filter=extensions)
1065       QSfichier=QSfichier[0]
1066       self.fichierMED=QSfichier
1067       from acquiertGroupes import getGroupes
1068       erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1069       if erreur != "" : print ("a traiter")
1070       texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1071       texteSources=""
1072       texteCond=""
1073       texteNoCond=""
1074       texteVcut=""
1075       texteZs=""
1076       for groupe in self.listeGroupes :
1077           if groupe[0:8]=='CURRENT_':
1078              texteSources +=groupe[8:]+"=SOURCE("
1079              texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1080           if groupe[0:5]=='COND_':    texteCond    +=groupe[5:]+"=CONDUCTEUR();\n"
1081           if groupe[0:7]=='NOCOND_':  texteNoCond  +=groupe[7:]+"=NOCOND();\n"
1082           if groupe[0:5]=='VCUT_':    texteVcut    +='V_'+groupe[5:]+"=VCUT();\n"
1083           if groupe[0:3]=='ZS_':      texteZs      +=groupe[3:]+"=ZS();\n"
1084       texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1085       self.newTexteCND=texte
1086       self.modified=1
1087       return texte
1088
1089
1090 if __name__ == "__main__":
1091    print ('a faire')