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
33 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
34 from PyQt5.QtGui import QPalette
35 from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
38 from datetime import date
39 from Extensions.i18n import tr
45 import convert, generator
46 from Editeur import session
47 from Editeur import comploader
48 from Editeur import Objecttreeitem
49 from desBaseWidget import Ui_baseWidget
50 from InterfaceQT4.monViewTexte import ViewText
51 from monWidgetCreeParam import MonWidgetCreeParam
53 from . import readercata
55 DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
61 class JDCEditor(Ui_baseWidget,QWidget):
62 # ----------------------------------------- #
67 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
68 #----------------------------------------------------------------------------------------------------------#
70 QWidget.__init__(self,None)
74 self.widgetOptionnel=None
75 self.fenetreCentraleAffichee=None
76 self.dejaDansPlieTout=False
77 self.afficheCommandesPliees = True
78 self.listeDesListesOuvertes=set()
79 self.appliEficas = appli
80 self.appli = appli #---- attendu par IHM
82 self.fichier = fichier
85 self.QWParent = QWParent
86 self.couleur = Qt.black
90 self.salome = self.appliEficas.salome
93 print ("dans JDC pas d appli ????????")
95 # ces attributs sont mis a jour par definitCode appelee par newEditor
96 self.code = self.appliEficas.CONFIGURATION.code
97 self.initSplitterSizes()
99 #self.afficheListesPliees=False
100 self.afficheListesPliees=True
101 if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
102 if self.code == 'PSEN_N1' : self.afficheListesPliees = False
104 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
105 self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
106 self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
107 self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
108 self.affiche=self.appliEficas.CONFIGURATION.affiche
109 self.afficheOptionnelVide=self.appliEficas.CONFIGURATION.afficheOptionnelVide
110 self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
111 self.dicoImages = self.appliEficas.CONFIGURATION.dicoImages
112 self.simpleClic = self.appliEficas.CONFIGURATION.simpleClic
113 #self.taille = self.appliEficas.taille
115 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
116 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
117 if self.code in ['MAP',]:
118 self.widgetTree.close()
120 if self.closeArbre: self.fermeArbre()
122 self.version_code = session.d_env.cata
125 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
126 self.readercata = readercata.READERCATA( self, self.appliEficas )
127 self.appliEficas.readercata=self.readercata
128 self.appliEficas.code=self.code
130 self.readercata=self.appliEficas.readercata
131 if self.readercata.fic_cata == None : return #Sortie Salome
132 self.titre=self.readercata.titre
133 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
134 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
136 self.format = self.appliEficas.format_fichier
139 self.liste_simp_reel=[]
141 self.dicoNouveauxMC={}
142 self.dicoNouveauxFact={}
144 nameConf='configuration_'+self.code
145 configuration=__import__(nameConf)
146 self.CONFIGURATION = self.appliEficas.CONFIGURATION
147 self.CONFIGStyle = self.appliEficas.CONFIGStyle
150 self.CONFIGURATION.generator_module
151 _module = __import__(self.CONFIGURATION.generator_module)
152 info = _module.entryPoint()
153 generator.plugins.addEntryPoint(info)
158 self.CONFIGURATION.convert_module
159 #print self.CONFIGURATION.convert_module
160 _module = __import__(self.CONFIGURATION.convert_module)
161 info = _module.entryPoint()
162 convert.plugins.addEntryPoint(info)
167 if hasattr(self.appliEficas,"statusBar"):
168 self.sb = self.appliEficas.statusBar()
171 self.lastModified = 0
173 self.modified = False
174 self.isReadOnly = False
175 self.node_selected = []
178 if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
179 else : self.afficheApresInsert=False
180 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
181 else : self.enteteQTree='complet'
182 if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
183 else : self.affichePlie=False
185 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
187 #------- construction du jdc --------------
192 if self.fichier is not None: # fichier jdc fourni
193 self.fileInfo = QFileInfo(self.fichier)
194 self.fileInfo.setCaching(0)
197 self.jdc = self.readFile(self.fichier)
198 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
200 print ("mauvaise lecture")
203 if self.jdc is not None and units is not None:
204 self.jdc.recorded_units=units
205 self.jdc.old_recorded_units=units
207 if not self.jdc: # nouveau jdc
209 self.jdc = self._newJDC(units=units)
211 self.jdc = self._newJDCInclude(units=units)
215 self.jdc.appli = self # a resorber
216 self.jdc.editor = self
217 self.jdc.lang = self.appli.langue
218 self.jdc.aReafficher=False
222 txt_exception = self.jdc.cr.get_mess_exception()
225 QApplication.restoreOverrideCursor()
226 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
227 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
229 comploader.charger_composants("QT")
230 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
231 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
232 self.viewJdcRapport()
236 if jdc_item and self.appliEficas.ssIhm==False:
237 self.tree = browser.JDCTree( jdc_item, self )
238 self.appliEficas.construitMenu()
245 #-------------------# Pour execution avec output et error dans le bash
247 #-------------------#
249 #if self.modified or self.fichier==None : self.saveFile()
252 #lancement avec le .bat
253 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
254 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
256 p = subprocess.Popen(['python',WrapperFilePath])
257 (out,err)=p.communicate()
261 #-------------------# Pour execution avec output et error dans le bash
262 def runPSEN_N1(self):
263 #-------------------#
267 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
268 sys.path.append(path1)
270 if not(self.jdc.isvalid()):
271 QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
272 if 'dicoImbrique' in generator.plugins:
273 self.generator=generator.plugins['dicoImbrique']()
274 jdc_formate=self.generator.gener(self.jdc)
275 dico=self.generator.Dico
278 #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
279 fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
280 f = open( str(fileDico), 'w')
281 f.write("Dico =" + str(dico) )
286 print ('in runPSEN_N1', dico)
290 #res,txt_exception=run(dico)
291 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
292 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
294 #-------------------# Pour execution avec output et error dans le bash
295 def process_N1(self):
296 #-------------------#
298 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
299 sys.path.append(path1)
302 if 'dicoImbrique' in generator.plugins:
303 self.generator=generator.plugins['dicoImbrique']()
304 jdc_formate=self.generator.gener(self.jdc)
305 dico=self.get_Dico() #generator.Dico
308 for k in dico['CONTINGENCY_PROCESSING']:
310 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
311 newK=k.replace('__',' ')
313 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
314 del dico['CONTINGENCY_PROCESSING'][k]
317 fileDico = os.path.join(path1, 'dicoN1_process.py')
318 f = open( str(fileDico), 'w')
319 f.write("Dico =" + str(dico) )
324 #return self.get_Dico()
326 #-------------------# Pour execution avec output et error dans le bash
327 def process_VP(self):
328 #-------------------#
329 if 'dicoImbrique' in generator.plugins:
330 self.generator=generator.plugins['dicoImbrique']()
331 jdc_formate=self.generator.gener(self.jdc)
332 dico=self.get_Dico() #generator.Dico
336 #--------------------------------#
337 def ajoutCommentaire(self):
338 #--------------------------------#
339 if self.tree.selectedItems()==[] :
340 QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
342 noeudAvantCommentaire=self.tree.selectedItems()[0]
343 if noeudAvantCommentaire ==self.tree.racine :
344 self.tree.racine.append_child("COMMENTAIRE",pos=0)
346 noeudAvantCommentaire.addComment(True)
350 #--------------------------------#
351 def _newJDC( self ,units = None):
352 #--------------------------------#
354 Initialise un nouveau JDC vierge
357 CONTEXT.unset_current_step()
360 if self.code == "CARMELCND" : texte=self._newJDCCND()
361 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
362 if self.code == "TELEMAC" : texte=self._newTELEMAC()
363 if self.code == "PSEN" : texte = self._newPSEN()
364 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
366 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
368 #if self.code == "CF" : texte = self._new_CF()
369 # texte=self.newTexteCND
371 jdc=self.readercata.cata[0].JdC( procedure =texte,
373 cata=self.readercata.cata,
374 cata_ord_dico=self.readercata.cata_ordonne_dico,
375 rep_mat=self.CONFIGURATION.rep_mat
377 jdc.lang = self.appli.langue
378 if units is not None:
379 jdc.recorded_units=units
380 jdc.old_recorded_units=units
381 ## PNPN est ce que la ligne suivante est bien utile ?
382 if texte == "" :jdc.analyse()
385 #--------------------------------#
386 def _newJDCInclude( self ,units = None):
387 #--------------------------------#
389 Initialise un nouveau JDC vierge
391 import Extensions.jdc_include
392 JdC_aux=Extensions.jdc_include.JdC_include
393 CONTEXT.unset_current_step()
395 jaux=self.readercata.cata[0].JdC( procedure="",
397 cata=self.readercata.cata,
398 cata_ord_dico=self.readercata.cata_ordonne_dico,
399 rep_mat=self.CONFIGURATION.rep_mat,
403 J=JdC_aux( procedure="",
405 cata=self.readercata.cata,
406 cata_ord_dico=self.readercata.cata_ordonne_dico,
408 rep_mat=self.CONFIGURATION.rep_mat,
411 if units is not None:
412 J.recorded_units=units
413 J.old_recorded_units=units
417 #-------------------------------#
418 def readFile(self, fn):
419 #--------------------------------#
421 Public slot to read the text from a file.
422 @param fn filename to read from (string or QString)
424 fn = six.text_type(fn)
426 # ------------------------------------------------------------------------------------
428 # ------------------------------------------------------------------------------------
430 jdcName=os.path.basename(fn)
431 # Il faut convertir le contenu du fichier en fonction du format
432 if self.appliEficas.format_fichier_in in convert.plugins:
433 # Le convertisseur existe on l'utilise
435 p=convert.plugins[self.appliEficas.format_fichier_in]()
439 if p.text=="" : self.nouveau=1
440 pareil,texteNew=self.verifieCHECKSUM(p.text)
442 if pareil == False and (self.appliEficas.ssIhm == False) :
443 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
445 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
446 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
449 #import cProfile, pstats, StringIO
450 #pr = cProfile.Profile()
453 text=p.convert('exec',self.appliEficas)
455 #s = StringIO.StringIO()
456 #sortby = 'cumulative'
457 #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
459 #print (s.getvalue())
461 if not p.cr.estvide():
462 self.affiche_infos("Erreur a la conversion",Qt.red)
464 self.affiche_infos("Type de fichier non reconnu",Qt.red)
465 if self.appliEficas.ssIhm == False:
466 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
467 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
470 CONTEXT.unset_current_step()
471 jdc=self.readercata.cata[0].JdC(procedure=text,
473 cata=self.readercata.cata,
474 cata_ord_dico=self.readercata.cata_ordonne_dico,
476 rep_mat=self.CONFIGURATION.rep_mat
478 # ----------------------------------------------------
480 # ----------------------------------------------------
481 self.modified = False
483 # qApp.restoreOverrideCursor()
484 if self.fileInfo!= None :
485 self.lastModified = self.fileInfo.lastModified()
487 self.lastModified = 1
488 nouveauTitre=self.titre+" "+os.path.basename(self.fichier)
489 self.appliEficas.setWindowTitle(nouveauTitre)
493 #-----------------------#
494 def get_source(self,file):
495 #-----------------------#
497 # Il faut convertir le contenu du fichier en fonction du format
498 if self.format in convert.plugins :
499 # Le convertisseur existe on l'utilise
500 p=convert.plugins[self.format]()
502 text=p.convert('execnoparseur')
503 if not p.cr.estvide():
504 self.affiche_infos("Erreur a la conversion",Qt.red)
507 # Il n'existe pas c'est une erreur
508 self.affiche_infos("Type de fichier non reconnu",Qt.red)
509 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
512 #-----------------------------------------------------------------------#
513 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
514 #--------------------------------------------------------------------#
515 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
519 #----------------------------------------------#
520 def __generateTempFilename(self, prefix, suffix):
521 #----------------------------------------------#
523 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
529 #----------------------------------------------#
530 def _viewTextExecute(self, txt, prefix, suffix):
531 #----------------------------------------------#
532 self.w = ViewText( self.QWParent )
533 self.w.setWindowTitle( "execution" )
534 self.monExe=QProcess(self.w)
535 pid=self.monExe.pid()
536 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
537 f=open(nomFichier,'w')
540 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
541 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
542 exe='sh ' + nomFichier
543 self.monExe.start(exe)
544 self.monExe.closeWriteChannel()
547 commande="rm "+ nomFichier
552 def readFromStdErr(self):
553 a=self.monExe.readAllStandardError()
554 self.w.view.append(str(a.data()))
556 def readFromStdOut(self) :
557 a=self.monExe.readAllStandardOutput()
558 self.w.view.append(str(a.data()))
560 def readFromStdErrQT4(self):
561 a=self.monExe.readAllStandardError()
562 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
564 def readFromStdOutQT4(self) :
565 a=self.monExe.readAllStandardOutput()
566 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
568 #-----------------------#
570 #-----------------------#
571 if 'dico' in generator.plugins:
572 self.generator=generator.plugins['dico']()
573 jdc_formate=self.generator.gener(self.jdc)
574 dico=self.generator.Dico
577 #-----------------------#
578 def gestionParam(self):
579 #-----------------------#
580 w = MonWidgetCreeParam( self)
583 #-----------------------#
584 def viewJdcSource(self):
585 #-----------------------#
586 if self.fichier == None : return
587 f=open(self.fichier,'r')
590 self._viewText(texteSource, "JDC_SOURCE")
592 #-----------------------#
594 #-----------------------#
595 strSource = str( self.get_text_JDC(self.format) )
596 self._viewText(strSource, "JDC_RESULTAT")
598 #-----------------------#
599 def viewJdcRapport(self):
600 #-----------------------#
601 strRapport = six.text_type( self.jdc.report() )
602 # on ajoute les regles
604 self._viewText(strRapport, "JDC_RAPPORT")
606 #-----------------------#
607 def viewJdcRegles(self):
608 #-----------------------#
609 if self.tree :self.tree.AppelleBuildLBRegles()
616 Public method called by the viewmanager to finally get rid of us.
622 #----------------------------------------------#
623 def affiche_infos(self,message,couleur=Qt.black):
624 #----------------------------------------------#
626 mapalette=self.sb.palette()
627 mapalette.setColor( QPalette.WindowText, couleur )
628 self.sb.setPalette( mapalette );
629 self.sb.showMessage(message,4000)
632 #------------------------------#
633 def affiche_alerte(self,titre,message):
634 #------------------------------#
635 # appele par I_MACRO_ETAPE
636 QMessageBox.information( self, titre, message)
638 #-----------------------------------#
639 def affiche_commentaire(self,message):
640 #-----------------------------------#
641 self.labelCommentaire.setText(message)
642 QTimer.singleShot(6000, self.rendInvisible)
644 #----------------------#
645 def rendInvisible(self):
646 #----------------------#
647 self.labelCommentaire.setText("")
649 #-------------------#
650 def init_modif(self):
651 #-------------------#
653 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
654 si un JDC doit etre sauvegarde avant destruction ou non
658 #---------------------------------------#
659 def chercheNoeudSelectionne(self,copie=1):
660 #---------------------------------------#
662 appele par Cut et Copy pour positionner self.node_selected
664 self.node_selected=[]
665 if len(self.tree.selectedItems()) == 0 : return
666 self.node_selected=self.tree.selectedItems()
669 #---------------------#
670 def handleSupprimer(self):
671 #---------------------#
672 self.chercheNoeudSelectionne()
673 if len(self.node_selected) == 0 : return
674 self.QWParent.noeud_a_editer = []
675 if self.node_selected[0]==self.tree.racine: return
676 if len(self.node_selected) == 1 : self.node_selected[0].delete()
677 else : self.node_selected[0].deleteMultiple(self.node_selected)
679 #---------------------#
680 def handleRechercher(self):
681 #---------------------#
682 from .monRecherche import DRecherche
683 monRechercheDialg=DRecherche(parent=self,fl=0)
684 monRechercheDialg.show()
687 #--------------------------------#
688 def handleRechercherDsCatalogue(self):
689 #-----------------------------#
690 from .monRechercheCatalogue import DRechercheCatalogue
691 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
692 monRechercheDialg.show()
694 #---------------------#
695 def handleDeplier(self):
696 #---------------------#
697 if self.tree == None : return
698 #self.tree.collapseAll()
701 self.tree.expandItem(self.tree.topLevelItem(0))
703 if self.fenetreCentraleAffichee != None :
704 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
705 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
708 self.tree.expandItem(self.tree.topLevelItem(0))
710 if self.fenetreCentraleAffichee != None :
711 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
712 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
714 #---------------------#
715 def handleEditCut(self):
716 #---------------------#
718 Stocke dans Eficas.noeud_a_editer le noeud a couper
720 #print "handleEditCut"
721 self.chercheNoeudSelectionne()
722 self.QWParent.edit="couper"
723 self.QWParent.noeud_a_editer = self.node_selected
725 #-----------------------#
726 def handleEditCopy(self):
727 #-----------------------#
729 Stocke dans Eficas.noeud_a_editer le noeud a copier
731 self.chercheNoeudSelectionne()
732 if len(self.node_selected) == 0 : return
733 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
734 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
735 self.QWParent.edit="copier"
736 self.QWParent.noeud_a_editer = self.node_selected
738 #------------------------#
739 def handleEditPaste(self):
740 #------------------------#
742 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
743 Ne permet que la copie d'objets de type Commande ou MCF
745 self.chercheNoeudSelectionne()
746 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
747 QMessageBox.information( self,
748 tr("Copie impossible"),
749 tr("Veuillez selectionner un objet a copier"))
751 if len(self.node_selected) != 1 :
752 QMessageBox.information( self,
753 tr("Copie impossible"),
754 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
756 noeudOuColler=self.node_selected[0]
758 if len(self.QWParent.noeud_a_editer)!=1:
759 #self.handleEditPasteMultiple()
760 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
763 noeudACopier=self.QWParent.noeud_a_editer[0]
765 if (self.QWParent.edit != "couper"):
766 #print (noeudOuColler.item.parent.get_child(noeudOuColler.item.nom))
768 if noeudOuColler == self.tree.racine :
769 child=noeudOuColler.doPastePremier(noeudACopier)
771 child=noeudACopier.doPaste(noeudOuColler,'after')
773 if child==None or child==0:
774 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
776 self.affiche_infos("Copie refusee",Qt.red)
777 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
779 nom=noeudACopier.item.sd.nom
780 child.item.nomme_sd(nom)
787 traceback.print_exc()
788 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
790 self.affiche_infos("Copie refusee",Qt.red)
793 # il faut declarer le JDCDisplay_courant modifie
794 # suppression eventuelle du noeud selectionne
795 # si possible on renomme l objet comme le noeud couper
797 if (self.QWParent.edit == "couper"):
799 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
800 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
804 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
805 indexNoeudACopier=self.getTreeIndex(noeudACopier)
806 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
807 noeudACopier.treeParent.build_children()
812 self.QWParent.noeud_a_editer=[]
814 # on rend la copie a nouveau possible en liberant le flag edit
815 self.QWParent.edit="copier"
816 noeudACopier.select()
818 #----------------------------------#
819 def handleDeplaceMultiple(self):
820 #----------------------------------#
823 #----------------------------------#
824 def handleEditPasteMultiple(self):
825 #----------------------------------#
827 # On ne garde que les niveaux "Etape"
828 # On insere dans l'ordre du JDC
829 listeNoeudsACouper=[]
833 from InterfaceQT4 import compojdc
834 noeudOuColler=self.node_selected[0]
835 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
836 QMessageBox.information( self,
837 tr("Copie impossible a cet endroit",),
838 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
840 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
842 for noeud in self.QWParent.noeud_a_editer :
843 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
844 indexInTree=noeud.treeParent.children.index(noeud)
846 for index in listeIndex:
847 if index < indexInTree : indice = indice +1
848 listeIndex.insert(indice, indexInTree)
849 listeNoeudsACouper.insert(indice, noeud)
851 noeudJdc=noeudOuColler.treeParent
853 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
855 for index in listeIndex:
857 if indexNoeudOuColler < index:
858 indexTravail=indexTravail+dejaCrees
859 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
860 noeud=noeudJdc.children[indexTravail]
861 child=noeud.doPaste(noeudOuColler)
862 listeChild.append(child)
863 dejaCrees=dejaCrees+1
865 self.QWParent.noeud_a_editer = []
866 for i in range(len(listeIndex)):
867 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
868 self.QWParent.noeud_a_editer.append(noeud)
871 if self.QWParent.edit !="couper" : return
873 for index in listeIndex:
875 if indexNoeudOuColler < index:
876 indexTravail=indexTravail+(len(listeIndex))
877 noeud=noeudJdc.children[indexTravail]
879 listeItem.append(noeud.item)
880 listeASupprimer.append(noeud)
882 for i in range(len(listeChild)):
883 self.tree.item.suppitem(listeItem[i])
884 listeChild[i].item.update(listeItem[i])
886 self.QWParent.noeud_a_editer = []
889 #---------------------#
890 def getFileName(self):
891 #---------------------#
894 #---------------------------#
895 def get_file_variable(self) :
896 #---------------------------#
897 titre = tr("Choix d'un fichier XML")
898 texte = tr("Le fichier contient une commande MODEL\n")
899 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
900 QMessageBox.information( self, titre,tr(texte))
902 fichier = QFileDialog.getOpenFileName(self.appliEficas,
903 tr('Ouvrir Fichier'),
904 self.appliEficas.CONFIGURATION.savedir,
905 tr('Wrapper Files (*.xml);;''All Files (*)'))
908 #--------------------------------------------------#
909 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
910 #--------------------------------------------------#
912 Public slot to write the text to a file.
914 @param fn filename to write to string
915 @return flag indicating success
918 fn = six.text_type(fn)
921 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
923 if len(txt) >= len(eol):
924 if txt[-len(eol):] != eol:
928 txt=self.ajoutVersionCataDsJDC(txt)
929 if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.get_checksum(txt)
932 if self.code=="TELEMAC" : return 1
938 except IOError as why:
939 if (self.appliEficas.ssIhm == False):
940 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
941 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
946 #-----------------------------------------------------------#
947 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
948 #-----------------------------------------------------------#
949 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
950 if format in generator.plugins:
952 # Le generateur existe on l'utilise
953 self.generator=generator.plugins[format]()
955 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
956 if pourRun : jdc_formate=self.generator.textePourRun
957 if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
958 except ValueError as e:
959 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
962 if not self.generator.cr.estvide():
963 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
964 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
969 # Il n'existe pas c'est une erreur
970 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
971 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
974 #----------------------#
976 #---------------------#
977 if 'dicoImbrique' in generator.plugins:
978 self.generator=generator.plugins['dicoImbrique']()
979 jdc_formate=self.generator.gener(self.jdc)
980 dico=self.generator.Dico
983 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
984 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
991 fonction="run"+self.code
993 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
998 fonction="saveRun"+self.code
999 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
1005 if not(self.jdc.isvalid()):
1006 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
1008 if len(self.jdc.etapes) != 1 :
1009 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
1011 if self.modified or self.fichier==None :
1012 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1013 texte=self.get_text_JDC("MAP")
1014 self.writeFile( self.fichierMapInput, txt = texte)
1016 self.fichierMapInput=self.fichier
1017 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1020 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
1021 # then instantiate corresponding class and call getUseSalome() method
1023 from mapengine.spec import factory
1024 mapComponent = factory.new(composant)[0]
1027 if mapComponent.getUseSalome():
1028 command += " -r sappli"
1029 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
1031 #textePython="ls -l"
1032 self._viewTextExecute( textePython,"map_run",".sh")
1034 # commande="rm "+self.fichierMapInput
1035 # os.system(commande)
1038 except Exception as e:
1039 print((traceback.print_exc()))
1041 #-------------------#
1042 def runZCRACKS(self):
1043 #-------------------#
1044 if not(self.jdc.isvalid()):
1045 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1047 if self.modified or self.fichier==None :
1049 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1050 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1051 self.writeFile( self.fichierZcracksInput, txt = texte)
1053 self.fichierZcracksInput=self.fichier
1055 #commande ="Zrun -zp "
1057 textePython=(commande + self.fichierZcracksInput)
1058 self._viewTextExecute( textePython,"run_zcracks",".sh")
1059 except Exception as e:
1060 print((traceback.print_exc()))
1062 #-------------------#
1063 def runCARMELCND(self):
1064 #-------------------#
1065 #if not(self.jdc.isvalid()):
1066 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1068 if self.modified or self.fichier==None :
1069 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1071 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1072 from PrepareRunCarmel import prepareRunCarmel
1073 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1074 repMed=os.path.dirname(self.fichier)
1075 repExeCarmel=self.generator.get_repExeCarmel()
1076 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1077 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1078 f=open(nomFichier,'w')
1079 f.write(textePython)
1081 commande="xterm -e sh "+nomFichier +"\n"
1084 #-------------------#
1085 def runCarmelCS(self):
1086 #-------------------#
1088 commande="runSession pilotyacsCS.py"
1090 except Exception as e:
1091 print((traceback.print_exc()))
1093 #-----------------------------------------------------#
1094 def determineNomFichier(self,path,extension):
1095 #-----------------------------------------------------#
1096 if self.appli.code in DictExtensions:
1097 chaine1=DictExtensions[self.appli.code]+" (*."+DictExtensions[self.appli.code]+");;"
1098 extensions= tr(chaine1+ "All Files (*)")
1100 extensions= tr("JDC (*.comm);;" "All Files (*)")
1102 if self.appli.code == "MAP" :
1103 extensions = extensions + ";; Run (*.input);;"
1105 fn = QFileDialog.getSaveFileName( self,
1106 tr("sauvegarde"), path,
1108 QFileDialog.DontConfirmOverwrite)
1109 if fn == None : return (0, None)
1111 if fn=='': return (0, None)
1113 ext = QFileInfo(fn).suffix()
1114 if ext == '': fn+=extension
1116 if QFileInfo(fn).exists():
1117 msgBox = QMessageBox(self)
1118 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1119 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1120 msgBox.addButton(tr("&Ecraser"),0)
1121 msgBox.addButton(tr("&Abandonner"),1)
1122 abort=msgBox.exec_()
1123 if abort == 1 : return (0, "")
1127 def saveRunMAP(self):
1130 if not(self.jdc.isvalid()):
1131 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1132 tr("Un JdC valide est necessaire pour creer un .input")
1136 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1138 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1139 tr("Choix du composant obligatoire")
1142 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1146 if self.fichier is not None and self.fichier != "" :
1147 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1148 monPath=str(QFileInfo(self.fichier).absolutePath())
1149 monNomFichier=os.path.join(monPath,maBase)
1150 elif hasattr(self,'monNomFichierInput'):
1151 monNomFichier=self.monNomFichierInput
1154 monDialog=QFileDialog(self.appliEficas)
1155 monDialog.setDirectory (path)
1156 monDialog.setWindowTitle ("Save")
1158 for c in monDialog.children():
1159 if isinstance(c,QDialogButtonBox):
1160 for b in c.children():
1161 if isinstance(b,QPushButton):
1163 if avant=="&Open": b.setText("Save")
1164 mesFiltres= "input Map (*.input);;All Files (*)"
1165 monDialog.setNameFilters(mesFiltres)
1166 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1167 BOk=monDialog.exec_()
1169 fn=str(monDialog.selectedFiles()[0])
1170 if fn == "" or fn == None : return
1171 if not fn.endswith(".input"):
1173 self.monNomFichierInput=fn
1175 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1176 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1177 texte=self.get_text_JDC("MAP")
1178 self.writeFile( self.fichierMapInput, txt = texte)
1180 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1181 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1182 (output, err) = p.communicate()
1186 def saveRunPSEN(self):
1188 #print ("saveRunPSEN")
1192 #-----------------------------------------#
1193 def cherche_Groupes(self):
1194 #-----------------------------------------#
1195 listeMA,listeNO=self.get_text_JDC("GroupMA")
1196 return listeMA,listeNO
1198 #-----------------------------------------#
1199 def cherche_Dico(self):
1200 #-----------------------------------------#
1202 format = self.appliEficas.format_fichier
1203 if format in generator.plugins:
1204 # Le generateur existe on l'utilise
1205 self.generator=generator.plugins[format]()
1206 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1207 dicoCourant=self.generator.dico
1212 #-----------------------------------------#
1213 def handleAjoutGroup(self,listeGroup):
1214 #-----------------------------------------#
1217 from ajoutGroupe import handleAjoutGroupFiltre
1219 handleAjoutGroupFiltre(self,listeGroup)
1220 #print "apres handleAjoutGroupFiltre"
1225 #-----------------------------------------------------------------#
1226 def saveFileLegerAs(self, fileName = None) :
1227 #-----------------------------------------------------------------#
1228 if fileName != None :
1229 self.fichier = fileName
1230 return self.saveFileLeger()
1231 return self.saveFileLeger()
1233 #-----------------------------------------------------------------#
1234 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1235 #-----------------------------------------------------------------#
1238 #saveas=True # Pour forcer le nom
1239 self.generator=generator.plugins[self.format]()
1240 if self.fichier is None or saveas:
1241 if path is None: path=self.CONFIGURATION.savedir
1242 bOK, fn=self.determineNomFichier(path,extension)
1243 if bOK == 0 : return (0, None)
1244 if fn == None : return (0, None)
1245 if fn== '' : return (0, None)
1247 ulfile = os.path.abspath(six.text_type(fn))
1248 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1249 fn = six.text_type(QDir.toNativeSeparators(fn))
1251 self.fichier = os.path.splitext(fn)[0]+extension
1253 if hasattr(self.generator, "writeLeger"):
1254 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1256 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1259 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1260 self.appliEficas.setWindowTitle(nouveauTitre)
1261 return (1, self.fichier)
1263 #-----------------------------------------------------------------#
1264 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1265 #-----------------------------------------------------------------#
1267 Public slot to save the text to a file.
1269 @param path directory to save the file in (string or QString)
1270 @return tuple of two values (boolean, string) giving a success indicator and
1271 the name of the saved file
1275 if not self.modified and not saveas:
1276 return (0, None) # do nothing if text wasn't changed
1278 if self.appli.code in DictExtensions :
1279 extension=DictExtensions[self.appli.code]
1285 if self.fichier is None or saveas:
1286 if path is None: path=self.CONFIGURATION.savedir
1287 bOK, fn=self.determineNomFichier(path,extension)
1288 if bOK == 0 : return (0, None)
1289 if fn == None : return (0, None)
1290 if fn== '' : return (0, None)
1292 ulfile = os.path.abspath(six.text_type(fn))
1293 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1294 fn = six.text_type(QDir.toNativeSeparators(fn))
1298 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1300 self.modified = False
1301 if self.fileInfo is None or saveas:
1302 self.fileInfo = QFileInfo(self.fichier)
1303 self.fileInfo.setCaching(0)
1304 self.lastModified = self.fileInfo.lastModified()
1305 if newName is not None:
1306 self.appliEficas.addToRecentList(newName)
1307 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1308 self.tree.racine.update_node_label()
1310 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1311 self.generator.writeDefault(fn)
1312 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1313 self.generator.writeDefault(fn)
1316 self.appliEficas.addJdcInSalome( self.fichier)
1318 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1319 self.appliEficas.setWindowTitle(nouveauTitre)
1321 return (1, self.fichier)
1324 #----------------------------------------------#
1325 def sauveLigneFile(self):
1326 #----------------------------------------------#
1328 return self.saveFile(formatLigne="Ligne")
1331 #----------------------------------------------#
1332 def saveFileAs(self, path = None,fileName=None):
1333 #----------------------------------------------#
1335 Public slot to save a file with a new name.
1337 @param path directory to save the file in (string or QString)
1338 @return tuple of two values (boolean, string) giving a success indicator and
1339 the name of the saved file
1341 if fileName != None :
1342 self.fichier = fileName
1343 return self.saveFile()
1344 return self.saveFile(path,1,"beautifie")
1348 #---------------------------------------------#
1349 def get_file(self,unite=None,fic_origine = ''):
1350 #---------------------------------------------#
1358 titre = tr("Choix unite %d ", unite)
1359 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1360 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1361 labeltexte = tr('Fichier pour unite ') + repr( unite)
1363 titre = tr("Choix d'un fichier de poursuite")
1364 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1365 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1367 QMessageBox.information( self, titre,texte)
1368 fn = QFileDialog.getOpenFileName(self.appliEficas,
1370 self.appliEficas.CONFIGURATION.savedir)
1372 # ce retour est impose par le get_file d'I_JDC
1373 if fn== '' : return None," "
1374 if not fn : return (0, " ")
1377 ulfile = os.path.abspath(six.text_type(fn))
1378 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1380 # On utilise le convertisseur defini par format_fichier
1381 source=self.get_source(ulfile)
1383 # On a reussia convertir le fichier self.ulfile
1386 # Une erreur a ete rencontree
1388 return ulfile, jdcText
1390 #-----------------------------------#
1391 def updateJdc(self, itemApres,texte):
1392 #------------------------------------#
1393 # ajoute une etape de JdC a partir d un texte
1395 etape=monItem.item.object
1396 CONTEXT.set_current_step(etape)
1397 etape.build_includeInclude(texte)
1398 self.tree.racine.build_children()
1400 #-----------------------------------#
1401 def updateJdcEtape(self, itemApres,texte):
1402 #------------------------------------#
1403 # ajoute une etape de JdC a partir d un texte
1405 etape=monItem.item.object
1406 CONTEXT.set_current_step(etape)
1408 ok=etape.build_includeEtape(texte)
1412 QMessageBox.information( self,
1414 tr("Impossible d importer le texte"))
1415 self.tree.racine.build_children()
1420 #-------------------------------------#
1421 def deleteEtape(self,etape):
1422 #-------------------------------------#
1424 self.jdc.suppentite(etape)
1426 #-------------------------------------#
1427 def deleteMC(self,etape,MCFils,listeAvant=()):
1428 #-------------------------------------#
1431 for mot in listeAvant :
1432 ouChercher=ouChercher.get_child(mot,restreint="oui")
1433 monMC=ouChercher.get_child(MCFils,restreint="oui")
1434 if monMC != None : ouChercher.suppentite(monMC)
1435 ouChercher.state='changed'
1436 ouChercher.isvalid()
1438 #-------------------------------------#
1439 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1440 #-------------------------------------#
1443 for mot in listeAvant :
1444 ouChercher=ouChercher.get_child(mot,restreint="oui")
1445 monMC=etape.get_child(ouChercher,restreint="oui")
1446 if monMC== None : monMC= ouChercher.addentite(MCFils)
1447 monMC.valeur=valeurs
1449 monMC.state='changed'
1452 #----------------------------------------------#
1453 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
1454 #----------------------------------------------#
1456 print ('ajoutMCFact')
1459 for mot in listeAvant :
1460 ouChercher=ouChercher.get_child(mot,restreint="oui")
1463 monMC=etape.get_child(ouChercher,restreint="oui")
1464 if monMC== None : monMC= ouChercher.addentite(MCFils)
1467 #-------------------------------------------------#
1468 def getValeur(self,nomEtape,MCFils,listeAvant=()):
1469 #-------------------------------------------------#
1473 for e in self.jdc.etapes:
1474 if e.nom == nomEtape : ouChercher=e; break
1475 if debug : print ('etape trouvee', ouChercher)
1476 if ouChercher==None : return None
1477 for mot in listeAvant :
1478 ouChercher=ouChercher.get_child(mot,restreint="oui")
1479 if debug : print (mot, ouChercher)
1480 if ouChercher==None : return None
1481 monMC=ouChercher.get_child(MCFils,restreint="oui")
1482 if debug : print ('monMC', monMC)
1483 if monMC== None : return None
1486 #-----------------------------------------------------------#
1487 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
1488 #--------------------------------------------------------#
1492 for e in self.jdc.etapes:
1493 if e.nom == nomEtape : ouChercher=e; break
1494 if ouChercher==None : return None
1495 for mot in listeAvant :
1496 ouChercher=ouChercher.get_child(mot,restreint="oui")
1497 #print (mot, ouChercher)
1498 if ouChercher==None : return None
1499 monMC=ouChercher.get_child(MCFils,restreint="oui")
1500 monMC.set_valeur(valeur)
1503 #-----------------------------------------------------------#
1504 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1505 #-----------------------------------------------------------#
1508 if isinstance (etape, str):
1510 for e in self.jdc.etapes:
1511 if e.nom == etape : ouChercher=e; break
1512 if ouChercher==None : return
1514 for mot in listeAvant :
1515 ouChercher=ouChercher.get_child(mot,restreint="oui")
1516 if ouChercher==None : return
1517 monMC=ouChercher.get_child(MCFils,restreint="oui")
1518 if monMC== None : monMC= ouChercher.addentite(MCFils)
1520 monMC.definition.into=valeurs
1521 from Noyau.N_VALIDATOR import IntoProtocol
1522 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1523 monMC.state='changed'
1526 #-------------------------------------------------------------------#
1527 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1528 #-------------------------------------------------------------------#
1530 for e in self.jdc.etapes:
1531 if e.nom == nomEtape : ouChercher=e; break
1533 for mot in listeAvant :
1535 ouChercher=ouChercher.get_child(mot,restreint="oui")
1536 # Le mot clef n est pas la
1539 monMC=ouChercher.get_child(MCFils,restreint="oui")
1540 # Le mot clef n est pas la
1542 if monMC == None : return 0
1544 if hasattr(monMC.definition,'into') :
1545 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1546 else : maListeDeValeur=monMC.definition.into
1550 monMC.state='changed'
1553 #-------------------------------------#
1554 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1555 #-------------------------------------#
1558 #if isinstance (etape, str):
1559 # for e in self.jdc.etapes:
1560 # if e.nom == etape : etape=e; break
1561 #if etape == None : return
1562 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1563 ouChercher=definitionEtape
1564 if len(listeMC) > 1 :
1566 for mc in listeMC[0:-1]:
1567 mcfact=ouChercher.entites[mc]
1570 mcAccas=ouChercher.entites[listeMC[-1]]
1571 mcAccas.defaut=valeurs
1574 #------------------------------------------------#
1575 def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
1576 #------------------------------------------------#
1578 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1579 ouChercher=definitionEtape
1581 if len(listeMC) > 1 :
1582 for mc in listeMC[0:-1]:
1583 mcfact=ouChercher.entites[mc]
1585 mcAccas=ouChercher.entites[listeMC[-1]]
1587 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1588 else : oldValeurs=None
1589 if oldValeurs==valeurs : return 0
1591 mcAccas.into=valeurs
1592 from Noyau.N_VALIDATOR import IntoProtocol
1593 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1596 #-------------------------------------------------------------#
1597 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1598 #-------------------------------------------------------------#
1600 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1601 if isinstance (etape, str):
1602 for e in self.jdc.etapes:
1603 if e.nom == etape : etape=e; break
1604 if etape == None : return
1605 definitionEtape=getattr(self.jdc.cata[0],etape)
1606 ouChercher=definitionEtape
1607 for k in listeAvant :
1608 ouChercher=ouChercher.entites[k]
1609 MCADetruire=ouChercher.entites[nomDuMC]
1610 ouChercher.ordre_mc.remove(nomDuMC)
1611 print ('remove de ', nomDuMC)
1612 del ouChercher.entites[nomDuMC]
1613 del self.dicoNouveauxMC[nomDuMC]
1616 #-------------------------------------------------------------#
1617 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
1618 #-------------------------------------------------------------#
1620 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1621 ouChercher=definitionEtape
1622 for k in listeAvant :
1623 ouChercher=ouChercher.entites[k]
1624 from Accas import A_SIMP
1625 Nouveau=A_SIMP.SIMP(typ,**args)
1626 Nouveau.pere=ouChercher
1628 #Nouveau.ordre_mc=[]
1629 ouChercher.entites[nomDuMC]=Nouveau
1630 ouChercher.ordre_mc.append(nomDuMC)
1631 #print ('ajout de ', nomDuMC)
1632 #traceback.print_stack()
1633 # ajout CIST sauvegarde
1634 if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
1635 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
1636 #print self.dicoNouveauxMC
1638 #---------------------------------------------------------------------#
1639 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1640 #---------------------------------------------------------------------#
1642 print ('ajoutDefinitionMCFact', nomDuMC)
1643 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1644 ouChercher=definitionEtape
1645 for k in listeAvant :
1646 ouChercher=ouChercher.entites[k]
1647 from Accas import A_SIMP
1652 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1654 args[nomMC]=nouveauMC
1655 from Accas import A_FACT
1656 nouveauFact=A_FACT.FACT(**args)
1657 nouveauFact.pere=ouChercher
1658 nouveauFact.nom=nomDuMC
1659 from Editeur.autre_analyse_cata import traite_entite
1660 traite_entite(nouveauFact,[])
1661 ouChercher.entites[nomDuMC]=nouveauFact
1662 ouChercher.ordre_mc.append(nomDuMC)
1663 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1664 #print self.dicoNouveauxMC
1666 #----------------------------------------------------#
1668 #----------------------------------------------------#
1669 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
1670 #----------------------------------------------------#
1671 # dans le MDD et le JDC
1673 self.changeIntoDefMC(etape,listeMC,into)
1675 if isinstance (etape, str):
1676 for e in self.jdc.etapes:
1677 if e.nom == etape : etape=e; break
1678 if etape == None : return
1681 for mot in listeMC[:-1] :
1682 ouChercher=ouChercher.get_child(mot,restreint="oui")
1683 if ouChercher==None : return
1685 monMC=ouChercher.get_child(MCFils,restreint="oui")
1686 if monMC== None : monMC= etape.addentite(MCFils)
1688 monMC.definition.into=into
1689 monMC.valeur=valeurs
1691 monMC.state='changed'
1694 #-------------------------------------#
1695 def ajoutVersionCataDsJDC(self,txt):
1696 #-------------------------------------#
1697 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1698 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1699 texte=txt+ligneVersion
1702 #-------------------------------------#
1703 def verifieVersionCataDuJDC(self,text):
1704 #-------------------------------------#
1706 indexDeb=text.find("#VERSION_CATALOGUE:")
1707 indexFin=text.find(":FIN VERSION_CATALOGUE")
1709 self.versionCataDuJDC="sans"
1712 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1713 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1715 self.versionCata="sans"
1716 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1718 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1719 return memeVersion,textJDC
1721 #-------------------------------#
1722 def traduitCatalogue(self,texte):
1723 #-------------------------------#
1724 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1725 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1727 traducteur=__import__(nomTraducteur)
1728 monTraducteur=traducteur.MonTraducteur(texte)
1729 nouveauTexte=monTraducteur.traduit()
1735 #------------------------------#
1736 def verifieCHECKSUM(self,text):
1737 #------------------------------#
1738 indexDeb=text.find("#CHECKSUM:")
1741 indexFin=text.find(":FIN CHECKSUM")
1742 checkAvant=text[indexDeb:indexFin+13]
1743 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1744 if self.code != 'PSEN' and self.code != 'PSEN_N1':
1745 checksum=self.get_checksum(textJDC)
1746 pareil=(checkAvant==checksum)
1749 #if self.code=='PSEN'
1750 return pareil, textJDC
1752 #---------------------------#
1753 def get_checksum(self,texte):
1754 #---------------------------#
1755 newtexte=texte.replace('"','\\"')
1756 commande='echo "'+newtexte+'"|md5sum'
1757 a=os.popen(commande)
1760 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1764 #---------------------------#
1766 #---------------------------#
1767 texte="CONDUITE_FORCEE();"
1771 #---------------------------#
1772 def _newTELEMAC(self):
1773 #---------------------------#
1774 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1775 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1779 #---------------------------#
1781 #---------------------------#
1782 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1786 #---------------------------#
1787 def _newPSEN_N1(self):
1788 #---------------------------#
1789 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1790 #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1793 #---------------------------#
1795 #---------------------------#
1796 def _newZCRACKS(self):
1797 #---------------------------#
1798 texte="MAILLAGES();REMESHING();"
1801 #---------------------------#
1802 def _newJDCCND(self):
1803 #---------------------------#
1804 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1806 #if self.salome == 0 :
1807 QMessageBox.information( self,
1809 tr("Veuillez selectionner un fichier Med"))
1810 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1811 caption='Fichier Med',
1813 QSfichier=QSfichier[0]
1814 self.fichierMED=QSfichier
1815 from acquiertGroupes import getGroupes
1816 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1817 if erreur != "" : print ("a traiter")
1818 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1824 for groupe in self.listeGroupes :
1825 if groupe[0:8]=='CURRENT_':
1826 texteSources +=groupe[8:]+"=SOURCE("
1827 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1828 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1829 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1830 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1831 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1832 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1833 self.newTexteCND=texte
1838 #---------------------------#
1839 def BoutonFileSelected(self):
1840 #---------------------------#
1842 QSfichier=self.openfile.selectedFiles()[0]
1843 self.fichierMED=str(QSfichier)
1844 from acquiertGroupes import getGroupes
1845 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1846 if erreur != "" : print ("a traiter")
1848 #-----------------------------
1849 def BoutonSalomePressed(self):
1850 #----------------------------
1851 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1852 self.fichierMED="A_partir_de_SMESH"
1853 self.nomMaillage="A_partir_de_SMESH"
1854 self.openfile.close()
1857 #-----------------------------------------
1858 def initSplitterSizes(self, nbWidget=3):
1859 #-----------------------------------------
1860 #print ("je passe ds initSplitterSizes", nbWidget)
1862 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1863 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1864 else : self.splitterSizes3=[150,1000,300]
1866 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1867 else : self.splitterSizes2=[300,1000]
1871 #-----------------------------------------
1872 def restoreSplitterSizes(self,nbWidget=3):
1873 #----------------------------------------
1875 #traceback.print_stack()
1876 #print ("je passe ds restoreSplitterSizes")
1877 if not(hasattr(self,'splitter')) : return
1878 if nbWidget==2 : newSizes=self.splitterSizes2
1879 if nbWidget==3 : newSizes=self.splitterSizes3
1880 #self.inhibeSplitter = 1
1881 self.splitter.setSizes(newSizes)
1882 #self.inhibeSplitter = 0
1883 QApplication.processEvents()
1884 # seule la fentetre du milieu est necessaire
1885 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1887 #-----------------------------------------
1888 def saveSplitterSizes(self,event):
1889 #-----------------------------------------
1890 #print ("je passe ds saveSplitterSizes")
1891 if self.inhibeSplitter : return
1892 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1893 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1895 #------------------------
1896 def fermeOptionnel(self):
1897 #------------------------
1898 if self.widgetOptionnel == None : return
1900 self.inhibeSplitter=1
1901 self.widgetOptionnel.setParent(None)
1902 self.widgetOptionnel.close()
1903 self.widgetOptionnel.deleteLater()
1904 self.widgetOptionnel=None
1905 self.inhibeSplitter=0
1906 self.restoreSplitterSizes(2)
1908 #------------------------
1909 def ajoutOptionnel(self):
1910 #------------------------
1911 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1912 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1913 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1915 self.restoreSplitterSizes(3)
1918 #------------------------
1919 def fermeArbre(self):
1920 #------------------------
1921 #print (self.widgetTree)
1922 self.oldWidgetTree=self.widgetTree
1923 self.widgetTree.hide()
1924 #self.widgetTree=None
1926 #------------------------
1927 def ouvreArbre(self):
1928 #------------------------
1929 #print ('je passe la')
1930 #print (self.widgetTree)
1931 #self.widgetTree=self.oldWidgetTree
1932 self.widgetTree.show()
1933 #self.restoreSplitterSizes(3)
1935 #-----------------------------
1936 def getTreeIndex(self,noeud):
1937 #----------------------------
1939 if noeud in noeud.treeParent.children :
1940 indexNoeud=noeud.treeParent.children.index(noeud)
1942 if hasattr(noeud,'vraiParent') :
1944 noeudVraiParent = noeud.vraiParent
1945 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1946 noeudVrai = noeudVraiParent
1947 noeudVraiParent = noeudVraiParent.vraiParent
1949 if noeudVraiParent == noeud.treeParent :
1950 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1956 if __name__ == "__main__":
1958 name='prefs_'+prefs.code
1959 prefsCode=__import__(name)
1962 if hasattr(prefsCode,'encoding'):
1963 # Hack pour changer le codage par defaut des strings
1966 sys.setdefaultencoding(prefs.encoding)
1967 del sys.setdefaultencoding
1972 app = QApplication(sys.argv)
1973 mw = JDCEditor(None,'azAster.comm')
1974 app.setMainWidget(mw)
1975 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1978 res = app.exec_loop()