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+" "+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)
1390 ok=etape.build_includeEtape(texte)
1394 QMessageBox.information( self,
1396 tr("Impossible d importer le texte"))
1397 self.tree.racine.build_children()
1402 #-------------------------------------#
1403 def deleteEtape(self,etape):
1404 #-------------------------------------#
1406 self.jdc.suppentite(etape)
1408 #-------------------------------------#
1409 def deleteMC(self,etape,MCFils,listeAvant=()):
1410 #-------------------------------------#
1413 for mot in listeAvant :
1414 ouChercher=ouChercher.get_child(mot,restreint="oui")
1415 monMC=ouChercher.get_child(MCFils,restreint="oui")
1416 if monMC != None : ouChercher.suppentite(monMC)
1417 ouChercher.state='changed'
1418 ouChercher.isvalid()
1420 #-------------------------------------#
1421 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1422 #-------------------------------------#
1425 for mot in listeAvant :
1426 ouChercher=ouChercher.get_child(mot,restreint="oui")
1427 monMC=etape.get_child(ouChercher,restreint="oui")
1428 if monMC== None : monMC= ouChercher.addentite(MCFils)
1429 monMC.valeur=valeurs
1431 monMC.state='changed'
1434 #----------------------------------------------#
1435 def ajoutMCFact(self,etape,MCFils,listeAvant=()):
1436 #----------------------------------------------#
1438 print ('ajoutMCFact')
1441 for mot in listeAvant :
1442 ouChercher=ouChercher.get_child(mot,restreint="oui")
1445 monMC=etape.get_child(ouChercher,restreint="oui")
1446 if monMC== None : monMC= ouChercher.addentite(MCFils)
1449 #-------------------------------------#
1450 def getValeur(self,nomEtape,MCFils,listeAvant=()):
1451 #-------------------------------------#
1455 for e in self.jdc.etapes:
1456 if e.nom == nomEtape : ouChercher=e; break
1457 if ouChercher==None : return None
1458 for mot in listeAvant :
1459 ouChercher=ouChercher.get_child(mot,restreint="oui")
1460 #print (mot, ouChercher)
1461 if ouChercher==None : return None
1462 monMC=ouChercher.get_child(MCFils,restreint="oui")
1463 if monMC== None : return None
1466 #-----------------------------------------------------------#
1467 def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
1468 #--------------------------------------------------------#
1472 for e in self.jdc.etapes:
1473 if e.nom == nomEtape : ouChercher=e; break
1474 if ouChercher==None : return None
1475 for mot in listeAvant :
1476 ouChercher=ouChercher.get_child(mot,restreint="oui")
1477 #print (mot, ouChercher)
1478 if ouChercher==None : return None
1479 monMC=ouChercher.get_child(MCFils,restreint="oui")
1480 monMC.set_valeur(valeur)
1483 #-----------------------------------------------------------#
1484 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1485 #-----------------------------------------------------------#
1488 if isinstance (etape, str):
1490 for e in self.jdc.etapes:
1491 if e.nom == etape : ouChercher=e; break
1492 if ouChercher==None : return
1494 for mot in listeAvant :
1495 ouChercher=ouChercher.get_child(mot,restreint="oui")
1496 if ouChercher==None : return
1497 monMC=ouChercher.get_child(MCFils,restreint="oui")
1498 if monMC== None : monMC= ouChercher.addentite(MCFils)
1500 monMC.definition.into=valeurs
1501 from Noyau.N_VALIDATOR import IntoProtocol
1502 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1503 monMC.state='changed'
1506 #-------------------------------------------------------------------#
1507 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1508 #-------------------------------------------------------------------#
1510 for e in self.jdc.etapes:
1511 if e.nom == nomEtape : ouChercher=e; break
1513 for mot in listeAvant :
1515 ouChercher=ouChercher.get_child(mot,restreint="oui")
1516 # Le mot clef n est pas la
1519 monMC=ouChercher.get_child(MCFils,restreint="oui")
1520 # Le mot clef n est pas la
1522 if monMC == None : return 0
1524 if hasattr(monMC.definition,'into') :
1525 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1526 else : maListeDeValeur=monMC.definition.into
1530 monMC.state='changed'
1533 #-------------------------------------#
1534 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1535 #-------------------------------------#
1538 #if isinstance (etape, str):
1539 # for e in self.jdc.etapes:
1540 # if e.nom == etape : etape=e; break
1541 #if etape == None : return
1542 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1543 ouChercher=definitionEtape
1544 if len(listeMC) > 1 :
1546 for mc in listeMC[0:-1]:
1547 mcfact=ouChercher.entites[mc]
1550 mcAccas=ouChercher.entites[listeMC[-1]]
1551 mcAccas.defaut=valeurs
1554 #------------------------------------------------#
1555 def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
1556 #------------------------------------------------#
1558 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1559 ouChercher=definitionEtape
1561 if len(listeMC) > 1 :
1562 for mc in listeMC[0:-1]:
1563 mcfact=ouChercher.entites[mc]
1565 mcAccas=ouChercher.entites[listeMC[-1]]
1567 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1568 else : oldValeurs=None
1569 if oldValeurs==valeurs : return 0
1571 mcAccas.into=valeurs
1572 from Noyau.N_VALIDATOR import IntoProtocol
1573 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1576 #-------------------------------------------------------------#
1577 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1578 #-------------------------------------------------------------#
1580 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1581 if isinstance (etape, str):
1582 for e in self.jdc.etapes:
1583 if e.nom == etape : etape=e; break
1584 if etape == None : return
1585 definitionEtape=getattr(self.jdc.cata[0],etape)
1586 ouChercher=definitionEtape
1587 for k in listeAvant :
1588 ouChercher=ouChercher.entites[k]
1589 MCADetruire=ouChercher.entites[nomDuMC]
1590 ouChercher.ordre_mc.remove(nomDuMC)
1591 del ouChercher.entites[nomDuMC]
1592 del self.dicoNouveauxMC[nomDuMC]
1595 #-------------------------------------------------------------#
1596 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
1597 #-------------------------------------------------------------#
1599 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1600 ouChercher=definitionEtape
1601 for k in listeAvant :
1602 ouChercher=ouChercher.entites[k]
1603 from Accas import A_SIMP
1604 Nouveau=A_SIMP.SIMP(typ,**args)
1605 Nouveau.pere=ouChercher
1607 #Nouveau.ordre_mc=[]
1608 ouChercher.entites[nomDuMC]=Nouveau
1609 ouChercher.ordre_mc.append(nomDuMC)
1610 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
1611 #print self.dicoNouveauxMC
1613 #---------------------------------------------------------------------#
1614 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1615 #---------------------------------------------------------------------#
1617 print ('ajoutDefinitionMCFact', nomDuMC)
1618 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1619 ouChercher=definitionEtape
1620 for k in listeAvant :
1621 ouChercher=ouChercher.entites[k]
1622 from Accas import A_SIMP
1627 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1629 args[nomMC]=nouveauMC
1630 from Accas import A_FACT
1631 nouveauFact=A_FACT.FACT(**args)
1632 nouveauFact.pere=ouChercher
1633 nouveauFact.nom=nomDuMC
1634 from Editeur.autre_analyse_cata import traite_entite
1635 traite_entite(nouveauFact,[])
1636 ouChercher.entites[nomDuMC]=nouveauFact
1637 ouChercher.ordre_mc.append(nomDuMC)
1638 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1639 #print self.dicoNouveauxMC
1641 #----------------------------------------------------#
1643 #----------------------------------------------------#
1644 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
1645 #----------------------------------------------------#
1646 # dans le MDD et le JDC
1648 self.changeIntoDefMC(etape,listeMC,into)
1650 if isinstance (etape, str):
1651 for e in self.jdc.etapes:
1652 if e.nom == etape : etape=e; break
1653 if etape == None : return
1656 for mot in listeMC[:-1] :
1657 ouChercher=ouChercher.get_child(mot,restreint="oui")
1658 if ouChercher==None : return
1660 monMC=ouChercher.get_child(MCFils,restreint="oui")
1661 if monMC== None : monMC= etape.addentite(MCFils)
1663 monMC.definition.into=into
1664 monMC.valeur=valeurs
1666 monMC.state='changed'
1669 #-------------------------------------#
1670 def ajoutVersionCataDsJDC(self,txt):
1671 #-------------------------------------#
1672 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1673 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1674 texte=txt+ligneVersion
1677 #-------------------------------------#
1678 def verifieVersionCataDuJDC(self,text):
1679 #-------------------------------------#
1681 indexDeb=text.find("#VERSION_CATALOGUE:")
1682 indexFin=text.find(":FIN VERSION_CATALOGUE")
1684 self.versionCataDuJDC="sans"
1687 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1688 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1690 self.versionCata="sans"
1691 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1693 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1694 return memeVersion,textJDC
1696 #-------------------------------#
1697 def traduitCatalogue(self,texte):
1698 #-------------------------------#
1699 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1700 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1702 traducteur=__import__(nomTraducteur)
1703 monTraducteur=traducteur.MonTraducteur(texte)
1704 nouveauTexte=monTraducteur.traduit()
1710 #------------------------------#
1711 def verifieCHECKSUM(self,text):
1712 #------------------------------#
1713 indexDeb=text.find("#CHECKSUM:")
1716 indexFin=text.find(":FIN CHECKSUM")
1717 checkAvant=text[indexDeb:indexFin+13]
1718 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1719 checksum=self.get_checksum(textJDC)
1720 pareil=(checkAvant==checksum)
1721 return pareil, textJDC
1723 #---------------------------#
1724 def get_checksum(self,texte):
1725 #---------------------------#
1726 newtexte=texte.replace('"','\\"')
1727 commande='echo "'+newtexte+'"|md5sum'
1728 a=os.popen(commande)
1731 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1735 #---------------------------#
1737 #---------------------------#
1738 texte="CONDUITE_FORCEE();"
1742 #---------------------------#
1743 def _newTELEMAC(self):
1744 #---------------------------#
1745 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1746 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1750 #---------------------------#
1752 #---------------------------#
1753 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1757 #---------------------------#
1758 def _newPSEN_N1(self):
1759 #---------------------------#
1760 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1761 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1764 #---------------------------#
1766 #---------------------------#
1767 def _newZCRACKS(self):
1768 #---------------------------#
1769 texte="MAILLAGES();REMESHING();"
1772 #---------------------------#
1773 def _newJDCCND(self):
1774 #---------------------------#
1775 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1777 #if self.salome == 0 :
1778 QMessageBox.information( self,
1780 tr("Veuillez selectionner un fichier Med"))
1781 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1782 caption='Fichier Med',
1784 QSfichier=QSfichier[0]
1785 self.fichierMED=QSfichier
1786 from acquiertGroupes import getGroupes
1787 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1788 if erreur != "" : print ("a traiter")
1789 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1795 for groupe in self.listeGroupes :
1796 if groupe[0:8]=='CURRENT_':
1797 texteSources +=groupe[8:]+"=SOURCE("
1798 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1799 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1800 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1801 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1802 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1803 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1804 self.newTexteCND=texte
1809 #---------------------------#
1810 def BoutonFileSelected(self):
1811 #---------------------------#
1813 QSfichier=self.openfile.selectedFiles()[0]
1814 self.fichierMED=str(QSfichier)
1815 from acquiertGroupes import getGroupes
1816 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1817 if erreur != "" : print ("a traiter")
1819 #-----------------------------
1820 def BoutonSalomePressed(self):
1821 #----------------------------
1822 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1823 self.fichierMED="A_partir_de_SMESH"
1824 self.nomMaillage="A_partir_de_SMESH"
1825 self.openfile.close()
1828 #-----------------------------------------
1829 def initSplitterSizes(self, nbWidget=3):
1830 #-----------------------------------------
1831 #print ("je passe ds initSplitterSizes", nbWidget)
1833 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1834 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1835 else : self.splitterSizes3=[150,1000,300]
1837 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1838 else : self.splitterSizes2=[300,1000]
1842 #-----------------------------------------
1843 def restoreSplitterSizes(self,nbWidget=3):
1844 #----------------------------------------
1846 #traceback.print_stack()
1847 #print ("je passe ds restoreSplitterSizes")
1848 if not(hasattr(self,'splitter')) : return
1849 if nbWidget==2 : newSizes=self.splitterSizes2
1850 if nbWidget==3 : newSizes=self.splitterSizes3
1851 #self.inhibeSplitter = 1
1852 self.splitter.setSizes(newSizes)
1853 #self.inhibeSplitter = 0
1854 QApplication.processEvents()
1855 # seule la fentetre du milieu est necessaire
1856 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1858 #-----------------------------------------
1859 def saveSplitterSizes(self,event):
1860 #-----------------------------------------
1861 #print ("je passe ds saveSplitterSizes")
1862 if self.inhibeSplitter : return
1863 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1864 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1866 #------------------------
1867 def fermeOptionnel(self):
1868 #------------------------
1869 if self.widgetOptionnel == None : return
1871 self.inhibeSplitter=1
1872 self.widgetOptionnel.setParent(None)
1873 self.widgetOptionnel.close()
1874 self.widgetOptionnel.deleteLater()
1875 self.widgetOptionnel=None
1876 self.inhibeSplitter=0
1877 self.restoreSplitterSizes(2)
1879 #------------------------
1880 def ajoutOptionnel(self):
1881 #------------------------
1882 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1883 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1884 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1886 self.restoreSplitterSizes(3)
1889 #------------------------
1890 def fermeArbre(self):
1891 #------------------------
1892 #print (self.widgetTree)
1893 self.oldWidgetTree=self.widgetTree
1894 self.widgetTree.hide()
1895 #self.widgetTree=None
1897 #------------------------
1898 def ouvreArbre(self):
1899 #------------------------
1900 #print ('je passe la')
1901 #print (self.widgetTree)
1902 #self.widgetTree=self.oldWidgetTree
1903 self.widgetTree.show()
1904 #self.restoreSplitterSizes(3)
1906 #-----------------------------
1907 def getTreeIndex(self,noeud):
1908 #----------------------------
1910 if noeud in noeud.treeParent.children :
1911 indexNoeud=noeud.treeParent.children.index(noeud)
1913 if hasattr(noeud,'vraiParent') :
1915 noeudVraiParent = noeud.vraiParent
1916 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1917 noeudVrai = noeudVraiParent
1918 noeudVraiParent = noeudVraiParent.vraiParent
1920 if noeudVraiParent == noeud.treeParent :
1921 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1927 if __name__ == "__main__":
1929 name='prefs_'+prefs.code
1930 prefsCode=__import__(name)
1933 if hasattr(prefsCode,'encoding'):
1934 # Hack pour changer le codage par defaut des strings
1937 sys.setdefaultencoding(prefs.encoding)
1938 del sys.setdefaultencoding
1943 app = QApplication(sys.argv)
1944 mw = JDCEditor(None,'azAster.comm')
1945 app.setMainWidget(mw)
1946 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1949 res = app.exec_loop()