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 saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1209 #-----------------------------------------------------------------#
1212 #saveas=True # Pour forcer le nom
1213 self.generator=generator.plugins[self.format]()
1214 if self.fichier is None or saveas:
1215 if path is None: path=self.CONFIGURATION.savedir
1216 bOK, fn=self.determineNomFichier(path,extension)
1217 if bOK == 0 : return (0, None)
1218 if fn == None : return (0, None)
1219 if fn== '' : return (0, None)
1221 ulfile = os.path.abspath(six.text_type(fn))
1222 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1223 fn = six.text_type(QDir.toNativeSeparators(fn))
1225 self.fichier = os.path.splitext(fn)[0]+extension
1227 if hasattr(self.generator, "writeLeger"):
1228 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1230 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1233 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1234 self.appliEficas.setWindowTitle(nouveauTitre)
1235 return (1, self.fichier)
1237 #-----------------------------------------------------------------#
1238 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1239 #-----------------------------------------------------------------#
1241 Public slot to save the text to a file.
1243 @param path directory to save the file in (string or QString)
1244 @return tuple of two values (boolean, string) giving a success indicator and
1245 the name of the saved file
1249 if not self.modified and not saveas:
1250 return (0, None) # do nothing if text wasn't changed
1252 if self.appli.code in DictExtensions :
1253 extension=DictExtensions[self.appli.code]
1259 if self.fichier is None or saveas:
1260 if path is None: path=self.CONFIGURATION.savedir
1261 bOK, fn=self.determineNomFichier(path,extension)
1262 if bOK == 0 : return (0, None)
1263 if fn == None : return (0, None)
1264 if fn== '' : return (0, None)
1266 ulfile = os.path.abspath(six.text_type(fn))
1267 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1268 fn = six.text_type(QDir.toNativeSeparators(fn))
1272 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1274 self.modified = False
1275 if self.fileInfo is None or saveas:
1276 self.fileInfo = QFileInfo(self.fichier)
1277 self.fileInfo.setCaching(0)
1278 self.lastModified = self.fileInfo.lastModified()
1279 if newName is not None:
1280 self.appliEficas.addToRecentList(newName)
1281 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1282 self.tree.racine.update_node_label()
1284 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1285 self.generator.writeDefault(fn)
1286 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1287 self.generator.writeDefault(fn)
1290 self.appliEficas.addJdcInSalome( self.fichier)
1292 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1293 self.appliEficas.setWindowTitle(nouveauTitre)
1295 return (1, self.fichier)
1298 #----------------------------------------------#
1299 def sauveLigneFile(self):
1300 #----------------------------------------------#
1302 return self.saveFile(formatLigne="Ligne")
1305 #----------------------------------------------#
1306 def saveFileAs(self, path = None,fileName=None):
1307 #----------------------------------------------#
1309 Public slot to save a file with a new name.
1311 @param path directory to save the file in (string or QString)
1312 @return tuple of two values (boolean, string) giving a success indicator and
1313 the name of the saved file
1315 if fileName != None :
1316 self.fichier = fileName
1317 return self.saveFile()
1318 return self.saveFile(path,1,"beautifie")
1322 #---------------------------------------------#
1323 def get_file(self,unite=None,fic_origine = ''):
1324 #---------------------------------------------#
1332 titre = tr("Choix unite %d ", unite)
1333 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1334 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1335 labeltexte = tr('Fichier pour unite ') + repr( unite)
1337 titre = tr("Choix d'un fichier de poursuite")
1338 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1339 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1341 QMessageBox.information( self, titre,texte)
1342 fn = QFileDialog.getOpenFileName(self.appliEficas,
1344 self.appliEficas.CONFIGURATION.savedir)
1346 # ce retour est impose par le get_file d'I_JDC
1347 if fn== '' : return None," "
1348 if not fn : return (0, " ")
1351 ulfile = os.path.abspath(six.text_type(fn))
1352 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1354 # On utilise le convertisseur defini par format_fichier
1355 source=self.get_source(ulfile)
1357 # On a reussia convertir le fichier self.ulfile
1360 # Une erreur a ete rencontree
1362 return ulfile, jdcText
1364 #-------------------------------#
1365 def updateJdc(self, itemApres,texte):
1366 #--------------------------------#
1368 etape=monItem.item.object
1370 CONTEXT.set_current_step(etape)
1371 etape.build_includeInclude(texte)
1372 self.tree.racine.build_children()
1374 #-------------------------------------#
1375 def deleteEtape(self,etape):
1376 #-------------------------------------#
1377 self.jdc.suppentite(etape)
1379 #-------------------------------------#
1380 def deleteMC(self,etape,MCFils,listeAvant=()):
1381 #-------------------------------------#
1383 for mot in listeAvant :
1384 ouChercher=ouChercher.get_child(mot,restreint="oui")
1385 monMC=ouChercher.get_child(MCFils,restreint="oui")
1386 if monMC != None : ouChercher.suppentite(monMC)
1387 ouChercher.state='changed'
1388 ouChercher.isvalid()
1390 #-------------------------------------#
1391 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1392 #-------------------------------------#
1394 for mot in listeAvant :
1395 ouChercher=ouChercher.get_child(mot,restreint="oui")
1396 monMC=etape.get_child(ouChercher,restreint="oui")
1397 if monMC== None : monMC= ouChercher.addentite(MCFils)
1398 monMC.valeur=valeurs
1400 monMC.state='changed'
1403 #-------------------------------------#
1404 def getValeur(self,nomEtape,MCFils,listeAvant=()):
1405 #-------------------------------------#
1408 for e in self.jdc.etapes:
1409 if e.nom == nomEtape : ouChercher=e; break
1410 if ouChercher==None : return None
1411 for mot in listeAvant :
1412 ouChercher=ouChercher.get_child(mot,restreint="oui")
1413 if ouChercher==None : return None
1414 monMC=ouChercher.get_child(MCFils,restreint="oui")
1415 if monMC== None : return None
1418 #-----------------------------------------------------------#
1419 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1420 #-----------------------------------------------------------#
1422 if isinstance (etape, str):
1424 for e in self.jdc.etapes:
1425 if e.nom == etape : ouChercher=e; break
1426 if ouChercher==None : return
1428 for mot in listeAvant :
1429 ouChercher=ouChercher.get_child(mot,restreint="oui")
1430 if ouChercher==None : return
1431 monMC=ouChercher.get_child(MCFils,restreint="oui")
1432 if monMC== None : monMC= ouChercher.addentite(MCFils)
1434 monMC.definition.into=valeurs
1435 from Noyau.N_VALIDATOR import IntoProtocol
1436 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1437 monMC.state='changed'
1440 #-------------------------------------------------------------------#
1441 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1442 #-------------------------------------------------------------------#
1443 for e in self.jdc.etapes:
1444 if e.nom == nomEtape : ouChercher=e; break
1446 for mot in listeAvant :
1448 ouChercher=ouChercher.get_child(mot,restreint="oui")
1449 # Le mot clef n est pas la
1452 monMC=ouChercher.get_child(MCFils,restreint="oui")
1453 # Le mot clef n est pas la
1455 if monMC == None : return 0
1457 if hasattr(monMC.definition,'into') :
1458 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1459 else : maListeDeValeur=monMC.definition.into
1463 monMC.state='changed'
1466 #-------------------------------------#
1467 def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
1468 #-------------------------------------#
1470 #if isinstance (etape, str):
1471 # for e in self.jdc.etapes:
1472 # if e.nom == etape : etape=e; break
1473 #if etape == None : return
1474 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1475 ouChercher=definitionEtape
1476 if len(listeMC) > 1 :
1478 for mc in listeMC[0:-1]:
1479 mcfact=ouChercher.entites[mc]
1482 mcAccas=ouChercher.entites[listeMC[-1]]
1483 mcAccas.defaut=valeurs
1486 #------------------------------------------------#
1487 def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
1488 #------------------------------------------------#
1489 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1490 ouChercher=definitionEtape
1492 if len(listeMC) > 1 :
1493 for mc in listeMC[0:-1]:
1494 mcfact=ouChercher.entites[mc]
1496 mcAccas=ouChercher.entites[listeMC[-1]]
1498 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1499 else : oldValeurs=None
1500 if oldValeurs==valeurs : return 0
1502 mcAccas.into=valeurs
1503 from Noyau.N_VALIDATOR import IntoProtocol
1504 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1507 #-------------------------------------------------------------#
1508 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1509 #-------------------------------------------------------------#
1510 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1511 if isinstance (etape, str):
1512 for e in self.jdc.etapes:
1513 if e.nom == etape : etape=e; break
1514 if etape == None : return
1515 definitionEtape=getattr(self.jdc.cata[0],etape)
1516 ouChercher=definitionEtape
1517 for k in listeAvant :
1518 ouChercher=ouChercher.entites[k]
1519 MCADetruire=ouChercher.entites[nomDuMC]
1520 ouChercher.ordre_mc.remove(nomDuMC)
1521 del ouChercher.entites[nomDuMC]
1522 del self.dicoNouveauxMC[nomDuMC]
1525 #-------------------------------------------------------------#
1526 def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
1527 #-------------------------------------------------------------#
1528 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1529 ouChercher=definitionEtape
1530 for k in listeAvant :
1531 ouChercher=ouChercher.entites[k]
1532 from Accas import A_SIMP
1533 Nouveau=A_SIMP.SIMP(typ,**args)
1534 Nouveau.pere=ouChercher
1536 #Nouveau.ordre_mc=[]
1537 ouChercher.entites[nomDuMC]=Nouveau
1538 ouChercher.ordre_mc.append(nomDuMC)
1539 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
1540 #print self.dicoNouveauxMC
1542 #---------------------------------------------------------------------#
1543 def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
1544 #---------------------------------------------------------------------#
1545 print ('ajoutDefinitionMCFact', nomDuMC)
1546 definitionEtape=getattr(self.jdc.cata[0],nomEtape)
1547 ouChercher=definitionEtape
1548 for k in listeAvant :
1549 ouChercher=ouChercher.entites[k]
1550 from Accas import A_SIMP
1555 nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
1557 args[nomMC]=nouveauMC
1558 from Accas import A_FACT
1559 nouveauFact=A_FACT.FACT(**args)
1560 nouveauFact.pere=ouChercher
1561 nouveauFact.nom=nomDuMC
1562 from Editeur.autre_analyse_cata import traite_entite
1563 traite_entite(nouveauFact,[])
1564 ouChercher.entites[nomDuMC]=nouveauFact
1565 ouChercher.ordre_mc.append(nomDuMC)
1566 self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
1567 #print self.dicoNouveauxMC
1569 #----------------------------------------------------#
1571 #----------------------------------------------------#
1572 def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
1573 #----------------------------------------------------#
1575 self.changeIntoDefMC(etape,listeMC,into)
1577 if isinstance (etape, str):
1578 for e in self.jdc.etapes:
1579 if e.nom == etape : etape=e; break
1580 if etape == None : return
1583 for mot in listeMC[:-1] :
1584 ouChercher=ouChercher.get_child(mot,restreint="oui")
1585 if ouChercher==None : return
1588 monMC=ouChercher.get_child(MCFils,restreint="oui")
1589 if monMC== None : monMC= etape.addentite(MCFils)
1592 monMC.definition.into=into
1593 monMC.valeur=valeurs
1595 monMC.state='changed'
1598 #-------------------------------------#
1599 def ajoutVersionCataDsJDC(self,txt):
1600 #-------------------------------------#
1601 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1602 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1603 texte=txt+ligneVersion
1606 #-------------------------------------#
1607 def verifieVersionCataDuJDC(self,text):
1608 #-------------------------------------#
1610 indexDeb=text.find("#VERSION_CATALOGUE:")
1611 indexFin=text.find(":FIN VERSION_CATALOGUE")
1613 self.versionCataDuJDC="sans"
1616 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1617 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1619 self.versionCata="sans"
1620 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1622 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1623 return memeVersion,textJDC
1625 #-------------------------------#
1626 def traduitCatalogue(self,texte):
1627 #-------------------------------#
1628 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1629 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1631 traducteur=__import__(nomTraducteur)
1632 monTraducteur=traducteur.MonTraducteur(texte)
1633 nouveauTexte=monTraducteur.traduit()
1639 #------------------------------#
1640 def verifieCHECKSUM(self,text):
1641 #------------------------------#
1642 indexDeb=text.find("#CHECKSUM:")
1645 indexFin=text.find(":FIN CHECKSUM")
1646 checkAvant=text[indexDeb:indexFin+13]
1647 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1648 checksum=self.get_checksum(textJDC)
1649 pareil=(checkAvant==checksum)
1650 return pareil, textJDC
1652 #---------------------------#
1653 def get_checksum(self,texte):
1654 #---------------------------#
1655 newtexte=texte.replace('"','\\"')
1656 commande='echo "'+newtexte+'"|md5sum'
1657 a=os.popen(commande)
1660 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1664 #---------------------------#
1666 #---------------------------#
1667 texte="CONDUITE_FORCEE();"
1671 #---------------------------#
1672 def _newTELEMAC(self):
1673 #---------------------------#
1674 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1675 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1679 #---------------------------#
1681 #---------------------------#
1682 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1686 #---------------------------#
1687 def _newPSEN_N1(self):
1688 #---------------------------#
1689 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1690 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1693 #---------------------------#
1695 #---------------------------#
1696 def _newZCRACKS(self):
1697 #---------------------------#
1698 texte="MAILLAGES();REMESHING();"
1701 #---------------------------#
1702 def _newJDCCND(self):
1703 #---------------------------#
1704 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1706 #if self.salome == 0 :
1707 QMessageBox.information( self,
1709 tr("Veuillez selectionner un fichier Med"))
1710 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1711 caption='Fichier Med',
1713 QSfichier=QSfichier[0]
1714 self.fichierMED=QSfichier
1715 from acquiertGroupes import getGroupes
1716 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1717 if erreur != "" : print ("a traiter")
1718 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1724 for groupe in self.listeGroupes :
1725 if groupe[0:8]=='CURRENT_':
1726 texteSources +=groupe[8:]+"=SOURCE("
1727 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1728 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1729 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1730 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1731 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1732 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1733 self.newTexteCND=texte
1738 #---------------------------#
1739 def BoutonFileSelected(self):
1740 #---------------------------#
1742 QSfichier=self.openfile.selectedFiles()[0]
1743 self.fichierMED=str(QSfichier)
1744 from acquiertGroupes import getGroupes
1745 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1746 if erreur != "" : print ("a traiter")
1748 #-----------------------------
1749 def BoutonSalomePressed(self):
1750 #----------------------------
1751 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1752 self.fichierMED="A_partir_de_SMESH"
1753 self.nomMaillage="A_partir_de_SMESH"
1754 self.openfile.close()
1757 #-----------------------------------------
1758 def initSplitterSizes(self, nbWidget=3):
1759 #-----------------------------------------
1760 #print ("je passe ds initSplitterSizes", nbWidget)
1762 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1763 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1764 else : self.splitterSizes3=[150,1000,300]
1766 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1767 else : self.splitterSizes2=[300,1000]
1771 #-----------------------------------------
1772 def restoreSplitterSizes(self,nbWidget=3):
1773 #----------------------------------------
1775 #traceback.print_stack()
1776 #print ("je passe ds restoreSplitterSizes")
1777 if not(hasattr(self,'splitter')) : return
1778 if nbWidget==2 : newSizes=self.splitterSizes2
1779 if nbWidget==3 : newSizes=self.splitterSizes3
1780 #self.inhibeSplitter = 1
1781 self.splitter.setSizes(newSizes)
1782 #self.inhibeSplitter = 0
1783 QApplication.processEvents()
1784 # seule la fentetre du milieu est necessaire
1785 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1787 #-----------------------------------------
1788 def saveSplitterSizes(self,event):
1789 #-----------------------------------------
1790 #print ("je passe ds saveSplitterSizes")
1791 if self.inhibeSplitter : return
1792 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1793 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1795 #------------------------
1796 def fermeOptionnel(self):
1797 #------------------------
1798 if self.widgetOptionnel == None : return
1800 self.inhibeSplitter=1
1801 self.widgetOptionnel.setParent(None)
1802 self.widgetOptionnel.close()
1803 self.widgetOptionnel.deleteLater()
1804 self.widgetOptionnel=None
1805 self.inhibeSplitter=0
1806 self.restoreSplitterSizes(2)
1808 #------------------------
1809 def ajoutOptionnel(self):
1810 #------------------------
1811 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1812 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1813 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1815 self.restoreSplitterSizes(3)
1818 #------------------------
1819 def fermeArbre(self):
1820 #------------------------
1821 #print (self.widgetTree)
1822 self.oldWidgetTree=self.widgetTree
1823 self.widgetTree.hide()
1824 #self.widgetTree=None
1826 #------------------------
1827 def ouvreArbre(self):
1828 #------------------------
1829 #print ('je passe la')
1830 #print (self.widgetTree)
1831 #self.widgetTree=self.oldWidgetTree
1832 self.widgetTree.show()
1833 #self.restoreSplitterSizes(3)
1835 #-----------------------------
1836 def getTreeIndex(self,noeud):
1837 #----------------------------
1839 if noeud in noeud.treeParent.children :
1840 indexNoeud=noeud.treeParent.children.index(noeud)
1842 if hasattr(noeud,'vraiParent') :
1844 noeudVraiParent = noeud.vraiParent
1845 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1846 noeudVrai = noeudVraiParent
1847 noeudVraiParent = noeudVraiParent.vraiParent
1849 if noeudVraiParent == noeud.treeParent :
1850 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1856 if __name__ == "__main__":
1858 name='prefs_'+prefs.code
1859 prefsCode=__import__(name)
1862 if hasattr(prefsCode,'encoding'):
1863 # Hack pour changer le codage par defaut des strings
1866 sys.setdefaultencoding(prefs.encoding)
1867 del sys.setdefaultencoding
1872 app = QApplication(sys.argv)
1873 mw = JDCEditor(None,'azAster.comm')
1874 app.setMainWidget(mw)
1875 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1878 res = app.exec_loop()