1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2021 EDF R&D
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.
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.
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
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 from __future__ import absolute_import
21 from __future__ import print_function
23 from builtins import str
24 from builtins import range
27 import types,sys,os, re
36 import convert, generator
37 from Editeur import session
38 from Editeur import comploader
39 from Editeur import Objecttreeitem
41 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
46 class JDCEditorSsIhm :
47 # ------------------- #
52 # ---------------------------------------------
53 # Methodes Communes ou appelees depuis avec Ihm
54 # ---------------------------------------------
56 def __init__ (self,appliEficas,fichier = None, jdc = None, units = None, include=0 ):
57 #-----------------------------------------------------------------------------------#
58 # paticularisee avec Ihm
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
69 self.dicoNouveauxMC = {}
70 self.dicoNouveauxFact = {}
72 self.liste_simp_reel = []
74 if self.appliEficas != None : self.salome = self.appliEficas.salome
75 else : self.salome = 0
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
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
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
91 self.readercata=self.appliEficas.readercata
92 if self.readercata.fichierCata == None : return #Sortie Salome
93 self.titre=self.readercata.titre
95 self.formatFichierOut = self.appliEficas.formatFichierOut
96 self.formatFichierIn = self.appliEficas.formatFichierIn
98 if self.appliEficas.maConfiguration.dumpXSD==True : self.appliEficas.dumpXsd()
100 self.liste_simp_reel=[]
101 self.dicoNouveauxMC={}
102 self.dicoNouveauxFact={}
106 self.maConfiguration.generator_module
107 _module = __import__(self.maConfiguration.generator_module)
108 info = _module.entryPoint()
109 generator.plugins.addEntryPoint(info)
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)
122 self.maConfiguration.mesGenerators = generator
123 self.maConfiguration.mesconvertisseurs = convert
124 try : self.XMLgenerator=generator.plugins['xml']()
125 except : self.XMLgenerator=None
128 if self.formatFichierOut in generator.plugins.keys():
129 self.generator = generator.plugins[self.formatFichierOut]()
133 self.lastModified = 0
135 self.modified = False
136 self.isReadOnly = False
138 #------- construction du jdc --------------
142 if self.fichier is not None: # fichier jdc fourni
144 #print ('PNPN : chgt try en if')
147 self.jdc = self.readFile(self.fichier)
149 print ("mauvaise lecture du fichier")
151 try : self.appliEficas.addJdcInSalome( self.fichier)
152 except : print ("mauvais enregistrement dans Salome")
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
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)
167 self.jdc.editor = self
168 self.jdc.lang = self.appliEficas.langue
169 self.jdc.aReafficher=False
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()
179 self.informe('pb chargement jdc',txt_exception)
181 #comploader.chargerComposants()
182 #self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
184 #-------------------------------#
185 def readFile(self, fn):
186 #--------------------------------#
188 Public slot to read the text from a file.
189 @param fn filename to read from (string or QString)
193 # paticularisee avec Ihm
196 jdcName=os.path.basename(fn)
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]()
206 if p.text=="" : self.nouveau=1
207 #print ('PNPN --> CIST a faire')
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)
213 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
214 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
216 text=p.convert('exec',self.appliEficas)
217 if not p.cr.estvide(): self.afficheInfos("Erreur a la conversion",'red')
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)
226 CONTEXT.unsetCurrentStep()
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,
234 rep_mat=self.maConfiguration.rep_mat
236 self.modified = False
240 #--------------------------------#
241 def _newJDC( self ,units = None):
242 #--------------------------------#
244 Initialise un nouveau JDC vierge
247 CONTEXT.unsetCurrentStep()
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()
255 if hasattr(self.readercata.cata,'TEXTE_NEW_JDC') : texte=self.readercata.cata.TEXTE_NEW_JDC
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
265 jdc.lang = self.appliEficas.langue
266 if units is not None:
267 jdc.recorded_units=units
268 jdc.old_recorded_units=units
270 # Attention positionne contexte ?
271 # est ce qu on ne doit pas changer le format en Accas si on vient d accas ?
275 #--------------------------------#
276 def _newJDCInclude( self ,units = None):
277 #--------------------------------#
279 Initialise un nouveau JDC vierge
281 import Extensions.jdc_include
282 JdC_aux=Extensions.jdc_include.JdC_include
283 CONTEXT.unsetCurrentStep()
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,
295 J=JdC_aux( procedure="",
296 appliEficas=self.appliEficas,
297 cata=self.readercata.cata,
298 cata_ord_dico=self.readercata.cata_ordonne_dico,
300 rep_mat=self.maConfiguration.rep_mat,
304 if units is not None:
305 J.recorded_units=units
306 J.old_recorded_units=units
311 #-----------------------#
312 def getSource(self,file):
313 #-----------------------#
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]()
320 text=p.convert('execnoparseur')
321 if not p.cr.estvide():
322 self.afficheInfos("Erreur a la conversion",'red')
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)
331 #----------------------------------------------#
332 def __generateTempFilename(self, prefix, suffix):
333 #----------------------------------------------#
335 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
339 #-----------------------#
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)
347 dico=self.generator.Dico
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')
359 self._viewText(texteSource, "JDC_SOURCE")
361 self._viewText("file doesn't exist", "JDC_SOURCE")
364 #-----------------------#
366 #-----------------------#
367 strSource = str( self.getTextJDC(self.formatFichierOut) )
368 self._viewText(strSource, "JDC_RESULTAT")
370 #-----------------------#
371 def viewJdcRapport(self):
372 #-----------------------#
373 # on ajoute les regles
374 strRapport = str( self.jdc.report() )
375 self._viewText(strRapport, "JDC_RAPPORT")
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")
384 #-----------------------#
385 def getJdcRapport(self):
386 #-----------------------#
387 # on ajoute les regles
388 strRapport = str( self.jdc.report() )
391 #---------------------#
392 def getFileName(self):
393 #---------------------#
396 #-------------------#
398 #-------------------#
400 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
401 si un JDC doit etre sauvegarde avant destruction ou non
406 #--------------------------------------------------#
407 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
408 #--------------------------------------------------#
410 Public slot to write the text to a file.
412 @param fn filename to write to string
413 @return flag indicating success
419 txt = self.getTextJDC(self.formatFichierOut,formatLigne=formatLigne)
421 if len(txt) >= len(eol):
422 if txt[-len(eol):] != eol:
426 txt=self.ajoutVersionCataDsJDC(txt)
427 if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
430 if self.code=="TELEMAC" : 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')
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:
449 # Le generateur existe on l'utilise
450 self.generator=generator.plugins[format]()
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')
459 if not self.generator.cr.estvide():
460 self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
465 # Il n'existe pas c'est une erreur
466 self.informe("Format inconnu", self.format + " non reconnu" )
469 #------------------------------#
470 def verifieChecksum(self,text):
471 #------------------------------#
472 # Attention : souci sous Windows
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)
484 return pareil, textJDC
486 #---------------------------#
487 def getChecksum(self,texte):
488 #---------------------------#
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"
498 newtexte=texte.replace('"','\\"')
499 commande='echo "'+newtexte+'"|md5sum'
504 checksum='Fichier trop long \n'
505 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
508 #----------------------#
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
518 self.afficheInfos(tr("Format %s non reconnu" , 'Dictionnaire Imbrique' ),'red')
521 #-----------------------------------------#
522 def chercheGroupes(self):
523 #-----------------------------------------#
524 listeMA,listeNO=self.getTextJDC("GroupMA")
525 return listeMA,listeNO
527 #-----------------------------------------#
528 def chercheDico(self):
529 #-----------------------------------------#
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
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()
547 #-----------------------------------------------------------------#
548 def saveFileComplet(self, fichier = None, formatLigne="beautifie"):
549 #-----------------------------------------------------------------#
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)
557 # ---------------------------------------------
558 # Methodes Surchargees par avecIhm
559 # ---------------------------------------------
561 #--------------------------------#
562 def ajoutCommentaire(self):
563 #--------------------------------#
564 print ('pas programme sans Ihm')
565 print ('prevenir la maintenance du besoin')
568 #--------------------------------------#
569 def informe(self,titre,txt,critique=True):
570 #--------------------------------------#
571 # methode differenre avec et sans ihm
572 if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
575 if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
577 #--------------------------------------#
578 def afficheInfos(self,txt,couleur=None):
579 #--------------------------------------#
580 # methode differenre avec et sans ihm
583 #-----------------------------------------------------------------------#
584 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
585 #--------------------------------------------------------------------#
586 print ('_____________________________')
588 print ('_____________________________')
591 #-----------------------------------------------------------------#
592 def saveFile(self, fichier, formatLigne="beautifie"):
593 #-----------------------------------------------------------------#
595 Public slot to save the text to a file.
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
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)
615 return (1, self.fichier)
618 #----------------------------------------------#
619 def sauveLigneFile(self):
620 #----------------------------------------------#
622 return self.saveFile(formatLigne="Ligne")
625 #-----------------------------------#
626 def updateJdc(self, itemApres,texte):
627 #------------------------------------#
628 # ajoute une etape de JdC a partir d un texte
630 etape=monItem.item.object
631 CONTEXT.setCurrentStep(etape)
632 etape.buildIncludeInclude(texte)
633 self.tree.racine.buildChildren()
635 #-----------------------------------#
636 def updateJdcEtape(self, itemApres,texte):
637 #------------------------------------#
638 # ajoute une etape de JdC a partir d un texte
640 etape=monItem.item.object
641 CONTEXT.set_current_step(etape)
643 ok=etape.build_includeEtape(texte)
647 QMessageBox.information( self,
649 tr("Impossible d importer le texte"))
650 self.tree.racine.build_children()
655 #-------------------------------------#
656 def deleteEtape(self,etape):
657 #-------------------------------------#
659 self.jdc.suppentite(etape)
661 #-------------------------------------#
662 def deleteMC(self,etape,MCFils,listeAvant=()):
663 #-------------------------------------#
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'
673 #--------------------------------------------------------#
674 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
675 #--------------------------------------------------------#
678 if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
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)
687 monMC.state='changed'
691 #--------------------------------------------------------#
692 def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
693 # Attention si +sieursMCFACT
694 #--------------------------------------------------------#
697 if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
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)
709 monMC.state='changed'
713 #----------------------------------------------#
714 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
715 #----------------------------------------------#
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)
724 #-----------------------------------------------------------------#
725 def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
726 #-----------------------------------------------------------------#
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)
740 #-------------------------------------------------#
741 def getValeur(self,nomEtape,MCFils,listeAvant=()):
742 #-------------------------------------------------#
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
760 #-------------------------------------------------#
761 def getMCDsEtape(self,etape,MCFils,listeAvant=()):
762 #-------------------------------------------------#
765 if etape==None : return None
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)
776 #-----------------------------------------------------------#
777 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
778 #--------------------------------------------------------#
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)
793 #-----------------------------------------------------------#
794 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
795 #-----------------------------------------------------------#
798 if isinstance (etape, str):
800 for e in self.jdc.etapes:
801 if e.nom == etape : ouChercher=e; break
802 if ouChercher==None : return
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)
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'
816 #-------------------------------------------------------------------#
817 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
818 #-------------------------------------------------------------------#
820 for e in self.jdc.etapes:
821 if e.nom == nomEtape : ouChercher=e; break
823 for mot in listeAvant :
825 ouChercher=ouChercher.getChild(mot,restreint="oui")
826 # Le mot clef n est pas la
829 monMC=ouChercher.getChild(MCFils,restreint="oui")
830 # Le mot clef n est pas la
832 if monMC == None : return 0
834 if hasattr(monMC.definition,'into') :
835 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
836 else : maListeDeValeur=monMC.definition.into
840 monMC.state='changed'
843 #-------------------------------------#
844 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
845 #-------------------------------------#
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 :
857 for mc in listeMC[0:-1]:
858 mcfact=ouChercher.entites[mc]
861 mcAccas=ouChercher.entites[listeMC[-1]]
862 mcAccas.defaut=valeurs
865 #------------------------------------------------#
866 def changeIntoDefMC(self,etape,listeMC,valeurs):
867 #------------------------------------------------#
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)
874 #if len(listeMC) > 1 :
875 # for mc in listeMC[0:-1]:
876 # mcfact=ouChercher.entites[mc]
878 #mcAccas=ouChercher.entites[listeMC[-1]]
881 mcAccas=ouChercher.entites[mc]
883 if ouChercher == None : return 0
885 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
886 else : oldValeurs=None
888 if oldValeurs==valeurs : return 1
890 from Noyau.N_VALIDATOR import IntoProtocol
891 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
894 #-------------------------------------------------------------#
895 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
896 #-------------------------------------------------------------#
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]
915 #-------------------------------------------------------------#
916 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
917 #-------------------------------------------------------------#
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
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
938 #---------------------------------------------------------------------#
939 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
940 #---------------------------------------------------------------------#
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
953 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
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
967 #----------------------------------------------------#
969 #----------------------------------------------------#
970 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
971 #----------------------------------------------------#
972 # dans le MDD et le JDC
974 self.changeIntoDefMC(etape,listeMC,into)
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
982 for mot in listeMC[:-1] :
983 ouChercher=ouChercher.getChild(mot,restreint="oui")
984 if ouChercher==None : return
986 monMC=ouChercher.getChild(MCFils,restreint="oui")
987 if monMC== None : monMC= etape.addEntite(MCFils)
989 monMC.definition.into=into
992 monMC.state='changed'
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
1004 #-------------------------------------#
1005 def verifieVersionCataDuJDC(self,text):
1006 #-------------------------------------#
1008 indexDeb=text.find("#VERSION_CATALOGUE:")
1009 indexFin=text.find(":FIN VERSION_CATALOGUE")
1011 self.versionCataDuJDC="sans"
1014 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1015 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1017 self.versionCata="sans"
1018 if hasattr(self.readercata.cata,'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata.VERSION_CATALOGUE
1020 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1021 return memeVersion,textJDC
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")))
1029 traducteur=__import__(nomTraducteur)
1030 monTraducteur=traducteur.MonTraducteur(texte)
1031 nouveauTexte=monTraducteur.traduit()
1037 # Methodes a resorber
1038 # il faut mettre a jour les catalogues avec
1042 #---------------------------#
1044 #---------------------------#
1045 texte="CONDUITE_FORCEE();"
1048 #---------------------------#
1050 #---------------------------#
1051 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
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(); "
1062 #---------------------------#
1063 def _newZCRACKS(self):
1064 #---------------------------#
1065 texte="MAILLAGES();REMESHING();"
1069 #---------------------------#
1070 def _newJDCCND(self):
1071 #---------------------------#
1072 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1074 #if self.salome == 0 :
1075 QMessageBox.information( self,
1077 tr("Veuillez selectionner un fichier Med"))
1078 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1079 caption='Fichier Med',
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"
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
1106 if __name__ == "__main__":