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