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'}
60 class JDCEditor(Ui_baseWidget,QWidget):
61 # ----------------------------------------- #
66 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
67 #----------------------------------------------------------------------------------------------------------#
69 QWidget.__init__(self,None)
73 self.widgetOptionnel=None
74 self.fenetreCentraleAffichee=None
75 self.dejaDansPlieTout=False
76 self.afficheCommandesPliees = True
77 self.listeDesListesOuvertes=set()
78 self.appliEficas = appli
79 self.appli = appli #---- attendu par IHM
81 self.fichier = fichier
84 self.QWParent = QWParent
85 self.couleur = Qt.black
89 self.salome = self.appliEficas.salome
92 print ("dans JDC pas d appli ????????")
94 # ces attributs sont mis a jour par definitCode appelee par newEditor
95 self.code = self.appliEficas.CONFIGURATION.code
96 self.initSplitterSizes()
98 #self.afficheListesPliees=False
99 self.afficheListesPliees=True
100 if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
101 if self.code == 'PSEN_N1' : self.afficheListesPliees = False
103 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
104 self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
105 self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
106 self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
107 self.affiche=self.appliEficas.CONFIGURATION.affiche
108 self.afficheOptionnelVide=self.appliEficas.CONFIGURATION.afficheOptionnelVide
109 self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
110 self.dicoImages = self.appliEficas.CONFIGURATION.dicoImages
111 self.simpleClic = self.appliEficas.CONFIGURATION.simpleClic
112 #self.taille = self.appliEficas.taille
114 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
115 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
116 if self.code in ['MAP',]:
117 self.widgetTree.close()
119 if self.closeArbre: self.fermeArbre()
121 self.version_code = session.d_env.cata
124 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
125 self.readercata = readercata.READERCATA( self, self.appliEficas )
126 self.appliEficas.readercata=self.readercata
127 self.appliEficas.code=self.code
129 self.readercata=self.appliEficas.readercata
130 if self.readercata.fic_cata == None : return #Sortie Salome
131 self.titre=self.readercata.titre
132 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
133 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
135 self.format = self.appliEficas.format_fichier
138 self.liste_simp_reel=[]
140 self.dicoNouveauxMC={}
141 self.dicoNouveauxFact={}
143 nameConf='configuration_'+self.code
144 configuration=__import__(nameConf)
145 self.CONFIGURATION = self.appliEficas.CONFIGURATION
146 self.CONFIGStyle = self.appliEficas.CONFIGStyle
149 self.CONFIGURATION.generator_module
150 _module = __import__(self.CONFIGURATION.generator_module)
151 info = _module.entryPoint()
152 generator.plugins.addEntryPoint(info)
157 self.CONFIGURATION.convert_module
158 #print self.CONFIGURATION.convert_module
159 _module = __import__(self.CONFIGURATION.convert_module)
160 info = _module.entryPoint()
161 convert.plugins.addEntryPoint(info)
166 if hasattr(self.appliEficas,"statusBar"):
167 self.sb = self.appliEficas.statusBar()
170 self.lastModified = 0
172 self.modified = False
173 self.isReadOnly = False
174 self.node_selected = []
177 if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
178 else : self.afficheApresInsert=False
179 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
180 else : self.enteteQTree='complet'
181 if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
182 else : self.affichePlie=False
184 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
186 #------- construction du jdc --------------
191 if self.fichier is not None: # fichier jdc fourni
192 self.fileInfo = QFileInfo(self.fichier)
193 self.fileInfo.setCaching(0)
196 self.jdc = self.readFile(self.fichier)
197 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
199 print ("mauvaise lecture")
202 if self.jdc is not None and units is not None:
203 self.jdc.recorded_units=units
204 self.jdc.old_recorded_units=units
206 if not self.jdc: # nouveau jdc
208 self.jdc = self._newJDC(units=units)
210 self.jdc = self._newJDCInclude(units=units)
214 self.jdc.appli = self # a resorber
215 self.jdc.editor = self
216 self.jdc.lang = self.appli.langue
217 self.jdc.aReafficher=False
221 txt_exception = self.jdc.cr.get_mess_exception()
224 QApplication.restoreOverrideCursor()
225 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
226 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
228 comploader.charger_composants("QT")
229 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
230 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
231 self.viewJdcRapport()
235 if jdc_item and self.appliEficas.ssIhm==False:
236 self.tree = browser.JDCTree( jdc_item, self )
237 self.appliEficas.construitMenu()
244 #-------------------# Pour execution avec output et error dans le bash
246 # #-------------------#
247 # #if self.modified or self.fichier==None : self.saveFile()
250 # #lancement avec le .bat
251 # path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
252 # WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
254 # p = subprocess.Popen(['python',WrapperFilePath])
255 # (out,err)=p.communicate()
262 # lancement avec le .bat
263 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../', '../', 'PSEN_Eficas', 'PSEN'))
264 filer = open('temp.txt', 'r')
271 if 'PF_PARAMETERS' in self.Ordre_Des_Commandes:
272 Python3_path = _path[2].replace('\n', '')
276 # 'PF_PARAMETERS' in self.readercata.Ordre_Des_Commandes
277 if 'PF_PARAMETERS' in self.Ordre_Des_Commandes:
278 WrapperFilePath = os.path.join(path1, 'PFWrapper.py')
279 p = subprocess.Popen([Python3_path + '/python.exe', WrapperFilePath])
281 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
282 p = subprocess.Popen(['python', WrapperFilePath])
283 (out, err) = p.communicate()
287 #-------------------# Pour execution avec output et error dans le bash
288 def runPSEN_N1(self):
289 #-------------------#
292 #cmd = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_N1','run.py'))
293 #cmd = "from run import runPSEN_N1; dico="+str(dico)
295 #textePython=("python "+ cmd + " "+ str(dico))
296 #self._viewTextExecute( textePython,"psen_run",".sh")
298 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
299 sys.path.append(path1)
301 if not(self.jdc.isvalid()):
302 QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
303 if generator.plugins.has_key('dicoImbrique'):
304 self.generator=generator.plugins['dicoImbrique']()
305 jdc_formate=self.generator.gener(self.jdc)
306 dico=self.generator.Dico
309 fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
310 f = open( str(fileDico), 'wb')
311 f.write("Dico =" + str(dico) )
314 if 'PSSE_path' in dico['CASE_SELECTION']:
316 #self.appliEficas.close()
318 elif 'PF_path' in dico['CASE_SELECTION']:
320 RunPFfile = os.path.join(path1, 'RunPF.py')
321 Python3_path=dico['CASE_SELECTION']['Python3_path']
322 p = subprocess.Popen([Python3_path + '/python.exe', RunPFfile])
326 #res,txt_exception=run(dico)
327 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
328 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
331 #-------------------# Pour execution avec output et error dans le bash
332 def process_N1(self):
333 #-------------------#
335 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
336 sys.path.append(path1)
339 if generator.plugins.has_key('dicoImbrique'):
340 self.generator=generator.plugins['dicoImbrique']()
341 jdc_formate=self.generator.gener(self.jdc)
342 dico=self.get_Dico() #generator.Dico
345 for k in dico['CONTINGENCY_PROCESSING'].keys():
347 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
348 newK=k.replace('___',' ')
350 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
351 del dico['CONTINGENCY_PROCESSING'][k]
354 fileDico = os.path.join(path1, 'dicoN1_process.py')
355 f = open( str(fileDico), 'wb')
356 f.write("Dico =" + str(dico) )
361 #return self.get_Dico()
363 #-------------------# Pour execution avec output et error dans le bash
364 def process_VP(self):
365 #-------------------#
366 if 'dicoImbrique' in generator.plugins:
367 self.generator=generator.plugins['dicoImbrique']()
368 jdc_formate=self.generator.gener(self.jdc)
369 dico=self.get_Dico() #generator.Dico
373 #--------------------------------#
374 def ajoutCommentaire(self):
375 #--------------------------------#
376 if self.tree.selectedItems()==[] :
377 QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
379 noeudAvantCommentaire=self.tree.selectedItems()[0]
380 if noeudAvantCommentaire ==self.tree.racine :
381 self.tree.racine.append_child("COMMENTAIRE",pos=0)
383 noeudAvantCommentaire.addComment(True)
387 #--------------------------------#
388 def _newJDC( self ,units = None):
389 #--------------------------------#
391 Initialise un nouveau JDC vierge
394 CONTEXT.unset_current_step()
397 if self.code == "CARMELCND" : texte=self._newJDCCND()
398 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
399 if self.code == "TELEMAC" : texte=self._newTELEMAC()
400 if self.code == "PSEN" : texte = self._newPSEN()
401 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
403 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
405 #if self.code == "CF" : texte = self._new_CF()
406 # texte=self.newTexteCND
408 jdc=self.readercata.cata[0].JdC( procedure =texte,
410 cata=self.readercata.cata,
411 cata_ord_dico=self.readercata.cata_ordonne_dico,
412 rep_mat=self.CONFIGURATION.rep_mat
414 jdc.lang = self.appli.langue
415 if units is not None:
416 jdc.recorded_units=units
417 jdc.old_recorded_units=units
418 ## PNPN est ce que la ligne suivante est bien utile ?
419 if texte == "" :jdc.analyse()
422 #--------------------------------#
423 def _newJDCInclude( self ,units = None):
424 #--------------------------------#
426 Initialise un nouveau JDC vierge
428 import Extensions.jdc_include
429 JdC_aux=Extensions.jdc_include.JdC_include
430 CONTEXT.unset_current_step()
432 jaux=self.readercata.cata[0].JdC( procedure="",
434 cata=self.readercata.cata,
435 cata_ord_dico=self.readercata.cata_ordonne_dico,
436 rep_mat=self.CONFIGURATION.rep_mat,
440 J=JdC_aux( procedure="",
442 cata=self.readercata.cata,
443 cata_ord_dico=self.readercata.cata_ordonne_dico,
445 rep_mat=self.CONFIGURATION.rep_mat,
448 if units is not None:
449 J.recorded_units=units
450 J.old_recorded_units=units
454 #-------------------------------#
455 def readFile(self, fn):
456 #--------------------------------#
458 Public slot to read the text from a file.
459 @param fn filename to read from (string or QString)
461 fn = six.text_type(fn)
463 # ------------------------------------------------------------------------------------
465 # ------------------------------------------------------------------------------------
467 jdcName=os.path.basename(fn)
468 # Il faut convertir le contenu du fichier en fonction du format
469 if self.appliEficas.format_fichier_in in convert.plugins:
470 # Le convertisseur existe on l'utilise
472 p=convert.plugins[self.appliEficas.format_fichier_in]()
474 if p.text=="" : self.nouveau=1
475 pareil,texteNew=self.verifieCHECKSUM(p.text)
477 if pareil == False and (self.appliEficas.ssIhm == False) :
478 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
480 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
481 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
483 text=p.convert('exec',self.appliEficas)
484 if not p.cr.estvide():
485 self.affiche_infos("Erreur a la conversion",Qt.red)
487 self.affiche_infos("Type de fichier non reconnu",Qt.red)
488 if self.appliEficas.ssIhm == False:
489 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
490 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
493 CONTEXT.unset_current_step()
494 jdc=self.readercata.cata[0].JdC(procedure=text,
496 cata=self.readercata.cata,
497 cata_ord_dico=self.readercata.cata_ordonne_dico,
499 rep_mat=self.CONFIGURATION.rep_mat
501 # ----------------------------------------------------
503 # ----------------------------------------------------
504 self.modified = False
506 # qApp.restoreOverrideCursor()
507 if self.fileInfo!= None :
508 self.lastModified = self.fileInfo.lastModified()
510 self.lastModified = 1
511 nouveauTitre=self.titre+" "+os.path.basename(self.fichier)
512 self.appliEficas.setWindowTitle(nouveauTitre)
516 #-----------------------#
517 def get_source(self,file):
518 #-----------------------#
520 # Il faut convertir le contenu du fichier en fonction du format
521 if self.format in convert.plugins :
522 # Le convertisseur existe on l'utilise
523 p=convert.plugins[self.format]()
525 text=p.convert('execnoparseur')
526 if not p.cr.estvide():
527 self.affiche_infos("Erreur a la conversion",Qt.red)
530 # Il n'existe pas c'est une erreur
531 self.affiche_infos("Type de fichier non reconnu",Qt.red)
532 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
535 #-----------------------------------------------------------------------#
536 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
537 #--------------------------------------------------------------------#
538 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
542 #----------------------------------------------#
543 def __generateTempFilename(self, prefix, suffix):
544 #----------------------------------------------#
546 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
552 #----------------------------------------------#
553 def _viewTextExecute(self, txt, prefix, suffix):
554 #----------------------------------------------#
555 self.w = ViewText( self.QWParent )
556 self.w.setWindowTitle( "execution" )
557 self.monExe=QProcess(self.w)
558 pid=self.monExe.pid()
559 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
560 f=open(nomFichier,'w')
563 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
564 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
565 exe='sh ' + nomFichier
566 self.monExe.start(exe)
567 self.monExe.closeWriteChannel()
570 commande="rm "+ nomFichier
575 def readFromStdErr(self):
576 a=self.monExe.readAllStandardError()
577 self.w.view.append(str(a.data()))
579 def readFromStdOut(self) :
580 a=self.monExe.readAllStandardOutput()
581 self.w.view.append(str(a.data()))
583 def readFromStdErrQT4(self):
584 a=self.monExe.readAllStandardError()
585 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
587 def readFromStdOutQT4(self) :
588 a=self.monExe.readAllStandardOutput()
589 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
591 #-----------------------#
593 #-----------------------#
594 if 'dico' in generator.plugins:
595 self.generator=generator.plugins['dico']()
596 jdc_formate=self.generator.gener(self.jdc)
597 dico=self.generator.Dico
600 #-----------------------#
601 def gestionParam(self):
602 #-----------------------#
603 w = MonWidgetCreeParam( self)
606 #-----------------------#
607 def viewJdcSource(self):
608 #-----------------------#
609 if self.fichier == None : return
610 f=open(self.fichier,'r')
613 self._viewText(texteSource, "JDC_SOURCE")
615 #-----------------------#
617 #-----------------------#
618 strSource = str( self.get_text_JDC(self.format) )
619 self._viewText(strSource, "JDC_RESULTAT")
621 #-----------------------#
622 def viewJdcRapport(self):
623 #-----------------------#
624 strRapport = six.text_type( self.jdc.report() )
625 # on ajoute les regles
627 self._viewText(strRapport, "JDC_RAPPORT")
629 #-----------------------#
630 def viewJdcRegles(self):
631 #-----------------------#
632 if self.tree :self.tree.AppelleBuildLBRegles()
639 Public method called by the viewmanager to finally get rid of us.
645 #----------------------------------------------#
646 def affiche_infos(self,message,couleur=Qt.black):
647 #----------------------------------------------#
649 mapalette=self.sb.palette()
650 mapalette.setColor( QPalette.WindowText, couleur )
651 self.sb.setPalette( mapalette );
652 self.sb.showMessage(message,4000)
655 #------------------------------#
656 def affiche_alerte(self,titre,message):
657 #------------------------------#
658 # appele par I_MACRO_ETAPE
659 QMessageBox.information( self, titre, message)
661 #-----------------------------------#
662 def affiche_commentaire(self,message):
663 #-----------------------------------#
664 self.labelCommentaire.setText(message)
665 QTimer.singleShot(6000, self.rendInvisible)
667 #----------------------#
668 def rendInvisible(self):
669 #----------------------#
670 self.labelCommentaire.setText("")
672 #-------------------#
673 def init_modif(self):
674 #-------------------#
676 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
677 si un JDC doit etre sauvegarde avant destruction ou non
681 #---------------------------------------#
682 def chercheNoeudSelectionne(self,copie=1):
683 #---------------------------------------#
685 appele par Cut et Copy pour positionner self.node_selected
687 self.node_selected=[]
688 if len(self.tree.selectedItems()) == 0 : return
689 self.node_selected=self.tree.selectedItems()
692 #---------------------#
693 def handleSupprimer(self):
694 #---------------------#
695 self.chercheNoeudSelectionne()
696 if len(self.node_selected) == 0 : return
697 self.QWParent.noeud_a_editer = []
698 if self.node_selected[0]==self.tree.racine: return
699 if len(self.node_selected) == 1 : self.node_selected[0].delete()
700 else : self.node_selected[0].deleteMultiple(self.node_selected)
702 #---------------------#
703 def handleRechercher(self):
704 #---------------------#
705 from .monRecherche import DRecherche
706 monRechercheDialg=DRecherche(parent=self,fl=0)
707 monRechercheDialg.show()
710 #--------------------------------#
711 def handleRechercherDsCatalogue(self):
712 #-----------------------------#
713 from .monRechercheCatalogue import DRechercheCatalogue
714 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
715 monRechercheDialg.show()
717 #---------------------#
718 def handleDeplier(self):
719 #---------------------#
720 if self.tree == None : return
721 #self.tree.collapseAll()
724 self.tree.expandItem(self.tree.topLevelItem(0))
726 if self.fenetreCentraleAffichee != None :
727 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
728 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
731 self.tree.expandItem(self.tree.topLevelItem(0))
733 if self.fenetreCentraleAffichee != None :
734 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
735 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
737 #---------------------#
738 def handleEditCut(self):
739 #---------------------#
741 Stocke dans Eficas.noeud_a_editer le noeud a couper
743 #print "handleEditCut"
744 self.chercheNoeudSelectionne()
745 self.QWParent.edit="couper"
746 self.QWParent.noeud_a_editer = self.node_selected
748 #-----------------------#
749 def handleEditCopy(self):
750 #-----------------------#
752 Stocke dans Eficas.noeud_a_editer le noeud a copier
754 self.chercheNoeudSelectionne()
755 if len(self.node_selected) == 0 : return
756 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
757 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
758 self.QWParent.edit="copier"
759 self.QWParent.noeud_a_editer = self.node_selected
761 #------------------------#
762 def handleEditPaste(self):
763 #------------------------#
765 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
766 Ne permet que la copie d'objets de type Commande ou MCF
768 self.chercheNoeudSelectionne()
769 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
770 QMessageBox.information( self,
771 tr("Copie impossible"),
772 tr("Veuillez selectionner un objet a copier"))
774 if len(self.node_selected) != 1 :
775 QMessageBox.information( self,
776 tr("Copie impossible"),
777 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
779 noeudOuColler=self.node_selected[0]
781 if len(self.QWParent.noeud_a_editer)!=1:
782 #self.handleEditPasteMultiple()
783 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
786 noeudACopier=self.QWParent.noeud_a_editer[0]
788 if (self.QWParent.edit != "couper"):
789 #print (noeudOuColler.item.parent.get_child(noeudOuColler.item.nom))
791 if noeudOuColler == self.tree.racine :
792 child=noeudOuColler.doPastePremier(noeudACopier)
794 child=noeudACopier.doPaste(noeudOuColler,'after')
796 if child==None or child==0:
797 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
799 self.affiche_infos("Copie refusee",Qt.red)
800 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
802 nom=noeudACopier.item.sd.nom
803 child.item.nomme_sd(nom)
810 traceback.print_exc()
811 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
813 self.affiche_infos("Copie refusee",Qt.red)
816 # il faut declarer le JDCDisplay_courant modifie
817 # suppression eventuelle du noeud selectionne
818 # si possible on renomme l objet comme le noeud couper
820 if (self.QWParent.edit == "couper"):
822 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
823 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
827 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
828 indexNoeudACopier=self.getTreeIndex(noeudACopier)
829 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
830 noeudACopier.treeParent.build_children()
835 self.QWParent.noeud_a_editer=[]
837 # on rend la copie a nouveau possible en liberant le flag edit
838 self.QWParent.edit="copier"
839 noeudACopier.select()
841 #----------------------------------#
842 def handleDeplaceMultiple(self):
843 #----------------------------------#
846 #----------------------------------#
847 def handleEditPasteMultiple(self):
848 #----------------------------------#
850 # On ne garde que les niveaux "Etape"
851 # On insere dans l'ordre du JDC
852 listeNoeudsACouper=[]
856 from InterfaceQT4 import compojdc
857 noeudOuColler=self.node_selected[0]
858 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
859 QMessageBox.information( self,
860 tr("Copie impossible a cet endroit",),
861 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
863 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
865 for noeud in self.QWParent.noeud_a_editer :
866 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
867 indexInTree=noeud.treeParent.children.index(noeud)
869 for index in listeIndex:
870 if index < indexInTree : indice = indice +1
871 listeIndex.insert(indice, indexInTree)
872 listeNoeudsACouper.insert(indice, noeud)
874 noeudJdc=noeudOuColler.treeParent
876 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
878 for index in listeIndex:
880 if indexNoeudOuColler < index:
881 indexTravail=indexTravail+dejaCrees
882 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
883 noeud=noeudJdc.children[indexTravail]
884 child=noeud.doPaste(noeudOuColler)
885 listeChild.append(child)
886 dejaCrees=dejaCrees+1
888 self.QWParent.noeud_a_editer = []
889 for i in range(len(listeIndex)):
890 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
891 self.QWParent.noeud_a_editer.append(noeud)
894 if self.QWParent.edit !="couper" : return
896 for index in listeIndex:
898 if indexNoeudOuColler < index:
899 indexTravail=indexTravail+(len(listeIndex))
900 noeud=noeudJdc.children[indexTravail]
902 listeItem.append(noeud.item)
903 listeASupprimer.append(noeud)
905 for i in range(len(listeChild)):
906 self.tree.item.suppitem(listeItem[i])
907 listeChild[i].item.update(listeItem[i])
909 self.QWParent.noeud_a_editer = []
912 #---------------------#
913 def getFileName(self):
914 #---------------------#
917 #---------------------------#
918 def get_file_variable(self) :
919 #---------------------------#
920 titre = tr("Choix d'un fichier XML")
921 texte = tr("Le fichier contient une commande MODEL\n")
922 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
923 QMessageBox.information( self, titre,tr(texte))
925 fichier = QFileDialog.getOpenFileName(self.appliEficas,
926 tr('Ouvrir Fichier'),
927 self.appliEficas.CONFIGURATION.savedir,
928 tr('Wrapper Files (*.xml);;''All Files (*)'))
931 #--------------------------------------------------#
932 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
933 #--------------------------------------------------#
935 Public slot to write the text to a file.
937 @param fn filename to write to string
938 @return flag indicating success
941 fn = six.text_type(fn)
944 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
946 if len(txt) >= len(eol):
947 if txt[-len(eol):] != eol:
951 txt=self.ajoutVersionCataDsJDC(txt)
952 checksum=self.get_checksum(txt)
954 if self.code=="TELEMAC" : return 1
960 except IOError as why:
961 if (self.appliEficas.ssIhm == False):
962 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
963 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
968 #-----------------------------------------------------------#
969 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
970 #-----------------------------------------------------------#
971 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
972 if format in generator.plugins:
974 # Le generateur existe on l'utilise
975 self.generator=generator.plugins[format]()
977 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
978 if pourRun : jdc_formate=self.generator.textePourRun
979 if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
980 except ValueError as e:
981 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
984 if not self.generator.cr.estvide():
985 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
986 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
991 # Il n'existe pas c'est une erreur
992 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
993 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
996 #----------------------#
998 #---------------------#
999 if 'dicoImbrique' in generator.plugins:
1000 self.generator=generator.plugins['dicoImbrique']()
1001 jdc_formate=self.generator.gener(self.jdc)
1002 dico=self.generator.Dico
1005 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1006 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1013 fonction="run"+self.code
1015 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
1020 fonction="saveRun"+self.code
1021 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
1027 if not(self.jdc.isvalid()):
1028 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
1030 if len(self.jdc.etapes) != 1 :
1031 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
1033 if self.modified or self.fichier==None :
1034 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1035 texte=self.get_text_JDC("MAP")
1036 self.writeFile( self.fichierMapInput, txt = texte)
1038 self.fichierMapInput=self.fichier
1039 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1042 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
1043 # then instantiate corresponding class and call getUseSalome() method
1045 from mapengine.spec import factory
1046 mapComponent = factory.new(composant)[0]
1049 if mapComponent.getUseSalome():
1050 command += " -r sappli"
1051 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
1053 #textePython="ls -l"
1054 self._viewTextExecute( textePython,"map_run",".sh")
1056 # commande="rm "+self.fichierMapInput
1057 # os.system(commande)
1060 except Exception as e:
1061 print((traceback.print_exc()))
1063 #-------------------#
1064 def runZCRACKS(self):
1065 #-------------------#
1066 if not(self.jdc.isvalid()):
1067 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1069 if self.modified or self.fichier==None :
1071 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1072 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1073 self.writeFile( self.fichierZcracksInput, txt = texte)
1075 self.fichierZcracksInput=self.fichier
1077 #commande ="Zrun -zp "
1079 textePython=(commande + self.fichierZcracksInput)
1080 self._viewTextExecute( textePython,"run_zcracks",".sh")
1081 except Exception as e:
1082 print((traceback.print_exc()))
1084 #-------------------#
1085 def runCARMELCND(self):
1086 #-------------------#
1087 #if not(self.jdc.isvalid()):
1088 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1090 if self.modified or self.fichier==None :
1091 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1093 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1094 from PrepareRunCarmel import prepareRunCarmel
1095 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1096 repMed=os.path.dirname(self.fichier)
1097 repExeCarmel=self.generator.get_repExeCarmel()
1098 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1099 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1100 f=open(nomFichier,'w')
1101 f.write(textePython)
1103 commande="xterm -e sh "+nomFichier +"\n"
1106 #-------------------#
1107 def runCarmelCS(self):
1108 #-------------------#
1110 commande="runSession pilotyacsCS.py"
1112 except Exception as e:
1113 print((traceback.print_exc()))
1115 #-----------------------------------------------------#
1116 def determineNomFichier(self,path,extension):
1117 #-----------------------------------------------------#
1118 if self.appli.code in DictExtensions:
1119 chaine1=DictExtensions[self.appli.code]+" (*."+DictExtensions[self.appli.code]+");;"
1120 extensions= tr(chaine1+ "All Files (*)")
1122 extensions= tr("JDC (*.comm);;" "All Files (*)")
1124 if self.appli.code == "MAP" :
1125 extensions = extensions + ";; Run (*.input);;"
1127 fn = QFileDialog.getSaveFileName( self,
1128 tr("sauvegarde"), path,
1130 QFileDialog.DontConfirmOverwrite)
1131 if fn == None : return (0, None)
1133 if fn=='': return (0, None)
1135 ext = QFileInfo(fn).suffix()
1136 if ext == '': fn+=extension
1138 if QFileInfo(fn).exists():
1139 msgBox = QMessageBox(self)
1140 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1141 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1142 msgBox.addButton(tr("&Ecraser"),0)
1143 msgBox.addButton(tr("&Abandonner"),1)
1144 abort=msgBox.exec_()
1145 if abort == 1 : return (0, "")
1149 def saveRunMAP(self):
1152 if not(self.jdc.isvalid()):
1153 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1154 tr("Un JdC valide est necessaire pour creer un .input")
1158 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1160 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1161 tr("Choix du composant obligatoire")
1164 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1168 if self.fichier is not None and self.fichier != "" :
1169 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1170 monPath=str(QFileInfo(self.fichier).absolutePath())
1171 monNomFichier=os.path.join(monPath,maBase)
1172 elif hasattr(self,'monNomFichierInput'):
1173 monNomFichier=self.monNomFichierInput
1176 monDialog=QFileDialog(self.appliEficas)
1177 monDialog.setDirectory (path)
1178 monDialog.setWindowTitle ("Save")
1180 for c in monDialog.children():
1181 if isinstance(c,QDialogButtonBox):
1182 for b in c.children():
1183 if isinstance(b,QPushButton):
1185 if avant=="&Open": b.setText("Save")
1186 mesFiltres= "input Map (*.input);;All Files (*)"
1187 monDialog.setNameFilters(mesFiltres)
1188 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1189 BOk=monDialog.exec_()
1191 fn=str(monDialog.selectedFiles()[0])
1192 if fn == "" or fn == None : return
1193 if not fn.endswith(".input"):
1195 self.monNomFichierInput=fn
1197 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1198 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1199 texte=self.get_text_JDC("MAP")
1200 self.writeFile( self.fichierMapInput, txt = texte)
1202 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1203 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1204 (output, err) = p.communicate()
1208 def saveRunPSEN(self):
1210 print( "saveRunPSEN")
1215 #-----------------------------------------#
1216 def cherche_Groupes(self):
1217 #-----------------------------------------#
1218 listeMA,listeNO=self.get_text_JDC("GroupMA")
1219 return listeMA,listeNO
1221 #-----------------------------------------#
1222 def cherche_Dico(self):
1223 #-----------------------------------------#
1225 format = self.appliEficas.format_fichier
1226 if format in generator.plugins:
1227 # Le generateur existe on l'utilise
1228 self.generator=generator.plugins[format]()
1229 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1230 dicoCourant=self.generator.dico
1235 #-----------------------------------------#
1236 def handleAjoutGroup(self,listeGroup):
1237 #-----------------------------------------#
1240 from ajoutGroupe import handleAjoutGroupFiltre
1242 handleAjoutGroupFiltre(self,listeGroup)
1243 #print "apres handleAjoutGroupFiltre"
1248 #-----------------------------------------------------------------#
1249 def saveFileLegerAs(self, fileName = None) :
1250 #-----------------------------------------------------------------#
1251 if fileName != None :
1252 self.fichier = fileName
1253 return self.saveFileLeger()
1254 return self.saveFileLeger()
1256 #-----------------------------------------------------------------#
1257 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1258 #-----------------------------------------------------------------#
1261 #saveas=True # Pour forcer le nom
1262 self.generator=generator.plugins[self.format]()
1263 if self.fichier is None or saveas:
1264 if path is None: path=self.CONFIGURATION.savedir
1265 bOK, fn=self.determineNomFichier(path,extension)
1266 if bOK == 0 : return (0, None)
1267 if fn == None : return (0, None)
1268 if fn== '' : return (0, None)
1270 ulfile = os.path.abspath(six.text_type(fn))
1271 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1272 fn = six.text_type(QDir.toNativeSeparators(fn))
1274 self.fichier = os.path.splitext(fn)[0]+extension
1276 if hasattr(self.generator, "writeLeger"):
1277 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1279 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1282 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1283 self.appliEficas.setWindowTitle(nouveauTitre)
1284 return (1, self.fichier)
1286 #-----------------------------------------------------------------#
1287 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1288 #-----------------------------------------------------------------#
1290 Public slot to save the text to a file.
1292 @param path directory to save the file in (string or QString)
1293 @return tuple of two values (boolean, string) giving a success indicator and
1294 the name of the saved file
1298 if not self.modified and not saveas:
1299 return (0, None) # do nothing if text wasn't changed
1301 if self.appli.code in DictExtensions :
1302 extension=DictExtensions[self.appli.code]
1308 if self.fichier is None or saveas:
1309 if path is None: path=self.CONFIGURATION.savedir
1310 bOK, fn=self.determineNomFichier(path,extension)
1311 if bOK == 0 : return (0, None)
1312 if fn == None : return (0, None)
1313 if fn== '' : return (0, None)
1315 ulfile = os.path.abspath(six.text_type(fn))
1316 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1317 fn = six.text_type(QDir.toNativeSeparators(fn))
1321 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1323 self.modified = False
1324 if self.fileInfo is None or saveas:
1325 self.fileInfo = QFileInfo(self.fichier)
1326 self.fileInfo.setCaching(0)
1327 self.lastModified = self.fileInfo.lastModified()
1328 if newName is not None:
1329 self.appliEficas.addToRecentList(newName)
1330 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1331 self.tree.racine.update_node_label()
1333 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1334 self.generator.writeDefault(fn)
1335 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1336 self.generator.writeDefault(fn)
1339 self.appliEficas.addJdcInSalome( self.fichier)
1341 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1342 self.appliEficas.setWindowTitle(nouveauTitre)
1344 return (1, self.fichier)
1347 #----------------------------------------------#
1348 def sauveLigneFile(self):
1349 #----------------------------------------------#
1351 return self.saveFile(formatLigne="Ligne")
1354 #----------------------------------------------#
1355 def saveFileAs(self, path = None,fileName=None):
1356 #----------------------------------------------#
1358 Public slot to save a file with a new name.
1360 @param path directory to save the file in (string or QString)
1361 @return tuple of two values (boolean, string) giving a success indicator and
1362 the name of the saved file
1364 if fileName != None :
1365 self.fichier = fileName
1366 return self.saveFile()
1367 return self.saveFile(path,1,"beautifie")
1371 #---------------------------------------------#
1372 def get_file(self,unite=None,fic_origine = ''):
1373 #---------------------------------------------#
1381 titre = tr("Choix unite %d ", unite)
1382 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1383 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1384 labeltexte = tr('Fichier pour unite ') + repr( unite)
1386 titre = tr("Choix d'un fichier de poursuite")
1387 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1388 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1390 QMessageBox.information( self, titre,texte)
1391 fn = QFileDialog.getOpenFileName(self.appliEficas,
1393 self.appliEficas.CONFIGURATION.savedir)
1395 # ce retour est impose par le get_file d'I_JDC
1396 if fn== '' : return None," "
1397 if not fn : return (0, " ")
1400 ulfile = os.path.abspath(six.text_type(fn))
1401 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1403 # On utilise le convertisseur defini par format_fichier
1404 source=self.get_source(ulfile)
1406 # On a reussia convertir le fichier self.ulfile
1409 # Une erreur a ete rencontree
1411 return ulfile, jdcText
1413 #-----------------------------------#
1414 def updateJdc(self, itemApres,texte):
1415 #------------------------------------#
1416 # ajoute une etape de JdC a partir d un texte
1418 etape=monItem.item.object
1419 CONTEXT.set_current_step(etape)
1420 etape.build_includeInclude(texte)
1421 self.tree.racine.build_children()
1423 #-----------------------------------#
1424 def updateJdcEtape(self, itemApres,texte):
1425 #------------------------------------#
1426 # ajoute une etape de JdC a partir d un texte
1428 etape=monItem.item.object
1429 CONTEXT.set_current_step(etape)
1431 ok=etape.build_includeEtape(texte)
1435 QMessageBox.information( self,
1437 tr("Impossible d importer le texte"))
1438 self.tree.racine.build_children()
1446 #----------------------------------------------#
1447 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
1448 #----------------------------------------------#
1450 print ('ajoutMCFact')
1453 for mot in listeAvant :
1454 ouChercher=ouChercher.get_child(mot,restreint="oui")
1457 monMC=etape.get_child(ouChercher,restreint="oui")
1458 if monMC== None : monMC= ouChercher.addentite(MCFils)
1461 #-------------------------------------#
1462 def getValeur(self,nomEtape,MCFils,listeAvant=()):
1463 #-------------------------------------#
1467 for e in self.jdc.etapes:
1468 if e.nom == nomEtape : ouChercher=e; break
1469 if ouChercher==None : return None
1470 for mot in listeAvant :
1471 ouChercher=ouChercher.get_child(mot,restreint="oui")
1472 #print (mot, ouChercher)
1473 if ouChercher==None : return None
1474 monMC=ouChercher.get_child(MCFils,restreint="oui")
1475 if monMC== None : return None
1478 #-----------------------------------------------------------#
1479 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
1480 #--------------------------------------------------------#
1484 for e in self.jdc.etapes:
1485 if e.nom == nomEtape : ouChercher=e; break
1486 if ouChercher==None : return None
1487 for mot in listeAvant :
1488 ouChercher=ouChercher.get_child(mot,restreint="oui")
1489 #print (mot, ouChercher)
1490 if ouChercher==None : return None
1491 monMC=ouChercher.get_child(MCFils,restreint="oui")
1492 monMC.set_valeur(valeur)
1496 #-------------------------------------#
1497 def deleteEtape(self,etape):
1498 #-------------------------------------#
1499 self.jdc.suppentite(etape)
1501 #-------------------------------------#
1502 def deleteMC(self,etape,MCFils,listeAvant=()):
1503 #-------------------------------------#
1505 for mot in listeAvant :
1506 ouChercher=ouChercher.get_child(mot,restreint="oui")
1507 monMC=ouChercher.get_child(MCFils,restreint="oui")
1508 if monMC != None : ouChercher.suppentite(monMC)
1509 ouChercher.state='changed'
1510 ouChercher.isvalid()
1512 #-------------------------------------#
1513 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1514 #-------------------------------------#
1515 print('debut ajoutMC')
1517 for mot in listeAvant :
1518 ouChercher=ouChercher.get_child(mot,restreint="oui")
1519 monMC=etape.get_child(ouChercher,restreint="oui")
1521 if monMC== None : monMC= ouChercher.addentite(MCFils)
1522 monMC.valeur=valeurs
1524 monMC.state='changed'
1529 #-----------------------------------------------------------#
1530 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1531 #-----------------------------------------------------------#
1533 for mot in listeAvant :
1534 ouChercher=ouChercher.get_child(mot,restreint="oui")
1535 if ouChercher ==None : print( 'SOUCI'); return
1536 monMC=ouChercher.get_child(MCFils,restreint="oui")
1537 if monMC== None : monMC= ouChercher.addentite(MCFils)
1538 monMC.definition.into=valeurs
1539 monMC.state='changed'
1542 #-------------------------------------#
1543 def changeIntoDefMC(self,etape,listeMC,valeurs):
1544 #-------------------------------------#
1545 definitionEtape=getattr(self.jdc.cata[0],etape)
1546 ouChercher=definitionEtape
1547 if len(listeMC) > 1 :
1548 for mc in listeMC[0:-1]:
1549 mcfact=ouChercher.entites[mc]
1552 mcAccas=ouChercher.entites[listeMC[-1]]
1553 mcAccas.into=valeurs
1555 #-------------------------------------------------------------#
1556 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1557 #-------------------------------------------------------------#
1558 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1559 definitionEtape=getattr(self.jdc.cata[0],etape)
1560 ouChercher=definitionEtape
1561 for k in listeAvant :
1562 ouChercher=ouChercher.entites[k]
1563 MCADetruire=ouChercher.entites[nomDuMC]
1564 ouChercher.ordre_mc.remove(nomDuMC)
1565 del ouChercher.entites[nomDuMC]
1566 del self.dicoNouveauxMC[nomDuMC]
1569 #-------------------------------------------------------------#
1570 def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1571 #-------------------------------------------------------------#
1572 print('debut ajoutDefinitionMC')
1573 definitionEtape=getattr(self.jdc.cata[0],etape)
1574 ouChercher=definitionEtape
1575 for k in listeAvant :
1576 ouChercher=ouChercher.entites[k]
1577 from Accas import A_SIMP
1578 Nouveau=A_SIMP.SIMP(typ,**args)
1579 Nouveau.pere=ouChercher
1582 ouChercher.entites[nomDuMC]=Nouveau
1583 ouChercher.ordre_mc.append(nomDuMC)
1584 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1585 print( self.dicoNouveauxMC)
1586 print('fin ajoutDefinitionMC')
1588 #----------------------------------------------------#
1589 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1590 #----------------------------------------------------#
1591 monMC=etape.get_child(MCFils,restreint="oui")
1592 if monMC== None : monMC= etape.addentite(MCFils)
1593 monMC.definition.into=into
1594 monMC.valeur=valeurs
1596 monMC.state='changed'
1602 #-------------------------------------------------------------------#
1603 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1604 #-------------------------------------------------------------------#
1606 for e in self.jdc.etapes:
1607 if e.nom == nomEtape : ouChercher=e; break
1609 for mot in listeAvant :
1611 ouChercher=ouChercher.get_child(mot,restreint="oui")
1612 # Le mot clef n est pas la
1615 monMC=ouChercher.get_child(MCFils,restreint="oui")
1616 # Le mot clef n est pas la
1618 if monMC == None : return 0
1620 if hasattr(monMC.definition,'into') :
1621 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1622 else : maListeDeValeur=monMC.definition.into
1626 monMC.state='changed'
1629 #-------------------------------------#
1630 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1631 #-------------------------------------#
1634 #if isinstance (etape, str):
1635 # for e in self.jdc.etapes:
1636 # if e.nom == etape : etape=e; break
1637 #if etape == None : return
1638 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1639 ouChercher=definitionEtape
1640 if len(listeMC) > 1 :
1642 for mc in listeMC[0:-1]:
1643 mcfact=ouChercher.entites[mc]
1646 mcAccas=ouChercher.entites[listeMC[-1]]
1647 mcAccas.defaut=valeurs
1653 #---------------------------------------------------------------------#
1654 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1655 #---------------------------------------------------------------------#
1657 print ('ajoutDefinitionMCFact', nomDuMC)
1658 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1659 ouChercher=definitionEtape
1660 for k in listeAvant :
1661 ouChercher=ouChercher.entites[k]
1662 from Accas import A_SIMP
1667 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1669 args[nomMC]=nouveauMC
1670 from Accas import A_FACT
1671 nouveauFact=A_FACT.FACT(**args)
1672 nouveauFact.pere=ouChercher
1673 nouveauFact.nom=nomDuMC
1674 from Editeur.autre_analyse_cata import traite_entite
1675 traite_entite(nouveauFact,[])
1676 ouChercher.entites[nomDuMC]=nouveauFact
1677 ouChercher.ordre_mc.append(nomDuMC)
1678 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1679 #print self.dicoNouveauxMC
1683 #-------------------------------------#
1684 def ajoutVersionCataDsJDC(self,txt):
1685 #-------------------------------------#
1686 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1687 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1688 texte=txt+ligneVersion
1691 #-------------------------------------#
1692 def verifieVersionCataDuJDC(self,text):
1693 #-------------------------------------#
1695 indexDeb=text.find("#VERSION_CATALOGUE:")
1696 indexFin=text.find(":FIN VERSION_CATALOGUE")
1698 self.versionCataDuJDC="sans"
1701 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1702 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1704 self.versionCata="sans"
1705 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1707 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1708 return memeVersion,textJDC
1710 #-------------------------------#
1711 def traduitCatalogue(self,texte):
1712 #-------------------------------#
1713 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1714 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1716 traducteur=__import__(nomTraducteur)
1717 monTraducteur=traducteur.MonTraducteur(texte)
1718 nouveauTexte=monTraducteur.traduit()
1724 #------------------------------#
1725 def verifieCHECKSUM(self,text):
1726 #------------------------------#
1727 indexDeb=text.find("#CHECKSUM:")
1730 indexFin=text.find(":FIN CHECKSUM")
1731 checkAvant=text[indexDeb:indexFin+13]
1732 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1733 checksum=self.get_checksum(textJDC)
1734 pareil=(checkAvant==checksum)
1735 return pareil, textJDC
1737 #---------------------------#
1738 def get_checksum(self,texte):
1739 #---------------------------#
1740 newtexte=texte.replace('"','\\"')
1741 commande='echo "'+newtexte+'"|md5sum'
1742 a=os.popen(commande)
1745 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1749 #---------------------------#
1751 #---------------------------#
1752 texte="CONDUITE_FORCEE();"
1756 #---------------------------#
1757 def _newTELEMAC(self):
1758 #---------------------------#
1759 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1760 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1764 #---------------------------#
1766 #---------------------------#
1767 if 'PF_PARAMETERS' in self.Ordre_Des_Commandes:
1768 texte = "DIRECTORY() ;PF_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1770 texte = "DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1774 #---------------------------#
1775 def _newPSEN_N1(self):
1776 #---------------------------#
1777 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1778 #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1781 #---------------------------#
1783 #---------------------------#
1784 def _newZCRACKS(self):
1785 #---------------------------#
1786 texte="MAILLAGES();REMESHING();"
1789 #---------------------------#
1790 def _newJDCCND(self):
1791 #---------------------------#
1792 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1794 #if self.salome == 0 :
1795 QMessageBox.information( self,
1797 tr("Veuillez selectionner un fichier Med"))
1798 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1799 caption='Fichier Med',
1801 QSfichier=QSfichier[0]
1802 self.fichierMED=QSfichier
1803 from acquiertGroupes import getGroupes
1804 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1805 if erreur != "" : print ("a traiter")
1806 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1812 for groupe in self.listeGroupes :
1813 if groupe[0:8]=='CURRENT_':
1814 texteSources +=groupe[8:]+"=SOURCE("
1815 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1816 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1817 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1818 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1819 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1820 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1821 self.newTexteCND=texte
1826 #---------------------------#
1827 def BoutonFileSelected(self):
1828 #---------------------------#
1830 QSfichier=self.openfile.selectedFiles()[0]
1831 self.fichierMED=str(QSfichier)
1832 from acquiertGroupes import getGroupes
1833 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1834 if erreur != "" : print ("a traiter")
1836 #-----------------------------
1837 def BoutonSalomePressed(self):
1838 #----------------------------
1839 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1840 self.fichierMED="A_partir_de_SMESH"
1841 self.nomMaillage="A_partir_de_SMESH"
1842 self.openfile.close()
1845 #-----------------------------------------
1846 def initSplitterSizes(self, nbWidget=3):
1847 #-----------------------------------------
1848 #print ("je passe ds initSplitterSizes", nbWidget)
1850 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1851 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1852 else : self.splitterSizes3=[150,1000,300]
1854 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1855 else : self.splitterSizes2=[300,1000]
1859 #-----------------------------------------
1860 def restoreSplitterSizes(self,nbWidget=3):
1861 #----------------------------------------
1863 #traceback.print_stack()
1864 #print ("je passe ds restoreSplitterSizes")
1865 if not(hasattr(self,'splitter')) : return
1866 if nbWidget==2 : newSizes=self.splitterSizes2
1867 if nbWidget==3 : newSizes=self.splitterSizes3
1868 #self.inhibeSplitter = 1
1869 self.splitter.setSizes(newSizes)
1870 #self.inhibeSplitter = 0
1871 QApplication.processEvents()
1872 # seule la fentetre du milieu est necessaire
1873 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1875 #-----------------------------------------
1876 def saveSplitterSizes(self,event):
1877 #-----------------------------------------
1878 #print ("je passe ds saveSplitterSizes")
1879 if self.inhibeSplitter : return
1880 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1881 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1883 #------------------------
1884 def fermeOptionnel(self):
1885 #------------------------
1886 if self.widgetOptionnel == None : return
1888 self.inhibeSplitter=1
1889 self.widgetOptionnel.setParent(None)
1890 self.widgetOptionnel.close()
1891 self.widgetOptionnel.deleteLater()
1892 self.widgetOptionnel=None
1893 self.inhibeSplitter=0
1894 self.restoreSplitterSizes(2)
1896 #------------------------
1897 def ajoutOptionnel(self):
1898 #------------------------
1899 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1900 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1901 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1903 self.restoreSplitterSizes(3)
1906 #------------------------
1907 def fermeArbre(self):
1908 #------------------------
1909 #print (self.widgetTree)
1910 self.oldWidgetTree=self.widgetTree
1911 self.widgetTree.hide()
1912 #self.widgetTree=None
1914 #------------------------
1915 def ouvreArbre(self):
1916 #------------------------
1917 #print ('je passe la')
1918 #print (self.widgetTree)
1919 #self.widgetTree=self.oldWidgetTree
1920 self.widgetTree.show()
1921 #self.restoreSplitterSizes(3)
1923 #-----------------------------
1924 def getTreeIndex(self,noeud):
1925 #----------------------------
1927 if noeud in noeud.treeParent.children :
1928 indexNoeud=noeud.treeParent.children.index(noeud)
1930 if hasattr(noeud,'vraiParent') :
1932 noeudVraiParent = noeud.vraiParent
1933 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1934 noeudVrai = noeudVraiParent
1935 noeudVraiParent = noeudVraiParent.vraiParent
1937 if noeudVraiParent == noeud.treeParent :
1938 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1944 if __name__ == "__main__":
1946 name='prefs_'+prefs.code
1947 prefsCode=__import__(name)
1950 if hasattr(prefsCode,'encoding'):
1951 # Hack pour changer le codage par defaut des strings
1954 sys.setdefaultencoding(prefs.encoding)
1955 del sys.setdefaultencoding
1960 app = QApplication(sys.argv)
1961 mw = JDCEditor(None,'azAster.comm')
1962 app.setMainWidget(mw)
1963 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1966 res = app.exec_loop()