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