InterfaceQT4/editorSsIhm.py

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