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" : '.comm'}
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)
198 print ("mauvaise lecture")
201 if self.jdc is not None and units is not None:
202 self.jdc.recorded_units=units
203 self.jdc.old_recorded_units=units
205 if not self.jdc: # nouveau jdc
207 self.jdc = self._newJDC(units=units)
209 self.jdc = self._newJDCInclude(units=units)
213 self.jdc.appli = self # a resorber
214 self.jdc.editor = self
215 self.jdc.lang = self.appli.langue
216 self.jdc.aReafficher=False
220 txt_exception = self.jdc.cr.get_mess_exception()
223 QApplication.restoreOverrideCursor()
224 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
225 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
227 comploader.charger_composants("QT")
228 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
229 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
230 self.viewJdcRapport()
234 if jdc_item and self.appliEficas.ssIhm==False:
235 self.tree = browser.JDCTree( jdc_item, self )
236 self.appliEficas.construitMenu()
243 #-------------------# Pour execution avec output et error dans le bash
245 #-------------------#
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()
259 #-------------------# Pour execution avec output et error dans le bash
260 def runPSEN_N1(self):
261 #-------------------#
265 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
266 sys.path.append(path1)
268 if not(self.jdc.isvalid()):
269 QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
270 if 'dicoImbrique' in generator.plugins:
271 self.generator=generator.plugins['dicoImbrique']()
272 jdc_formate=self.generator.gener(self.jdc)
273 dico=self.generator.Dico
276 #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
277 fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
278 f = open( str(fileDico), 'w')
279 f.write("Dico =" + str(dico) )
284 #print ('in runPSEN_N1', dico)
287 #res,txt_exception=run(dico)
288 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
289 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
291 #-------------------# Pour execution avec output et error dans le bash
292 def process_N1(self):
293 #-------------------#
295 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
296 sys.path.append(path1)
299 if 'dicoImbrique' in generator.plugins:
300 self.generator=generator.plugins['dicoImbrique']()
301 jdc_formate=self.generator.gener(self.jdc)
302 dico=self.get_Dico() #generator.Dico
305 for k in dico['CONTINGENCY_PROCESSING']:
307 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
308 newK=k.replace('___',' ')
310 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
311 del dico['CONTINGENCY_PROCESSING'][k]
314 fileDico = os.path.join(path1, 'dicoN1_process.py')
315 f = open( str(fileDico), 'w')
316 f.write("Dico =" + str(dico) )
321 #return self.get_Dico()
323 #-------------------# Pour execution avec output et error dans le bash
324 def process_VP(self):
325 #-------------------#
326 if 'dicoImbrique' in generator.plugins:
327 self.generator=generator.plugins['dicoImbrique']()
328 jdc_formate=self.generator.gener(self.jdc)
329 dico=self.get_Dico() #generator.Dico
333 #--------------------------------#
334 def ajoutCommentaire(self):
335 #--------------------------------#
336 if self.tree.selectedItems()==[] :
337 QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
339 noeudAvantCommentaire=self.tree.selectedItems()[0]
340 if noeudAvantCommentaire ==self.tree.racine :
341 self.tree.racine.append_child("COMMENTAIRE",pos=0)
343 noeudAvantCommentaire.addComment(True)
347 #--------------------------------#
348 def _newJDC( self ,units = None):
349 #--------------------------------#
351 Initialise un nouveau JDC vierge
354 CONTEXT.unset_current_step()
357 if self.code == "CARMELCND" : texte=self._newJDCCND()
358 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
359 if self.code == "TELEMAC" : texte=self._newTELEMAC()
360 if self.code == "PSEN" : texte = self._newPSEN()
361 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
363 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
365 #if self.code == "CF" : texte = self._new_CF()
366 # texte=self.newTexteCND
368 jdc=self.readercata.cata[0].JdC( procedure =texte,
370 cata=self.readercata.cata,
371 cata_ord_dico=self.readercata.cata_ordonne_dico,
372 rep_mat=self.CONFIGURATION.rep_mat
374 jdc.lang = self.appli.langue
375 if units is not None:
376 jdc.recorded_units=units
377 jdc.old_recorded_units=units
378 ## PNPN est ce que la ligne suivante est bien utile ?
379 if texte == "" :jdc.analyse()
382 #--------------------------------#
383 def _newJDCInclude( self ,units = None):
384 #--------------------------------#
386 Initialise un nouveau JDC vierge
388 import Extensions.jdc_include
389 JdC_aux=Extensions.jdc_include.JdC_include
390 CONTEXT.unset_current_step()
392 jaux=self.readercata.cata[0].JdC( procedure="",
394 cata=self.readercata.cata,
395 cata_ord_dico=self.readercata.cata_ordonne_dico,
396 rep_mat=self.CONFIGURATION.rep_mat,
400 J=JdC_aux( procedure="",
402 cata=self.readercata.cata,
403 cata_ord_dico=self.readercata.cata_ordonne_dico,
405 rep_mat=self.CONFIGURATION.rep_mat,
408 if units is not None:
409 J.recorded_units=units
410 J.old_recorded_units=units
414 #-------------------------------#
415 def readFile(self, fn):
416 #--------------------------------#
418 Public slot to read the text from a file.
419 @param fn filename to read from (string or QString)
421 fn = six.text_type(fn)
423 # ------------------------------------------------------------------------------------
425 # ------------------------------------------------------------------------------------
427 jdcName=os.path.basename(fn)
428 # Il faut convertir le contenu du fichier en fonction du format
429 if self.appliEficas.format_fichier_in in convert.plugins:
430 # Le convertisseur existe on l'utilise
432 p=convert.plugins[self.appliEficas.format_fichier_in]()
434 if p.text=="" : self.nouveau=1
435 pareil,texteNew=self.verifieCHECKSUM(p.text)
437 if pareil == False and (self.appliEficas.ssIhm == False) :
438 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
440 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
441 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
443 text=p.convert('exec',self.appliEficas)
444 if not p.cr.estvide():
445 self.affiche_infos("Erreur a la conversion",Qt.red)
447 self.affiche_infos("Type de fichier non reconnu",Qt.red)
448 if self.appliEficas.ssIhm == False:
449 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
450 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
453 CONTEXT.unset_current_step()
454 jdc=self.readercata.cata[0].JdC(procedure=text,
456 cata=self.readercata.cata,
457 cata_ord_dico=self.readercata.cata_ordonne_dico,
459 rep_mat=self.CONFIGURATION.rep_mat
461 # ----------------------------------------------------
463 # ----------------------------------------------------
464 self.modified = False
466 # qApp.restoreOverrideCursor()
467 if self.fileInfo!= None :
468 self.lastModified = self.fileInfo.lastModified()
470 self.lastModified = 1
471 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
472 self.appliEficas.setWindowTitle(nouveauTitre)
476 #-----------------------#
477 def get_source(self,file):
478 #-----------------------#
480 # Il faut convertir le contenu du fichier en fonction du format
481 if self.format in convert.plugins :
482 # Le convertisseur existe on l'utilise
483 p=convert.plugins[self.format]()
485 text=p.convert('execnoparseur')
486 if not p.cr.estvide():
487 self.affiche_infos("Erreur a la conversion",Qt.red)
490 # Il n'existe pas c'est une erreur
491 self.affiche_infos("Type de fichier non reconnu",Qt.red)
492 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
495 #-----------------------------------------------------------------------#
496 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
497 #--------------------------------------------------------------------#
498 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
502 #----------------------------------------------#
503 def __generateTempFilename(self, prefix, suffix):
504 #----------------------------------------------#
506 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
512 #----------------------------------------------#
513 def _viewTextExecute(self, txt, prefix, suffix):
514 #----------------------------------------------#
515 self.w = ViewText( self.QWParent )
516 self.w.setWindowTitle( "execution" )
517 self.monExe=QProcess(self.w)
518 pid=self.monExe.pid()
519 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
520 f=open(nomFichier,'w')
523 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
524 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
525 exe='sh ' + nomFichier
526 self.monExe.start(exe)
527 self.monExe.closeWriteChannel()
530 commande="rm "+ nomFichier
535 def readFromStdErr(self):
536 a=self.monExe.readAllStandardError()
537 self.w.view.append(str(a.data()))
539 def readFromStdOut(self) :
540 a=self.monExe.readAllStandardOutput()
541 self.w.view.append(str(a.data()))
543 def readFromStdErrQT4(self):
544 a=self.monExe.readAllStandardError()
545 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
547 def readFromStdOutQT4(self) :
548 a=self.monExe.readAllStandardOutput()
549 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
551 #-----------------------#
553 #-----------------------#
554 if 'dico' in generator.plugins:
555 self.generator=generator.plugins['dico']()
556 jdc_formate=self.generator.gener(self.jdc)
557 dico=self.generator.Dico
560 #-----------------------#
561 def gestionParam(self):
562 #-----------------------#
563 w = MonWidgetCreeParam( self)
566 #-----------------------#
567 def viewJdcSource(self):
568 #-----------------------#
569 if self.fichier == None : return
570 f=open(self.fichier,'r')
573 self._viewText(texteSource, "JDC_SOURCE")
575 #-----------------------#
577 #-----------------------#
578 strSource = str( self.get_text_JDC(self.format) )
579 self._viewText(strSource, "JDC_RESULTAT")
581 #-----------------------#
582 def viewJdcRapport(self):
583 #-----------------------#
584 strRapport = six.text_type( self.jdc.report() )
585 # on ajoute les regles
587 self._viewText(strRapport, "JDC_RAPPORT")
589 #-----------------------#
590 def viewJdcRegles(self):
591 #-----------------------#
592 if self.tree :self.tree.AppelleBuildLBRegles()
599 Public method called by the viewmanager to finally get rid of us.
605 #----------------------------------------------#
606 def affiche_infos(self,message,couleur=Qt.black):
607 #----------------------------------------------#
609 mapalette=self.sb.palette()
610 mapalette.setColor( QPalette.WindowText, couleur )
611 self.sb.setPalette( mapalette );
612 self.sb.showMessage(message,4000)
615 #------------------------------#
616 def affiche_alerte(self,titre,message):
617 #------------------------------#
618 # appele par I_MACRO_ETAPE
619 QMessageBox.information( self, titre, message)
621 #-----------------------------------#
622 def affiche_commentaire(self,message):
623 #-----------------------------------#
624 self.labelCommentaire.setText(message)
625 QTimer.singleShot(6000, self.rendInvisible)
627 #----------------------#
628 def rendInvisible(self):
629 #----------------------#
630 self.labelCommentaire.setText("")
632 #-------------------#
633 def init_modif(self):
634 #-------------------#
636 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
637 si un JDC doit etre sauvegarde avant destruction ou non
641 #---------------------------------------#
642 def chercheNoeudSelectionne(self,copie=1):
643 #---------------------------------------#
645 appele par Cut et Copy pour positionner self.node_selected
647 self.node_selected=[]
648 if len(self.tree.selectedItems()) == 0 : return
649 self.node_selected=self.tree.selectedItems()
652 #---------------------#
653 def handleSupprimer(self):
654 #---------------------#
655 self.chercheNoeudSelectionne()
656 if len(self.node_selected) == 0 : return
657 self.QWParent.noeud_a_editer = []
658 if self.node_selected[0]==self.tree.racine: return
659 if len(self.node_selected) == 1 : self.node_selected[0].delete()
660 else : self.node_selected[0].deleteMultiple(self.node_selected)
662 #---------------------#
663 def handleRechercher(self):
664 #---------------------#
665 from .monRecherche import DRecherche
666 monRechercheDialg=DRecherche(parent=self,fl=0)
667 monRechercheDialg.show()
670 #--------------------------------#
671 def handleRechercherDsCatalogue(self):
672 #-----------------------------#
673 from .monRechercheCatalogue import DRechercheCatalogue
674 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
675 monRechercheDialg.show()
677 #---------------------#
678 def handleDeplier(self):
679 #---------------------#
680 if self.tree == None : return
681 #self.tree.collapseAll()
684 self.tree.expandItem(self.tree.topLevelItem(0))
686 if self.fenetreCentraleAffichee != None :
687 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
688 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
691 self.tree.expandItem(self.tree.topLevelItem(0))
693 if self.fenetreCentraleAffichee != None :
694 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
695 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
697 #---------------------#
698 def handleEditCut(self):
699 #---------------------#
701 Stocke dans Eficas.noeud_a_editer le noeud a couper
703 #print "handleEditCut"
704 self.chercheNoeudSelectionne()
705 self.QWParent.edit="couper"
706 self.QWParent.noeud_a_editer = self.node_selected
708 #-----------------------#
709 def handleEditCopy(self):
710 #-----------------------#
712 Stocke dans Eficas.noeud_a_editer le noeud a copier
714 self.chercheNoeudSelectionne()
715 if len(self.node_selected) == 0 : return
716 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
717 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
718 self.QWParent.edit="copier"
719 self.QWParent.noeud_a_editer = self.node_selected
721 #------------------------#
722 def handleEditPaste(self):
723 #------------------------#
725 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
726 Ne permet que la copie d'objets de type Commande ou MCF
728 self.chercheNoeudSelectionne()
729 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
730 QMessageBox.information( self,
731 tr("Copie impossible"),
732 tr("Veuillez selectionner un objet a copier"))
734 if len(self.node_selected) != 1 :
735 QMessageBox.information( self,
736 tr("Copie impossible"),
737 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
739 noeudOuColler=self.node_selected[0]
741 if len(self.QWParent.noeud_a_editer)!=1:
742 #self.handleEditPasteMultiple()
743 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
746 noeudACopier=self.QWParent.noeud_a_editer[0]
748 if (self.QWParent.edit != "couper"):
749 #print (noeudOuColler.item.parent.get_child(noeudOuColler.item.nom))
751 if noeudOuColler == self.tree.racine :
752 child=noeudOuColler.doPastePremier(noeudACopier)
754 child=noeudACopier.doPaste(noeudOuColler,'after')
756 if child==None or child==0:
757 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
759 self.affiche_infos("Copie refusee",Qt.red)
760 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
762 nom=noeudACopier.item.sd.nom
763 child.item.nomme_sd(nom)
770 traceback.print_exc()
771 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
773 self.affiche_infos("Copie refusee",Qt.red)
776 # il faut declarer le JDCDisplay_courant modifie
777 # suppression eventuelle du noeud selectionne
778 # si possible on renomme l objet comme le noeud couper
780 if (self.QWParent.edit == "couper"):
782 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
783 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
787 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
788 indexNoeudACopier=self.getTreeIndex(noeudACopier)
789 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
790 noeudACopier.treeParent.build_children()
795 self.QWParent.noeud_a_editer=[]
797 # on rend la copie a nouveau possible en liberant le flag edit
798 self.QWParent.edit="copier"
799 noeudACopier.select()
801 #----------------------------------#
802 def handleDeplaceMultiple(self):
803 #----------------------------------#
806 #----------------------------------#
807 def handleEditPasteMultiple(self):
808 #----------------------------------#
810 # On ne garde que les niveaux "Etape"
811 # On insere dans l'ordre du JDC
812 listeNoeudsACouper=[]
816 from InterfaceQT4 import compojdc
817 noeudOuColler=self.node_selected[0]
818 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
819 QMessageBox.information( self,
820 tr("Copie impossible a cet endroit",),
821 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
823 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
825 for noeud in self.QWParent.noeud_a_editer :
826 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
827 indexInTree=noeud.treeParent.children.index(noeud)
829 for index in listeIndex:
830 if index < indexInTree : indice = indice +1
831 listeIndex.insert(indice, indexInTree)
832 listeNoeudsACouper.insert(indice, noeud)
834 noeudJdc=noeudOuColler.treeParent
836 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
838 for index in listeIndex:
840 if indexNoeudOuColler < index:
841 indexTravail=indexTravail+dejaCrees
842 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
843 noeud=noeudJdc.children[indexTravail]
844 child=noeud.doPaste(noeudOuColler)
845 listeChild.append(child)
846 dejaCrees=dejaCrees+1
848 self.QWParent.noeud_a_editer = []
849 for i in range(len(listeIndex)):
850 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
851 self.QWParent.noeud_a_editer.append(noeud)
854 if self.QWParent.edit !="couper" : return
856 for index in listeIndex:
858 if indexNoeudOuColler < index:
859 indexTravail=indexTravail+(len(listeIndex))
860 noeud=noeudJdc.children[indexTravail]
862 listeItem.append(noeud.item)
863 listeASupprimer.append(noeud)
865 for i in range(len(listeChild)):
866 self.tree.item.suppitem(listeItem[i])
867 listeChild[i].item.update(listeItem[i])
869 self.QWParent.noeud_a_editer = []
872 #---------------------#
873 def getFileName(self):
874 #---------------------#
877 #---------------------------#
878 def get_file_variable(self) :
879 #---------------------------#
880 titre = tr("Choix d'un fichier XML")
881 texte = tr("Le fichier contient une commande MODEL\n")
882 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
883 QMessageBox.information( self, titre,tr(texte))
885 fichier = QFileDialog.getOpenFileName(self.appliEficas,
886 tr('Ouvrir Fichier'),
887 self.appliEficas.CONFIGURATION.savedir,
888 tr('Wrapper Files (*.xml);;''All Files (*)'))
891 #--------------------------------------------------#
892 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
893 #--------------------------------------------------#
895 Public slot to write the text to a file.
897 @param fn filename to write to string
898 @return flag indicating success
901 fn = six.text_type(fn)
904 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
906 if len(txt) >= len(eol):
907 if txt[-len(eol):] != eol:
911 txt=self.ajoutVersionCataDsJDC(txt)
912 checksum=self.get_checksum(txt)
914 if self.code=="TELEMAC" : return 1
920 except IOError as why:
921 if (self.appliEficas.ssIhm == False):
922 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
923 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
928 #-----------------------------------------------------------#
929 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
930 #-----------------------------------------------------------#
931 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
932 if format in generator.plugins:
934 # Le generateur existe on l'utilise
935 self.generator=generator.plugins[format]()
937 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
938 if pourRun : jdc_formate=self.generator.textePourRun
939 if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
940 except ValueError as e:
941 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
944 if not self.generator.cr.estvide():
945 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
946 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
951 # Il n'existe pas c'est une erreur
952 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
953 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
956 #----------------------#
958 #---------------------#
959 if 'dicoImbrique' in generator.plugins:
960 self.generator=generator.plugins['dicoImbrique']()
961 jdc_formate=self.generator.gener(self.jdc)
962 dico=self.generator.Dico
965 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
966 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
973 fonction="run"+self.code
975 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
980 fonction="saveRun"+self.code
981 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
987 if not(self.jdc.isvalid()):
988 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
990 if len(self.jdc.etapes) != 1 :
991 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
993 if self.modified or self.fichier==None :
994 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
995 texte=self.get_text_JDC("MAP")
996 self.writeFile( self.fichierMapInput, txt = texte)
998 self.fichierMapInput=self.fichier
999 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1002 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
1003 # then instantiate corresponding class and call getUseSalome() method
1005 from mapengine.spec import factory
1006 mapComponent = factory.new(composant)[0]
1009 if mapComponent.getUseSalome():
1010 command += " -r sappli"
1011 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
1013 #textePython="ls -l"
1014 self._viewTextExecute( textePython,"map_run",".sh")
1016 # commande="rm "+self.fichierMapInput
1017 # os.system(commande)
1020 except Exception as e:
1021 print((traceback.print_exc()))
1023 #-------------------#
1024 def runZCRACKS(self):
1025 #-------------------#
1026 if not(self.jdc.isvalid()):
1027 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1029 if self.modified or self.fichier==None :
1031 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1032 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1033 self.writeFile( self.fichierZcracksInput, txt = texte)
1035 self.fichierZcracksInput=self.fichier
1037 #commande ="Zrun -zp "
1039 textePython=(commande + self.fichierZcracksInput)
1040 self._viewTextExecute( textePython,"run_zcracks",".sh")
1041 except Exception as e:
1042 print((traceback.print_exc()))
1044 #-------------------#
1045 def runCARMELCND(self):
1046 #-------------------#
1047 #if not(self.jdc.isvalid()):
1048 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1050 if self.modified or self.fichier==None :
1051 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1053 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1054 from PrepareRunCarmel import prepareRunCarmel
1055 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1056 repMed=os.path.dirname(self.fichier)
1057 repExeCarmel=self.generator.get_repExeCarmel()
1058 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1059 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1060 f=open(nomFichier,'w')
1061 f.write(textePython)
1063 commande="xterm -e sh "+nomFichier +"\n"
1066 #-------------------#
1067 def runCarmelCS(self):
1068 #-------------------#
1070 commande="runSession pilotyacsCS.py"
1072 except Exception as e:
1073 print((traceback.print_exc()))
1075 #-----------------------------------------------------#
1076 def determineNomFichier(self,path,extension):
1077 #-----------------------------------------------------#
1078 if self.appli.code in DictExtensions:
1079 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1080 extensions= tr(chaine1+ "All Files (*)")
1082 extensions= tr("JDC (*.comm);;" "All Files (*)")
1084 if self.appli.code == "MAP" :
1085 extensions = extensions + ";; Run (*.input);;"
1087 fn = QFileDialog.getSaveFileName( self,
1088 tr("sauvegarde"), path,
1090 QFileDialog.DontConfirmOverwrite)
1091 if fn == None : return (0, None)
1093 if fn=='': return (0, None)
1095 ext = QFileInfo(fn).suffix()
1096 if ext == '': fn+=extension
1098 if QFileInfo(fn).exists():
1099 msgBox = QMessageBox(self)
1100 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1101 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1102 msgBox.addButton(tr("&Ecraser"),0)
1103 msgBox.addButton(tr("&Abandonner"),1)
1104 abort=msgBox.exec_()
1105 if abort == 1 : return (0, "")
1109 def saveRunMAP(self):
1112 if not(self.jdc.isvalid()):
1113 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1114 tr("Un JdC valide est necessaire pour creer un .input")
1118 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1120 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1121 tr("Choix du composant obligatoire")
1124 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1128 if self.fichier is not None and self.fichier != "" :
1129 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1130 monPath=str(QFileInfo(self.fichier).absolutePath())
1131 monNomFichier=os.path.join(monPath,maBase)
1132 elif hasattr(self,'monNomFichierInput'):
1133 monNomFichier=self.monNomFichierInput
1136 monDialog=QFileDialog(self.appliEficas)
1137 monDialog.setDirectory (path)
1138 monDialog.setWindowTitle ("Save")
1140 for c in monDialog.children():
1141 if isinstance(c,QDialogButtonBox):
1142 for b in c.children():
1143 if isinstance(b,QPushButton):
1145 if avant=="&Open": b.setText("Save")
1146 mesFiltres= "input Map (*.input);;All Files (*)"
1147 monDialog.setNameFilters(mesFiltres)
1148 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1149 BOk=monDialog.exec_()
1151 fn=str(monDialog.selectedFiles()[0])
1152 if fn == "" or fn == None : return
1153 if not fn.endswith(".input"):
1155 self.monNomFichierInput=fn
1157 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1158 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1159 texte=self.get_text_JDC("MAP")
1160 self.writeFile( self.fichierMapInput, txt = texte)
1162 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1163 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1164 (output, err) = p.communicate()
1168 def saveRunPSEN(self):
1170 #print ("saveRunPSEN")
1174 #-----------------------------------------#
1175 def cherche_Groupes(self):
1176 #-----------------------------------------#
1177 listeMA,listeNO=self.get_text_JDC("GroupMA")
1178 return listeMA,listeNO
1180 #-----------------------------------------#
1181 def cherche_Dico(self):
1182 #-----------------------------------------#
1184 format = self.appliEficas.format_fichier
1185 if format in generator.plugins:
1186 # Le generateur existe on l'utilise
1187 self.generator=generator.plugins[format]()
1188 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1189 dicoCourant=self.generator.dico
1194 #-----------------------------------------#
1195 def handleAjoutGroup(self,listeGroup):
1196 #-----------------------------------------#
1199 from ajoutGroupe import handleAjoutGroupFiltre
1201 handleAjoutGroupFiltre(self,listeGroup)
1202 #print "apres handleAjoutGroupFiltre"
1207 #-----------------------------------------------------------------#
1208 def saveFileLegerAs(self, fileName = None) :
1209 #-----------------------------------------------------------------#
1210 if fileName != None :
1211 self.fichier = fileName
1212 return self.saveFileLeger()
1213 return self.saveFileLeger()
1215 #-----------------------------------------------------------------#
1216 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1217 #-----------------------------------------------------------------#
1220 #saveas=True # Pour forcer le nom
1221 self.generator=generator.plugins[self.format]()
1222 if self.fichier is None or saveas:
1223 if path is None: path=self.CONFIGURATION.savedir
1224 bOK, fn=self.determineNomFichier(path,extension)
1225 if bOK == 0 : return (0, None)
1226 if fn == None : return (0, None)
1227 if fn== '' : return (0, None)
1229 ulfile = os.path.abspath(six.text_type(fn))
1230 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1231 fn = six.text_type(QDir.toNativeSeparators(fn))
1233 self.fichier = os.path.splitext(fn)[0]+extension
1235 if hasattr(self.generator, "writeLeger"):
1236 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1238 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1241 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1242 self.appliEficas.setWindowTitle(nouveauTitre)
1243 return (1, self.fichier)
1245 #-----------------------------------------------------------------#
1246 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1247 #-----------------------------------------------------------------#
1249 Public slot to save the text to a file.
1251 @param path directory to save the file in (string or QString)
1252 @return tuple of two values (boolean, string) giving a success indicator and
1253 the name of the saved file
1257 if not self.modified and not saveas:
1258 return (0, None) # do nothing if text wasn't changed
1260 if self.appli.code in DictExtensions :
1261 extension=DictExtensions[self.appli.code]
1267 if self.fichier is None or saveas:
1268 if path is None: path=self.CONFIGURATION.savedir
1269 bOK, fn=self.determineNomFichier(path,extension)
1270 if bOK == 0 : return (0, None)
1271 if fn == None : return (0, None)
1272 if fn== '' : return (0, None)
1274 ulfile = os.path.abspath(six.text_type(fn))
1275 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1276 fn = six.text_type(QDir.toNativeSeparators(fn))
1280 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1282 self.modified = False
1283 if self.fileInfo is None or saveas:
1284 self.fileInfo = QFileInfo(self.fichier)
1285 self.fileInfo.setCaching(0)
1286 self.lastModified = self.fileInfo.lastModified()
1287 if newName is not None:
1288 self.appliEficas.addToRecentList(newName)
1289 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1290 self.tree.racine.update_node_label()
1292 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1293 self.generator.writeDefault(fn)
1294 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1295 self.generator.writeDefault(fn)
1298 self.appliEficas.addJdcInSalome( self.fichier)
1300 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1301 self.appliEficas.setWindowTitle(nouveauTitre)
1303 return (1, self.fichier)
1306 #----------------------------------------------#
1307 def sauveLigneFile(self):
1308 #----------------------------------------------#
1310 return self.saveFile(formatLigne="Ligne")
1313 #----------------------------------------------#
1314 def saveFileAs(self, path = None,fileName=None):
1315 #----------------------------------------------#
1317 Public slot to save a file with a new name.
1319 @param path directory to save the file in (string or QString)
1320 @return tuple of two values (boolean, string) giving a success indicator and
1321 the name of the saved file
1323 if fileName != None :
1324 self.fichier = fileName
1325 return self.saveFile()
1326 return self.saveFile(path,1,"beautifie")
1330 #---------------------------------------------#
1331 def get_file(self,unite=None,fic_origine = ''):
1332 #---------------------------------------------#
1340 titre = tr("Choix unite %d ", unite)
1341 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1342 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1343 labeltexte = tr('Fichier pour unite ') + repr( unite)
1345 titre = tr("Choix d'un fichier de poursuite")
1346 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1347 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1349 QMessageBox.information( self, titre,texte)
1350 fn = QFileDialog.getOpenFileName(self.appliEficas,
1352 self.appliEficas.CONFIGURATION.savedir)
1354 # ce retour est impose par le get_file d'I_JDC
1355 if fn== '' : return None," "
1356 if not fn : return (0, " ")
1359 ulfile = os.path.abspath(six.text_type(fn))
1360 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1362 # On utilise le convertisseur defini par format_fichier
1363 source=self.get_source(ulfile)
1365 # On a reussia convertir le fichier self.ulfile
1368 # Une erreur a ete rencontree
1370 return ulfile, jdcText
1372 #-----------------------------------#
1373 def updateJdc(self, itemApres,texte):
1374 #------------------------------------#
1375 # ajoute une etape de JdC a partir d un texte
1377 etape=monItem.item.object
1378 CONTEXT.set_current_step(etape)
1379 etape.build_includeInclude(texte)
1380 self.tree.racine.build_children()
1382 #-----------------------------------#
1383 def updateJdcEtape(self, itemApres,texte):
1384 #------------------------------------#
1385 # ajoute une etape de JdC a partir d un texte
1387 etape=monItem.item.object
1388 CONTEXT.set_current_step(etape)
1389 etape.build_includeEtape(texte)
1390 self.tree.racine.build_children()
1393 #-------------------------------------#
1394 def deleteEtape(self,etape):
1395 #-------------------------------------#
1397 self.jdc.suppentite(etape)
1399 #-------------------------------------#
1400 def deleteMC(self,etape,MCFils,listeAvant=()):
1401 #-------------------------------------#
1404 for mot in listeAvant :
1405 ouChercher=ouChercher.get_child(mot,restreint="oui")
1406 monMC=ouChercher.get_child(MCFils,restreint="oui")
1407 if monMC != None : ouChercher.suppentite(monMC)
1408 ouChercher.state='changed'
1409 ouChercher.isvalid()
1411 #-------------------------------------#
1412 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1413 #-------------------------------------#
1416 for mot in listeAvant :
1417 ouChercher=ouChercher.get_child(mot,restreint="oui")
1418 monMC=etape.get_child(ouChercher,restreint="oui")
1419 if monMC== None : monMC= ouChercher.addentite(MCFils)
1420 monMC.valeur=valeurs
1422 monMC.state='changed'
1425 #----------------------------------------------#
1426 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
1427 #----------------------------------------------#
1429 print ('ajoutMCFact')
1432 for mot in listeAvant :
1433 ouChercher=ouChercher.get_child(mot,restreint="oui")
1436 monMC=etape.get_child(ouChercher,restreint="oui")
1437 if monMC== None : monMC= ouChercher.addentite(MCFils)
1440 #-------------------------------------#
1441 def getValeur(self,nomEtape,MCFils,listeAvant=()):
1442 #-------------------------------------#
1446 for e in self.jdc.etapes:
1447 if e.nom == nomEtape : ouChercher=e; break
1448 if ouChercher==None : return None
1449 for mot in listeAvant :
1450 ouChercher=ouChercher.get_child(mot,restreint="oui")
1451 #print (mot, ouChercher)
1452 if ouChercher==None : return None
1453 monMC=ouChercher.get_child(MCFils,restreint="oui")
1454 if monMC== None : return None
1457 #-----------------------------------------------------------#
1458 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
1459 #--------------------------------------------------------#
1463 for e in self.jdc.etapes:
1464 if e.nom == nomEtape : ouChercher=e; break
1465 if ouChercher==None : return None
1466 for mot in listeAvant :
1467 ouChercher=ouChercher.get_child(mot,restreint="oui")
1468 #print (mot, ouChercher)
1469 if ouChercher==None : return None
1470 monMC=ouChercher.get_child(MCFils,restreint="oui")
1471 monMC.set_valeur(valeur)
1474 #-----------------------------------------------------------#
1475 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1476 #-----------------------------------------------------------#
1479 if isinstance (etape, str):
1481 for e in self.jdc.etapes:
1482 if e.nom == etape : ouChercher=e; break
1483 if ouChercher==None : return
1485 for mot in listeAvant :
1486 ouChercher=ouChercher.get_child(mot,restreint="oui")
1487 if ouChercher==None : return
1488 monMC=ouChercher.get_child(MCFils,restreint="oui")
1489 if monMC== None : monMC= ouChercher.addentite(MCFils)
1491 monMC.definition.into=valeurs
1492 from Noyau.N_VALIDATOR import IntoProtocol
1493 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1494 monMC.state='changed'
1497 #-------------------------------------------------------------------#
1498 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1499 #-------------------------------------------------------------------#
1501 for e in self.jdc.etapes:
1502 if e.nom == nomEtape : ouChercher=e; break
1504 for mot in listeAvant :
1506 ouChercher=ouChercher.get_child(mot,restreint="oui")
1507 # Le mot clef n est pas la
1510 monMC=ouChercher.get_child(MCFils,restreint="oui")
1511 # Le mot clef n est pas la
1513 if monMC == None : return 0
1515 if hasattr(monMC.definition,'into') :
1516 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1517 else : maListeDeValeur=monMC.definition.into
1521 monMC.state='changed'
1524 #-------------------------------------#
1525 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1526 #-------------------------------------#
1529 #if isinstance (etape, str):
1530 # for e in self.jdc.etapes:
1531 # if e.nom == etape : etape=e; break
1532 #if etape == None : return
1533 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1534 ouChercher=definitionEtape
1535 if len(listeMC) > 1 :
1537 for mc in listeMC[0:-1]:
1538 mcfact=ouChercher.entites[mc]
1541 mcAccas=ouChercher.entites[listeMC[-1]]
1542 mcAccas.defaut=valeurs
1545 #------------------------------------------------#
1546 def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
1547 #------------------------------------------------#
1549 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1550 ouChercher=definitionEtape
1552 if len(listeMC) > 1 :
1553 for mc in listeMC[0:-1]:
1554 mcfact=ouChercher.entites[mc]
1556 mcAccas=ouChercher.entites[listeMC[-1]]
1558 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1559 else : oldValeurs=None
1560 if oldValeurs==valeurs : return 0
1562 mcAccas.into=valeurs
1563 from Noyau.N_VALIDATOR import IntoProtocol
1564 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1567 #-------------------------------------------------------------#
1568 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1569 #-------------------------------------------------------------#
1571 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1572 if isinstance (etape, str):
1573 for e in self.jdc.etapes:
1574 if e.nom == etape : etape=e; break
1575 if etape == None : return
1576 definitionEtape=getattr(self.jdc.cata[0],etape)
1577 ouChercher=definitionEtape
1578 for k in listeAvant :
1579 ouChercher=ouChercher.entites[k]
1580 MCADetruire=ouChercher.entites[nomDuMC]
1581 ouChercher.ordre_mc.remove(nomDuMC)
1582 del ouChercher.entites[nomDuMC]
1583 del self.dicoNouveauxMC[nomDuMC]
1586 #-------------------------------------------------------------#
1587 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
1588 #-------------------------------------------------------------#
1590 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1591 ouChercher=definitionEtape
1592 for k in listeAvant :
1593 ouChercher=ouChercher.entites[k]
1594 from Accas import A_SIMP
1595 Nouveau=A_SIMP.SIMP(typ,**args)
1596 Nouveau.pere=ouChercher
1598 #Nouveau.ordre_mc=[]
1599 ouChercher.entites[nomDuMC]=Nouveau
1600 ouChercher.ordre_mc.append(nomDuMC)
1601 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
1602 #print self.dicoNouveauxMC
1604 #---------------------------------------------------------------------#
1605 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1606 #---------------------------------------------------------------------#
1608 print ('ajoutDefinitionMCFact', nomDuMC)
1609 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1610 ouChercher=definitionEtape
1611 for k in listeAvant :
1612 ouChercher=ouChercher.entites[k]
1613 from Accas import A_SIMP
1618 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1620 args[nomMC]=nouveauMC
1621 from Accas import A_FACT
1622 nouveauFact=A_FACT.FACT(**args)
1623 nouveauFact.pere=ouChercher
1624 nouveauFact.nom=nomDuMC
1625 from Editeur.autre_analyse_cata import traite_entite
1626 traite_entite(nouveauFact,[])
1627 ouChercher.entites[nomDuMC]=nouveauFact
1628 ouChercher.ordre_mc.append(nomDuMC)
1629 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1630 #print self.dicoNouveauxMC
1632 #----------------------------------------------------#
1634 #----------------------------------------------------#
1635 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
1636 #----------------------------------------------------#
1637 # dans le MDD et le JDC
1639 self.changeIntoDefMC(etape,listeMC,into)
1641 if isinstance (etape, str):
1642 for e in self.jdc.etapes:
1643 if e.nom == etape : etape=e; break
1644 if etape == None : return
1647 for mot in listeMC[:-1] :
1648 ouChercher=ouChercher.get_child(mot,restreint="oui")
1649 if ouChercher==None : return
1651 monMC=ouChercher.get_child(MCFils,restreint="oui")
1652 if monMC== None : monMC= etape.addentite(MCFils)
1654 monMC.definition.into=into
1655 monMC.valeur=valeurs
1657 monMC.state='changed'
1660 #-------------------------------------#
1661 def ajoutVersionCataDsJDC(self,txt):
1662 #-------------------------------------#
1663 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1664 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1665 texte=txt+ligneVersion
1668 #-------------------------------------#
1669 def verifieVersionCataDuJDC(self,text):
1670 #-------------------------------------#
1672 indexDeb=text.find("#VERSION_CATALOGUE:")
1673 indexFin=text.find(":FIN VERSION_CATALOGUE")
1675 self.versionCataDuJDC="sans"
1678 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1679 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1681 self.versionCata="sans"
1682 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1684 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1685 return memeVersion,textJDC
1687 #-------------------------------#
1688 def traduitCatalogue(self,texte):
1689 #-------------------------------#
1690 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1691 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1693 traducteur=__import__(nomTraducteur)
1694 monTraducteur=traducteur.MonTraducteur(texte)
1695 nouveauTexte=monTraducteur.traduit()
1701 #------------------------------#
1702 def verifieCHECKSUM(self,text):
1703 #------------------------------#
1704 indexDeb=text.find("#CHECKSUM:")
1707 indexFin=text.find(":FIN CHECKSUM")
1708 checkAvant=text[indexDeb:indexFin+13]
1709 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1710 checksum=self.get_checksum(textJDC)
1711 pareil=(checkAvant==checksum)
1712 return pareil, textJDC
1714 #---------------------------#
1715 def get_checksum(self,texte):
1716 #---------------------------#
1717 newtexte=texte.replace('"','\\"')
1718 commande='echo "'+newtexte+'"|md5sum'
1719 a=os.popen(commande)
1722 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1726 #---------------------------#
1728 #---------------------------#
1729 texte="CONDUITE_FORCEE();"
1733 #---------------------------#
1734 def _newTELEMAC(self):
1735 #---------------------------#
1736 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1737 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1741 #---------------------------#
1743 #---------------------------#
1744 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1748 #---------------------------#
1749 def _newPSEN_N1(self):
1750 #---------------------------#
1751 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1752 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1755 #---------------------------#
1757 #---------------------------#
1758 def _newZCRACKS(self):
1759 #---------------------------#
1760 texte="MAILLAGES();REMESHING();"
1763 #---------------------------#
1764 def _newJDCCND(self):
1765 #---------------------------#
1766 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1768 #if self.salome == 0 :
1769 QMessageBox.information( self,
1771 tr("Veuillez selectionner un fichier Med"))
1772 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1773 caption='Fichier Med',
1775 QSfichier=QSfichier[0]
1776 self.fichierMED=QSfichier
1777 from acquiertGroupes import getGroupes
1778 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1779 if erreur != "" : print ("a traiter")
1780 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1786 for groupe in self.listeGroupes :
1787 if groupe[0:8]=='CURRENT_':
1788 texteSources +=groupe[8:]+"=SOURCE("
1789 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1790 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1791 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1792 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1793 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1794 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1795 self.newTexteCND=texte
1800 #---------------------------#
1801 def BoutonFileSelected(self):
1802 #---------------------------#
1804 QSfichier=self.openfile.selectedFiles()[0]
1805 self.fichierMED=str(QSfichier)
1806 from acquiertGroupes import getGroupes
1807 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1808 if erreur != "" : print ("a traiter")
1810 #-----------------------------
1811 def BoutonSalomePressed(self):
1812 #----------------------------
1813 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1814 self.fichierMED="A_partir_de_SMESH"
1815 self.nomMaillage="A_partir_de_SMESH"
1816 self.openfile.close()
1819 #-----------------------------------------
1820 def initSplitterSizes(self, nbWidget=3):
1821 #-----------------------------------------
1822 #print ("je passe ds initSplitterSizes", nbWidget)
1824 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1825 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1826 else : self.splitterSizes3=[150,1000,300]
1828 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1829 else : self.splitterSizes2=[300,1000]
1833 #-----------------------------------------
1834 def restoreSplitterSizes(self,nbWidget=3):
1835 #----------------------------------------
1837 #traceback.print_stack()
1838 #print ("je passe ds restoreSplitterSizes")
1839 if not(hasattr(self,'splitter')) : return
1840 if nbWidget==2 : newSizes=self.splitterSizes2
1841 if nbWidget==3 : newSizes=self.splitterSizes3
1842 #self.inhibeSplitter = 1
1843 self.splitter.setSizes(newSizes)
1844 #self.inhibeSplitter = 0
1845 QApplication.processEvents()
1846 # seule la fentetre du milieu est necessaire
1847 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1849 #-----------------------------------------
1850 def saveSplitterSizes(self,event):
1851 #-----------------------------------------
1852 #print ("je passe ds saveSplitterSizes")
1853 if self.inhibeSplitter : return
1854 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1855 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1857 #------------------------
1858 def fermeOptionnel(self):
1859 #------------------------
1860 if self.widgetOptionnel == None : return
1862 self.inhibeSplitter=1
1863 self.widgetOptionnel.setParent(None)
1864 self.widgetOptionnel.close()
1865 self.widgetOptionnel.deleteLater()
1866 self.widgetOptionnel=None
1867 self.inhibeSplitter=0
1868 self.restoreSplitterSizes(2)
1870 #------------------------
1871 def ajoutOptionnel(self):
1872 #------------------------
1873 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1874 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1875 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1877 self.restoreSplitterSizes(3)
1880 #------------------------
1881 def fermeArbre(self):
1882 #------------------------
1883 #print (self.widgetTree)
1884 self.oldWidgetTree=self.widgetTree
1885 self.widgetTree.hide()
1886 #self.widgetTree=None
1888 #------------------------
1889 def ouvreArbre(self):
1890 #------------------------
1891 #print ('je passe la')
1892 #print (self.widgetTree)
1893 #self.widgetTree=self.oldWidgetTree
1894 self.widgetTree.show()
1895 #self.restoreSplitterSizes(3)
1897 #-----------------------------
1898 def getTreeIndex(self,noeud):
1899 #----------------------------
1901 if noeud in noeud.treeParent.children :
1902 indexNoeud=noeud.treeParent.children.index(noeud)
1904 if hasattr(noeud,'vraiParent') :
1906 noeudVraiParent = noeud.vraiParent
1907 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1908 noeudVrai = noeudVraiParent
1909 noeudVraiParent = noeudVraiParent.vraiParent
1911 if noeudVraiParent == noeud.treeParent :
1912 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1918 if __name__ == "__main__":
1920 name='prefs_'+prefs.code
1921 prefsCode=__import__(name)
1924 if hasattr(prefsCode,'encoding'):
1925 # Hack pour changer le codage par defaut des strings
1928 sys.setdefaultencoding(prefs.encoding)
1929 del sys.setdefaultencoding
1934 app = QApplication(sys.argv)
1935 mw = JDCEditor(None,'azAster.comm')
1936 app.setMainWidget(mw)
1937 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1940 res = app.exec_loop()