1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013 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
32 from six.moves import range
38 import convert, generator
39 from Editeur import session
40 from Editeur import comploader
41 from Editeur import Objecttreeitem
43 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
48 class JDCEditorSsIhm :
49 # ------------------- #
54 # ---------------------------------------------
55 # Methodes Communes ou appelees depuis avec Ihm
56 # ---------------------------------------------
58 def __init__ (self,appli,fichier = None, jdc = None, units = None, include=0 ):
59 #------------------------------------------------------------------------------#
60 # paticularisee avec Ihm
62 if debug : print ('dans le init de JDCEditorSsIhm')
63 self.appliEficas = appli
65 self.fichier = fichier
66 self.fichierComplet = fichier
70 self.dicoNouveauxMC = {}
71 self.dicoNouveauxFact = {}
73 self.liste_simp_reel = []
75 if appli != None : self.salome = self.appliEficas.salome
76 else : self.salome = 0
78 # ces attributs sont mis a jour par definitCode appelee par newEditor
79 self.code = self.appliEficas.maConfiguration.code
80 self.maConfiguration = self.appliEficas.maConfiguration
82 self.version_code = session.d_env.cata
85 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.readercata.demandeCatalogue==True or self.appliEficas.multi==True:
86 if self.maConfiguration.typeDeCata == 'XML' :
87 from InterfaceQT4 import readercataXML as readercata
89 from InterfaceQT4 import readercata
90 self.readercata = readercata.ReaderCata( self, self.appliEficas )
91 self.appliEficas.readercata=self.readercata
92 self.appliEficas.code=self.code
94 self.readercata=self.appliEficas.readercata
95 if self.readercata.fic_cata == None : return #Sortie Salome
96 self.titre=self.readercata.titre
98 self.format = self.appliEficas.format_fichier
100 if self.appliEficas.maConfiguration.dumpXSD==True : self.appliEficas.dumpXsd()
102 self.liste_simp_reel=[]
103 self.dicoNouveauxMC={}
104 self.dicoNouveauxFact={}
108 self.maConfiguration.generator_module
109 _module = __import__(self.maConfiguration.generator_module)
110 info = _module.entryPoint()
111 generator.plugins.addEntryPoint(info)
116 self.maConfiguration.convert_module
117 #print self.maConfiguration.convert_module
118 _module = __import__(self.maConfiguration.convert_module)
119 info = _module.entryPoint()
120 convert.plugins.addEntryPoint(info)
124 self.maConfiguration.mesGenerators = generator
125 self.maConfiguration.mesconvertisseurs = convert
128 self.lastModified = 0
130 self.modified = False
131 self.isReadOnly = False
133 #------- construction du jdc --------------
137 if self.fichier is not None: # fichier jdc fourni
139 #print ('PNPN : chgt try en if')
142 self.jdc = self.readFile(self.fichier)
144 print ("mauvaise lecture du fichier")
147 self.appliEficas.addJdcInSalome( self.fichier)
149 print ("mauvais enregistrement dans Salome")
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
158 if not self.jdc: # nouveau jdc
160 self.jdc = self._newJDC(units=units)
162 self.jdc = self._newJDCInclude(units=units)
166 self.jdc.appli = self # a resorber
167 self.jdc.editor = self
168 self.jdc.lang = self.appli.langue
169 self.jdc.aReafficher=False
173 txt_exception = self.jdc.cr.getMessException()
176 self.informe('pb chargement jdc',txt_exception)
178 comploader.chargerComposants()
179 self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
181 #-------------------------------#
182 def readFile(self, fn):
183 #--------------------------------#
185 Public slot to read the text from a file.
186 @param fn filename to read from (string or QString)
190 # paticularisee avec Ihm
192 fn = six.text_type(fn)
193 jdcName=os.path.basename(fn)
195 # Il faut convertir le contenu du fichier en fonction du format
196 if self.appliEficas.format_fichier_in in convert.plugins:
197 # Le convertisseur existe on l'utilise
199 p=convert.plugins[self.appliEficas.format_fichier_in]()
202 if p.text=="" : self.nouveau=1
203 #print ('PNPN --> CIST a faire')
205 pareil,texteNew=self.verifieChecksum(p.text)
207 self.informe(("fichier modifie"),("Attention! fichier change hors EFICAS"),False)
210 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
211 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
214 text=p.convert('exec',self.appliEficas)
216 if not p.cr.estvide(): self.afficheInfos("Erreur a la conversion",'red')
218 self.afficheInfos("Type de fichier non reconnu",'red')
219 self.informe( "Type de fichier non reconnu",
220 "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
223 CONTEXT.unsetCurrentStep()
225 #jdc=self.readercata.cata[0].JdC(procedure=text,
226 jdc=self.readercata.cata.JdC(procedure=text,
228 cata=self.readercata.cata,
229 cata_ord_dico=self.readercata.cata_ordonne_dico,
231 rep_mat=self.maConfiguration.rep_mat
233 self.modified = False
237 #--------------------------------#
238 def _newJDC( self ,units = None):
239 #--------------------------------#
241 Initialise un nouveau JDC vierge
244 CONTEXT.unsetCurrentStep()
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()
252 #if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
253 if hasattr(self.readercata.cata,'TEXTE_NEW_JDC') : texte=self.readercata.cata.TEXTE_NEW_JDC
256 #jdc=self.readercata.cata[0].JdC( procedure =texte,
257 #print (self.readercata.cata)
258 jdc=self.readercata.cata.JdC( procedure =texte,
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.appli.langue
266 if units is not None:
267 jdc.recorded_units=units
268 jdc.old_recorded_units=units
269 ## PNPN est ce que la ligne suivante est bien utile ?
270 # elle positionne le contexte
271 # est ce qu on ne doit pas changer le format en Accas si on vient d accas ?
272 if self.format == 'xml' : return jdc
278 #--------------------------------#
279 def _newJDCInclude( self ,units = None):
280 #--------------------------------#
282 Initialise un nouveau JDC vierge
284 import Extensions.jdc_include
285 JdC_aux=Extensions.jdc_include.JdC_include
286 CONTEXT.unsetCurrentStep()
288 #jaux=self.readercata.cata[0].JdC( procedure="",
289 jaux=self.readercata.cata.JdC( procedure="",
291 cata=self.readercata.cata,
292 cata_ord_dico=self.readercata.cata_ordonne_dico,
293 rep_mat=self.maConfiguration.rep_mat,
297 J=JdC_aux( procedure="",
299 cata=self.readercata.cata,
300 cata_ord_dico=self.readercata.cata_ordonne_dico,
302 rep_mat=self.maConfiguration.rep_mat,
305 if units is not None:
306 J.recorded_units=units
307 J.old_recorded_units=units
312 #-----------------------#
313 def getSource(self,file):
314 #-----------------------#
316 # Il faut convertir le contenu du fichier en fonction du format
317 if self.format in convert.plugins :
318 # Le convertisseur existe on l'utilise
319 p=convert.plugins[self.format]()
321 text=p.convert('execnoparseur')
322 if not p.cr.estvide():
323 self.afficheInfos("Erreur a la conversion",'red')
326 # Il n'existe pas c'est une erreur
327 self.afficheInfos("Type de fichier non reconnu",'red')
328 self.informe( "Type de fichier non reconnu",
329 "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
332 #----------------------------------------------#
333 def __generateTempFilename(self, prefix, suffix):
334 #----------------------------------------------#
336 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
340 #-----------------------#
342 #-----------------------#
343 if 'dico' in generator.plugins:
344 self.generator=generator.plugins['dico']()
345 #print (self.generator)
346 jdc_formate=self.generator.gener(self.jdc)
348 dico=self.generator.Dico
352 #-----------------------#
353 def viewJdcSource(self):
354 #-----------------------#
355 if self.fichier == None : return
356 f=open(self.fichier,'r')
359 self._viewText(texteSource, "JDC_SOURCE")
361 #-----------------------#
363 #-----------------------#
364 strSource = str( self.getTextJDC(self.format) )
365 self._viewText(strSource, "JDC_RESULTAT")
367 #-----------------------#
368 def viewJdcRapport(self):
369 #-----------------------#
370 # on ajoute les regles
371 strRapport = six.text_type( self.jdc.report() )
372 self._viewText(strRapport, "JDC_RAPPORT")
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")
381 #-----------------------#
382 def getJdcRapport(self):
383 #-----------------------#
384 # on ajoute les regles
385 strRapport = six.text_type( self.jdc.report() )
388 #---------------------#
389 def getFileName(self):
390 #---------------------#
393 #-------------------#
395 #-------------------#
397 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
398 si un JDC doit etre sauvegarde avant destruction ou non
403 #--------------------------------------------------#
404 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
405 #--------------------------------------------------#
407 Public slot to write the text to a file.
409 @param fn filename to write to string
410 @return flag indicating success
413 fn = six.text_type(fn)
416 txt = self.getTextJDC(self.format,formatLigne=formatLigne)
418 if len(txt) >= len(eol):
419 if txt[-len(eol):] != eol:
423 txt=self.ajoutVersionCataDsJDC(txt)
424 if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
427 if self.code=="TELEMAC" : return 1
433 except IOError as why:
434 self.afficheInfos('Sauvegarde du Fichier', 'Le fichier'+str(fn) + 'n a pas pu etre sauvegarde :' + str(why))
437 #-----------------------------------------------------------#
438 def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
439 #-----------------------------------------------------------#
440 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
441 if format in generator.plugins:
443 # Le generateur existe on l'utilise
444 self.generator=generator.plugins[format]()
446 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
447 if pourRun : jdc_formate=self.generator.textePourRun
448 if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
449 except ValueError as e:
450 self.informe( "Erreur a la generation",str(e),'red')
453 if not self.generator.cr.estvide():
454 self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
459 # Il n'existe pas c'est une erreur
460 self.informe("Format inconnu", self.format + " non reconnu" )
463 #------------------------------#
464 def verifieChecksum(self,text):
465 #------------------------------#
466 # Attention : souci sous Windows
468 indexDeb=text.find("#CHECKSUM:")
469 if indexDeb < 0 : return 1, text
470 indexFin=text.find(":FIN CHECKSUM")
471 checkAvant=text[indexDeb:indexFin+13]
472 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
473 if self.code != 'PSEN' and self.code != 'PSEN_N1':
474 checksum=self.getChecksum(textJDC)
475 pareil=(checkAvant==checksum)
478 return pareil, textJDC
480 #---------------------------#
481 def getChecksum(self,texte):
482 #---------------------------#
483 newtexte=texte.replace('"','\\"')
484 commande='echo "'+newtexte+'"|md5sum'
488 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
491 #----------------------#
493 #---------------------#
494 if 'dicoImbrique' in generator.plugins:
495 self.generator=generator.plugins['dicoImbrique']()
496 #print (self.generator)
497 jdc_formate=self.generator.gener(self.jdc)
498 dico=self.generator.Dico
501 self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
504 #-----------------------------------------#
505 def chercheGroupes(self):
506 #-----------------------------------------#
507 listeMA,listeNO=self.getTextJDC("GroupMA")
508 return listeMA,listeNO
510 #-----------------------------------------#
511 def chercheDico(self):
512 #-----------------------------------------#
514 format = self.appliEficas.format_fichier
515 if format in generator.plugins:
516 # Le generateur existe on l'utilise
517 self.generator=generator.plugins[format]()
518 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
519 dicoCourant=self.generator.dico
522 #-----------------------------------------------------------------#
523 def saveFileLegerAs(self, fileName = None) :
524 #-----------------------------------------------------------------#
525 if fileName != None :
526 self.fichier = fileName
527 return self.saveFileLeger(fileName)
528 return self.saveFileLeger()
530 #-----------------------------------------------------------------#
531 def saveFileComplet(self, fichier = None, formatLigne="beautifie"):
532 #-----------------------------------------------------------------#
534 self.generator=generator.plugins[self.format]()
535 print (self.generator)
536 if hasattr(self.generator, "writeComplet"):
537 self.generator.writeComplet(fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
540 # ---------------------------------------------
541 # Methodes Surchargees par avecIhm
542 # ---------------------------------------------
544 #--------------------------------#
545 def ajoutCommentaire(self):
546 #--------------------------------#
547 print ('pas programme sans Ihm')
548 print ('prevenir la maintenance du besoin')
551 #--------------------------------------#
552 def informe(self,titre,txt,critique=True):
553 #--------------------------------------#
554 # methode differenre avec et sans ihm
555 if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
558 if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
560 #--------------------------------------#
561 def afficheInfos(self,txt,couleur=None):
562 #--------------------------------------#
563 # methode differenre avec et sans ihm
566 #-----------------------------------------------------------------------#
567 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
568 #--------------------------------------------------------------------#
569 print ('_____________________________')
571 print ('_____________________________')
574 #-----------------------------------------------------------------#
575 def saveFile(self, fichier, formatLigne="beautifie"):
576 #-----------------------------------------------------------------#
578 Public slot to save the text to a file.
580 @param path directory to save the file in (string or QString)
581 @return tuple of two values (boolean, string) giving a success indicator and
582 the name of the saved file
586 if not (self.writeFile(fichier,formatLigne=formatLigne)): return (0, None)
587 self.fichierOut = fichier
589 if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
590 self.generator.writeDefault(fichier)
591 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
592 self.generator.writeDefault(fichier)
596 return (1, self.fichier)
599 #----------------------------------------------#
600 def sauveLigneFile(self):
601 #----------------------------------------------#
603 return self.saveFile(formatLigne="Ligne")
606 #-----------------------------------#
607 def updateJdc(self, itemApres,texte):
608 #------------------------------------#
609 # ajoute une etape de JdC a partir d un texte
611 etape=monItem.item.object
612 CONTEXT.setCurrentStep(etape)
613 etape.buildIncludeInclude(texte)
614 self.tree.racine.buildChildren()
616 #-----------------------------------#
617 def updateJdcEtape(self, itemApres,texte):
618 #------------------------------------#
619 # ajoute une etape de JdC a partir d un texte
621 etape=monItem.item.object
622 CONTEXT.set_current_step(etape)
624 ok=etape.build_includeEtape(texte)
628 QMessageBox.information( self,
630 tr("Impossible d importer le texte"))
631 self.tree.racine.build_children()
636 #-------------------------------------#
637 def deleteEtape(self,etape):
638 #-------------------------------------#
640 self.jdc.suppentite(etape)
642 #-------------------------------------#
643 def deleteMC(self,etape,MCFils,listeAvant=()):
644 #-------------------------------------#
647 for mot in listeAvant :
648 ouChercher=ouChercher.getChild(mot,restreint="oui")
649 monMC=ouChercher.getChild(MCFils,restreint="oui")
650 if monMC != None : ouChercher.suppentite(monMC)
651 ouChercher.state='changed'
654 #--------------------------------------------------------#
655 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
656 #--------------------------------------------------------#
659 if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
661 if debug : print (ouChercher)
662 for mot in listeAvant :
663 ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
664 monMC=ouChercher.getChild(MCFils,restreint="oui")
665 if monMC == None : monMC = ouChercher.addEntite(MCFils)
668 monMC.state='changed'
672 #--------------------------------------------------------#
673 def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
674 # Attention si +sieursMCFACT
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", debug=1)
683 # Attention si +sieursMCFACT
684 ouChercher=ouChercher[0]
685 if debug : print (ouChercher)
686 monMC=ouChercher.getChild(MCFils,restreint="oui")
687 if monMC == None : monMC = ouChercher.addEntite(MCFils)
690 monMC.state='changed'
694 #----------------------------------------------#
695 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
696 #----------------------------------------------#
699 for mot in listeAvant :
700 ouChercher=ouChercher.getChild(mot,restreint="oui")
701 monMC=etape.getChild(ouChercher,restreint="oui")
702 if monMC== None : monMC= ouChercher.addEntite(MCFils)
705 #-----------------------------------------------------------------#
706 def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
707 #-----------------------------------------------------------------#
710 for mot in listeAvant :
711 monObj=monObj.getChild(mot,restreint="oui")
712 if monObj==None : return False
713 if monObj == None : return False
714 if monObj.valeur != valeur :
715 # PNPN le setValeur fait des bugs --> pourquoi
716 #monObj.setValeur(valeur)
721 #-------------------------------------------------#
722 def getValeur(self,nomEtape,MCFils,listeAvant=()):
723 #-------------------------------------------------#
728 for e in self.jdc.etapes:
729 if e.nom == nomEtape : ouChercher=e; break
730 if debug : print ('etape trouvee', ouChercher)
731 if ouChercher==None : return None
732 for mot in listeAvant :
733 ouChercher=ouChercher.getChild(mot,restreint="oui")
734 if debug : print (mot, ouChercher)
735 if ouChercher==None : return None
736 monMC=ouChercher.getChild(MCFils,restreint="oui")
737 if debug : print ('monMC', monMC)
738 if monMC== None : return None
741 #-------------------------------------------------#
742 def getMCDsEtape(self,etape,MCFils,listeAvant=()):
743 #-------------------------------------------------#
746 if etape==None : return None
749 for mot in listeAvant :
750 ouChercher=ouChercher.getChild(mot,restreint="oui")
751 if debug : print (mot, ouChercher)
752 if ouChercher==None : return None
753 monMC=ouChercher.getChild(MCFils,restreint="oui")
754 if debug : print ('monMC', monMC)
757 #-----------------------------------------------------------#
758 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
759 #--------------------------------------------------------#
763 for e in self.jdc.etapes:
764 if e.nom == nomEtape : ouChercher=e; break
765 if ouChercher==None : return None
766 for mot in listeAvant :
767 ouChercher=ouChercher.getChild(mot,restreint="oui")
768 #print (mot, ouChercher)
769 if ouChercher==None : return None
770 monMC=ouChercher.getChild(MCFils,restreint="oui")
771 monMC.set_valeur(valeur)
774 #-----------------------------------------------------------#
775 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
776 #-----------------------------------------------------------#
779 if isinstance (etape, str):
781 for e in self.jdc.etapes:
782 if e.nom == etape : ouChercher=e; break
783 if ouChercher==None : return
785 for mot in listeAvant :
786 ouChercher=ouChercher.getChild(mot,restreint="oui")
787 if ouChercher==None : return
788 monMC=ouChercher.getChild(MCFils,restreint="oui")
789 if monMC== None : monMC= ouChercher.addEntite(MCFils)
791 monMC.definition.into=valeurs
792 from Noyau.N_VALIDATOR import IntoProtocol
793 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
794 monMC.state='changed'
797 #-------------------------------------------------------------------#
798 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
799 #-------------------------------------------------------------------#
801 for e in self.jdc.etapes:
802 if e.nom == nomEtape : ouChercher=e; break
804 for mot in listeAvant :
806 ouChercher=ouChercher.getChild(mot,restreint="oui")
807 # Le mot clef n est pas la
810 monMC=ouChercher.getChild(MCFils,restreint="oui")
811 # Le mot clef n est pas la
813 if monMC == None : return 0
815 if hasattr(monMC.definition,'into') :
816 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
817 else : maListeDeValeur=monMC.definition.into
821 monMC.state='changed'
824 #-------------------------------------#
825 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
826 #-------------------------------------#
829 #if isinstance (etape, str):
830 # for e in self.jdc.etapes:
831 # if e.nom == etape : etape=e; break
832 #if etape == None : return
833 definitionEtape=getattr(self.jdc.cata,nomEtape)
834 #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
835 ouChercher=definitionEtape
836 if len(listeMC) > 1 :
838 for mc in listeMC[0:-1]:
839 mcfact=ouChercher.entites[mc]
842 mcAccas=ouChercher.entites[listeMC[-1]]
843 mcAccas.defaut=valeurs
846 #------------------------------------------------#
847 def changeIntoDefMC(self,etape,listeMC,valeurs):
848 #------------------------------------------------#
850 #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
851 #definitionEtape=getattr(self.jdc.cata,nomEtape)
852 print ( 'changeIntoDefMC ',etape,listeMC,valeurs)
853 ouChercher=getattr(self.jdc.cata,etape.nom)
855 #if len(listeMC) > 1 :
856 # for mc in listeMC[0:-1]:
857 # mcfact=ouChercher.entites[mc]
859 #mcAccas=ouChercher.entites[listeMC[-1]]
862 mcAccas=ouChercher.entites[mc]
864 if ouChercher == None : return 0
866 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
867 else : oldValeurs=None
869 if oldValeurs==valeurs : return 1
871 from Noyau.N_VALIDATOR import IntoProtocol
872 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
875 #-------------------------------------------------------------#
876 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
877 #-------------------------------------------------------------#
879 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
880 if isinstance (etape, str):
881 for e in self.jdc.etapes:
882 if e.nom == etape : etape=e; break
883 if etape == None : return
884 #definitionEtape=getattr(self.jdc.cata[0],etape)
885 definitionEtape=getattr(self.jdc.cata,etape)
886 ouChercher=definitionEtape
887 for k in listeAvant :
888 ouChercher=ouChercher.entites[k]
889 MCADetruire=ouChercher.entites[nomDuMC]
890 ouChercher.ordre_mc.remove(nomDuMC)
891 print ('remove de ', nomDuMC)
892 del ouChercher.entites[nomDuMC]
893 del self.dicoNouveauxMC[nomDuMC]
896 #-------------------------------------------------------------#
897 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
898 #-------------------------------------------------------------#
900 #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
901 definitionEtape=getattr(self.jdc.cata,nomEtape)
902 ouChercher=definitionEtape
903 for k in listeAvant :
904 ouChercher=ouChercher.entites[k]
905 from Accas import A_SIMP
906 Nouveau=A_SIMP.SIMP(typ,**args)
907 Nouveau.pere=ouChercher
910 ouChercher.entites[nomDuMC]=Nouveau
911 ouChercher.ordre_mc.append(nomDuMC)
912 #print ('ajout de ', nomDuMC)
913 #traceback.print_stack()
914 # ajout CIST sauvegarde
915 if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
916 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
917 #print self.dicoNouveauxMC
919 #---------------------------------------------------------------------#
920 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
921 #---------------------------------------------------------------------#
923 print ('ajoutDefinitionMCFact', nomDuMC)
924 #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
925 definitionEtape=getattr(self.jdc.cata,nomEtape)
926 ouChercher=definitionEtape
927 for k in listeAvant :
928 ouChercher=ouChercher.entites[k]
929 from Accas import A_SIMP
934 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
936 args[nomMC]=nouveauMC
937 from Accas import A_FACT
938 nouveauFact=A_FACT.FACT(**args)
939 nouveauFact.pere=ouChercher
940 nouveauFact.nom=nomDuMC
941 from Editeur.autre_analyse_cata import traite_entite
942 traite_entite(nouveauFact,[])
943 ouChercher.entites[nomDuMC]=nouveauFact
944 ouChercher.ordre_mc.append(nomDuMC)
945 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
946 #print self.dicoNouveauxMC
948 #----------------------------------------------------#
950 #----------------------------------------------------#
951 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
952 #----------------------------------------------------#
953 # dans le MDD et le JDC
955 self.changeIntoDefMC(etape,listeMC,into)
957 if isinstance (etape, str):
958 for e in self.jdc.etapes:
959 if e.nom == etape : etape=e; break
960 if etape == None : return
963 for mot in listeMC[:-1] :
964 ouChercher=ouChercher.getChild(mot,restreint="oui")
965 if ouChercher==None : return
967 monMC=ouChercher.getChild(MCFils,restreint="oui")
968 if monMC== None : monMC= etape.addEntite(MCFils)
970 monMC.definition.into=into
973 monMC.state='changed'
976 #-------------------------------------#
977 def ajoutVersionCataDsJDC(self,txt):
978 #-------------------------------------#
979 #if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
980 if not hasattr(self.readercata.cata,'VERSION_CATALOGUE'): return txt
981 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata.VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
982 texte=txt+ligneVersion
985 #-------------------------------------#
986 def verifieVersionCataDuJDC(self,text):
987 #-------------------------------------#
989 indexDeb=text.find("#VERSION_CATALOGUE:")
990 indexFin=text.find(":FIN VERSION_CATALOGUE")
992 self.versionCataDuJDC="sans"
995 self.versionCataDuJDC=text[indexDeb+19:indexFin]
996 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
998 self.versionCata="sans"
999 if hasattr(self.readercata.cata,'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata.VERSION_CATALOGUE
1001 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1002 return memeVersion,textJDC
1004 #-------------------------------#
1005 def traduitCatalogue(self,texte):
1006 #-------------------------------#
1007 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1008 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1010 traducteur=__import__(nomTraducteur)
1011 monTraducteur=traducteur.MonTraducteur(texte)
1012 nouveauTexte=monTraducteur.traduit()
1018 # Methodes a resorber
1019 # il faut mettre a jour les catalogues avec
1023 #---------------------------#
1025 #---------------------------#
1026 texte="CONDUITE_FORCEE();"
1029 #---------------------------#
1031 #---------------------------#
1032 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1036 #---------------------------#
1037 def _newPSEN_N1(self):
1038 #---------------------------#
1039 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1040 #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1043 #---------------------------#
1044 def _newZCRACKS(self):
1045 #---------------------------#
1046 texte="MAILLAGES();REMESHING();"
1050 #---------------------------#
1051 def _newJDCCND(self):
1052 #---------------------------#
1053 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1055 #if self.salome == 0 :
1056 QMessageBox.information( self,
1058 tr("Veuillez selectionner un fichier Med"))
1059 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1060 caption='Fichier Med',
1062 QSfichier=QSfichier[0]
1063 self.fichierMED=QSfichier
1064 from acquiertGroupes import getGroupes
1065 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1066 if erreur != "" : print ("a traiter")
1067 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1073 for groupe in self.listeGroupes :
1074 if groupe[0:8]=='CURRENT_':
1075 texteSources +=groupe[8:]+"=SOURCE("
1076 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1077 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1078 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1079 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1080 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1081 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1082 self.newTexteCND=texte
1087 if __name__ == "__main__":