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={}
142 nameConf='configuration_'+self.code
143 configuration=__import__(nameConf)
144 self.CONFIGURATION = self.appliEficas.CONFIGURATION
145 self.CONFIGStyle = self.appliEficas.CONFIGStyle
148 self.CONFIGURATION.generator_module
149 _module = __import__(self.CONFIGURATION.generator_module)
150 info = _module.entryPoint()
151 generator.plugins.addEntryPoint(info)
156 self.CONFIGURATION.convert_module
157 #print self.CONFIGURATION.convert_module
158 _module = __import__(self.CONFIGURATION.convert_module)
159 info = _module.entryPoint()
160 convert.plugins.addEntryPoint(info)
165 if hasattr(self.appliEficas,"statusBar"):
166 self.sb = self.appliEficas.statusBar()
169 self.lastModified = 0
171 self.modified = False
172 self.isReadOnly = False
173 self.node_selected = []
176 if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
177 else : self.afficheApresInsert=False
178 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
179 else : self.enteteQTree='complet'
180 if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
181 else : self.affichePlie=False
183 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
185 #------- construction du jdc --------------
190 if self.fichier is not None: # fichier jdc fourni
191 self.fileInfo = QFileInfo(self.fichier)
192 self.fileInfo.setCaching(0)
195 self.jdc = self.readFile(self.fichier)
197 # print ("mauvaise lecture")
200 if self.jdc is not None and units is not None:
201 self.jdc.recorded_units=units
202 self.jdc.old_recorded_units=units
204 if not self.jdc: # nouveau jdc
206 self.jdc = self._newJDC(units=units)
208 self.jdc = self._newJDCInclude(units=units)
212 self.jdc.appli = self # a resorber
213 self.jdc.editor = self
214 self.jdc.lang = self.appli.langue
215 self.jdc.aReafficher=False
219 txt_exception = self.jdc.cr.get_mess_exception()
222 QApplication.restoreOverrideCursor()
223 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
224 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
226 comploader.charger_composants("QT")
227 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
228 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
229 self.viewJdcRapport()
233 if jdc_item and self.appliEficas.ssIhm==False:
234 self.tree = browser.JDCTree( jdc_item, self )
235 self.appliEficas.construitMenu()
242 #-------------------# Pour execution avec output et error dans le bash
244 #-------------------#
246 #if self.modified or self.fichier==None : self.saveFile()
249 #lancement avec le .bat
250 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
251 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
253 p = subprocess.Popen(['python',WrapperFilePath])
254 (out,err)=p.communicate()
258 #-------------------# Pour execution avec output et error dans le bash
259 def runPSEN_N1(self):
260 #-------------------#
264 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
265 sys.path.append(path1)
267 if not(self.jdc.isvalid()):
268 QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
269 if 'dicoImbrique' in generator.plugins:
270 self.generator=generator.plugins['dicoImbrique']()
271 jdc_formate=self.generator.gener(self.jdc)
272 dico=self.generator.Dico
275 #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
276 fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
277 f = open( str(fileDico), 'w')
278 f.write("Dico =" + str(dico) )
283 #print ('in runPSEN_N1', dico)
286 #res,txt_exception=run(dico)
287 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
288 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
290 #-------------------# Pour execution avec output et error dans le bash
291 def process_N1(self):
292 #-------------------#
294 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
295 sys.path.append(path1)
298 if 'dicoImbrique' in generator.plugins:
299 self.generator=generator.plugins['dicoImbrique']()
300 jdc_formate=self.generator.gener(self.jdc)
301 dico=self.get_Dico() #generator.Dico
304 for k in dico['CONTINGENCY_PROCESSING']:
306 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
307 newK=k.replace('___',' ')
309 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
310 del dico['CONTINGENCY_PROCESSING'][k]
313 fileDico = os.path.join(path1, 'dicoN1_process.py')
314 f = open( str(fileDico), 'w')
315 f.write("Dico =" + str(dico) )
320 #return self.get_Dico()
322 #--------------------------------#
323 def ajoutCommentaire(self):
324 #--------------------------------#
325 if self.tree.selectedItems()==[] :
326 QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
328 noeudAvantCommentaire=self.tree.selectedItems()[0]
329 if noeudAvantCommentaire ==self.tree.racine :
330 self.tree.racine.append_child("COMMENTAIRE",pos=0)
332 noeudAvantCommentaire.addComment(True)
336 #--------------------------------#
337 def _newJDC( self ,units = None):
338 #--------------------------------#
340 Initialise un nouveau JDC vierge
343 CONTEXT.unset_current_step()
346 if self.code == "CARMELCND" : texte=self._newJDCCND()
347 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
348 if self.code == "TELEMAC" : texte=self._newTELEMAC()
349 if self.code == "PSEN" : texte = self._newPSEN()
350 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
352 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
354 #if self.code == "CF" : texte = self._new_CF()
355 # texte=self.newTexteCND
357 jdc=self.readercata.cata[0].JdC( procedure =texte,
359 cata=self.readercata.cata,
360 cata_ord_dico=self.readercata.cata_ordonne_dico,
361 rep_mat=self.CONFIGURATION.rep_mat
363 jdc.lang = self.appli.langue
364 if units is not None:
365 jdc.recorded_units=units
366 jdc.old_recorded_units=units
367 ## PNPN est ce que la ligne suivante est bien utile ?
368 if texte == "" :jdc.analyse()
371 #--------------------------------#
372 def _newJDCInclude( self ,units = None):
373 #--------------------------------#
375 Initialise un nouveau JDC vierge
377 import Extensions.jdc_include
378 JdC_aux=Extensions.jdc_include.JdC_include
379 CONTEXT.unset_current_step()
381 jaux=self.readercata.cata[0].JdC( procedure="",
383 cata=self.readercata.cata,
384 cata_ord_dico=self.readercata.cata_ordonne_dico,
385 rep_mat=self.CONFIGURATION.rep_mat,
389 J=JdC_aux( procedure="",
391 cata=self.readercata.cata,
392 cata_ord_dico=self.readercata.cata_ordonne_dico,
394 rep_mat=self.CONFIGURATION.rep_mat,
397 if units is not None:
398 J.recorded_units=units
399 J.old_recorded_units=units
403 #-------------------------------#
404 def readFile(self, fn):
405 #--------------------------------#
407 Public slot to read the text from a file.
408 @param fn filename to read from (string or QString)
410 fn = six.text_type(fn)
412 # ------------------------------------------------------------------------------------
414 # ------------------------------------------------------------------------------------
416 jdcName=os.path.basename(fn)
417 # Il faut convertir le contenu du fichier en fonction du format
418 if self.appliEficas.format_fichier_in in convert.plugins:
419 # Le convertisseur existe on l'utilise
421 p=convert.plugins[self.appliEficas.format_fichier_in]()
423 if p.text=="" : self.nouveau=1
424 pareil,texteNew=self.verifieCHECKSUM(p.text)
426 if pareil == False and (self.appliEficas.ssIhm == False) :
427 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
429 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
430 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
432 text=p.convert('exec',self.appliEficas)
433 if not p.cr.estvide():
434 self.affiche_infos("Erreur a la conversion",Qt.red)
436 self.affiche_infos("Type de fichier non reconnu",Qt.red)
437 if self.appliEficas.ssIhm == False:
438 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
439 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
442 CONTEXT.unset_current_step()
443 jdc=self.readercata.cata[0].JdC(procedure=text,
445 cata=self.readercata.cata,
446 cata_ord_dico=self.readercata.cata_ordonne_dico,
448 rep_mat=self.CONFIGURATION.rep_mat
450 # ----------------------------------------------------
452 # ----------------------------------------------------
453 self.modified = False
455 # qApp.restoreOverrideCursor()
456 if self.fileInfo!= None :
457 self.lastModified = self.fileInfo.lastModified()
459 self.lastModified = 1
460 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
461 self.appliEficas.setWindowTitle(nouveauTitre)
465 #-----------------------#
466 def get_source(self,file):
467 #-----------------------#
469 # Il faut convertir le contenu du fichier en fonction du format
470 if self.format in convert.plugins :
471 # Le convertisseur existe on l'utilise
472 p=convert.plugins[self.format]()
474 text=p.convert('execnoparseur')
475 if not p.cr.estvide():
476 self.affiche_infos("Erreur a la conversion",Qt.red)
479 # Il n'existe pas c'est une erreur
480 self.affiche_infos("Type de fichier non reconnu",Qt.red)
481 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
484 #-----------------------------------------------------------------------#
485 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
486 #--------------------------------------------------------------------#
487 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
491 #----------------------------------------------#
492 def __generateTempFilename(self, prefix, suffix):
493 #----------------------------------------------#
495 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
501 #----------------------------------------------#
502 def _viewTextExecute(self, txt, prefix, suffix):
503 #----------------------------------------------#
504 self.w = ViewText( self.QWParent )
505 self.w.setWindowTitle( "execution" )
506 self.monExe=QProcess(self.w)
507 pid=self.monExe.pid()
508 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
509 f=open(nomFichier,'w')
512 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
513 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
514 exe='sh ' + nomFichier
515 self.monExe.start(exe)
516 self.monExe.closeWriteChannel()
519 commande="rm "+ nomFichier
524 def readFromStdErr(self):
525 a=self.monExe.readAllStandardError()
526 self.w.view.append(str(a.data()))
528 def readFromStdOut(self) :
529 a=self.monExe.readAllStandardOutput()
530 self.w.view.append(str(a.data()))
532 def readFromStdErrQT4(self):
533 a=self.monExe.readAllStandardError()
534 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
536 def readFromStdOutQT4(self) :
537 a=self.monExe.readAllStandardOutput()
538 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
540 #-----------------------#
542 #-----------------------#
543 if 'dico' in generator.plugins:
544 self.generator=generator.plugins['dico']()
545 jdc_formate=self.generator.gener(self.jdc)
546 dico=self.generator.Dico
549 #-----------------------#
550 def gestionParam(self):
551 #-----------------------#
552 w = MonWidgetCreeParam( self)
555 #-----------------------#
556 def viewJdcSource(self):
557 #-----------------------#
558 if self.fichier == None : return
559 f=open(self.fichier,'r')
562 self._viewText(texteSource, "JDC_SOURCE")
564 #-----------------------#
566 #-----------------------#
567 strSource = str( self.get_text_JDC(self.format) )
568 self._viewText(strSource, "JDC_RESULTAT")
570 #-----------------------#
571 def viewJdcRapport(self):
572 #-----------------------#
573 strRapport = six.text_type( self.jdc.report() )
574 # on ajoute les regles
576 self._viewText(strRapport, "JDC_RAPPORT")
578 #-----------------------#
579 def viewJdcRegles(self):
580 #-----------------------#
581 if self.tree :self.tree.AppelleBuildLBRegles()
588 Public method called by the viewmanager to finally get rid of us.
594 #----------------------------------------------#
595 def affiche_infos(self,message,couleur=Qt.black):
596 #----------------------------------------------#
598 mapalette=self.sb.palette()
599 mapalette.setColor( QPalette.WindowText, couleur )
600 self.sb.setPalette( mapalette );
601 self.sb.showMessage(message,4000)
604 #------------------------------#
605 def affiche_alerte(self,titre,message):
606 #------------------------------#
607 # appele par I_MACRO_ETAPE
608 QMessageBox.information( self, titre, message)
610 #-----------------------------------#
611 def affiche_commentaire(self,message):
612 #-----------------------------------#
613 self.labelCommentaire.setText(message)
614 QTimer.singleShot(6000, self.rendInvisible)
616 #----------------------#
617 def rendInvisible(self):
618 #----------------------#
619 self.labelCommentaire.setText("")
621 #-------------------#
622 def init_modif(self):
623 #-------------------#
625 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
626 si un JDC doit etre sauvegarde avant destruction ou non
630 #---------------------------------------#
631 def chercheNoeudSelectionne(self,copie=1):
632 #---------------------------------------#
634 appele par Cut et Copy pour positionner self.node_selected
636 self.node_selected=[]
637 if len(self.tree.selectedItems()) == 0 : return
638 self.node_selected=self.tree.selectedItems()
641 #---------------------#
642 def handleSupprimer(self):
643 #---------------------#
644 self.chercheNoeudSelectionne()
645 if len(self.node_selected) == 0 : return
646 self.QWParent.noeud_a_editer = []
647 if self.node_selected[0]==self.tree.racine: return
648 if len(self.node_selected) == 1 : self.node_selected[0].delete()
649 else : self.node_selected[0].deleteMultiple(self.node_selected)
651 #---------------------#
652 def handleRechercher(self):
653 #---------------------#
654 from .monRecherche import DRecherche
655 monRechercheDialg=DRecherche(parent=self,fl=0)
656 monRechercheDialg.show()
659 #--------------------------------#
660 def handleRechercherDsCatalogue(self):
661 #-----------------------------#
662 from .monRechercheCatalogue import DRechercheCatalogue
663 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
664 monRechercheDialg.show()
666 #---------------------#
667 def handleDeplier(self):
668 #---------------------#
669 if self.tree == None : return
670 #self.tree.collapseAll()
673 self.tree.expandItem(self.tree.topLevelItem(0))
675 if self.fenetreCentraleAffichee != None :
676 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
677 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
680 self.tree.expandItem(self.tree.topLevelItem(0))
682 if self.fenetreCentraleAffichee != None :
683 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
684 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
686 #---------------------#
687 def handleEditCut(self):
688 #---------------------#
690 Stocke dans Eficas.noeud_a_editer le noeud a couper
692 #print "handleEditCut"
693 self.chercheNoeudSelectionne()
694 self.QWParent.edit="couper"
695 self.QWParent.noeud_a_editer = self.node_selected
697 #-----------------------#
698 def handleEditCopy(self):
699 #-----------------------#
701 Stocke dans Eficas.noeud_a_editer le noeud a copier
703 self.chercheNoeudSelectionne()
704 if len(self.node_selected) == 0 : return
705 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
706 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
707 self.QWParent.edit="copier"
708 self.QWParent.noeud_a_editer = self.node_selected
710 #------------------------#
711 def handleEditPaste(self):
712 #------------------------#
714 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
715 Ne permet que la copie d'objets de type Commande ou MCF
717 self.chercheNoeudSelectionne()
718 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
719 QMessageBox.information( self,
720 tr("Copie impossible"),
721 tr("Veuillez selectionner un objet a copier"))
723 if len(self.node_selected) != 1 :
724 QMessageBox.information( self,
725 tr("Copie impossible"),
726 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
729 if len(self.QWParent.noeud_a_editer)!=1:
730 self.handleEditPasteMultiple()
733 noeudOuColler=self.node_selected[0]
735 if noeudOuColler == self.tree.racine:
739 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
740 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
743 noeudACopier=self.QWParent.noeud_a_editer[0]
744 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
745 indexNoeudACopier=self.getTreeIndex(noeudACopier)
747 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
750 if (self.QWParent.edit != "couper"):
752 if noeudOuColler == self.tree.racine :
753 child=noeudOuColler.doPastePremier(noeudACopier)
755 child=noeudACopier.doPaste(noeudOuColler,pos)
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"):
781 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
782 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
786 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
787 indexNoeudACopier=self.getTreeIndex(noeudACopier)
788 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
789 noeudACopier.treeParent.build_children()
794 self.QWParent.noeud_a_editer=[]
796 # on rend la copie a nouveau possible en liberant le flag edit
797 self.QWParent.edit="copier"
798 noeudACopier.select()
800 #----------------------------------#
801 def handleDeplaceMultiple(self):
802 #----------------------------------#
805 #----------------------------------#
806 def handleEditPasteMultiple(self):
807 #----------------------------------#
809 # On ne garde que les niveaux "Etape"
810 # On insere dans l'ordre du JDC
811 listeNoeudsACouper=[]
815 from InterfaceQT4 import compojdc
816 noeudOuColler=self.node_selected[0]
817 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
818 QMessageBox.information( self,
819 tr("Copie impossible a cet endroit",),
820 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
822 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
824 for noeud in self.QWParent.noeud_a_editer :
825 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
826 indexInTree=noeud.treeParent.children.index(noeud)
828 for index in listeIndex:
829 if index < indexInTree : indice = indice +1
830 listeIndex.insert(indice, indexInTree)
831 listeNoeudsACouper.insert(indice, noeud)
833 noeudJdc=noeudOuColler.treeParent
835 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
837 for index in listeIndex:
839 if indexNoeudOuColler < index:
840 indexTravail=indexTravail+dejaCrees
841 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
842 noeud=noeudJdc.children[indexTravail]
843 child=noeud.doPaste(noeudOuColler)
844 listeChild.append(child)
845 dejaCrees=dejaCrees+1
847 self.QWParent.noeud_a_editer = []
848 for i in range(len(listeIndex)):
849 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
850 self.QWParent.noeud_a_editer.append(noeud)
853 if self.QWParent.edit !="couper" : return
855 for index in listeIndex:
857 if indexNoeudOuColler < index:
858 indexTravail=indexTravail+(len(listeIndex))
859 noeud=noeudJdc.children[indexTravail]
861 listeItem.append(noeud.item)
862 listeASupprimer.append(noeud)
864 for i in range(len(listeChild)):
865 self.tree.item.suppitem(listeItem[i])
866 listeChild[i].item.update(listeItem[i])
868 self.QWParent.noeud_a_editer = []
871 #---------------------#
872 def getFileName(self):
873 #---------------------#
876 #---------------------------#
877 def get_file_variable(self) :
878 #---------------------------#
879 titre = tr("Choix d'un fichier XML")
880 texte = tr("Le fichier contient une commande MODEL\n")
881 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
882 QMessageBox.information( self, titre,tr(texte))
884 fichier = QFileDialog.getOpenFileName(self.appliEficas,
885 tr('Ouvrir Fichier'),
886 self.appliEficas.CONFIGURATION.savedir,
887 tr('Wrapper Files (*.xml);;''All Files (*)'))
890 #--------------------------------------------------#
891 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
892 #--------------------------------------------------#
894 Public slot to write the text to a file.
896 @param fn filename to write to string
897 @return flag indicating success
900 fn = six.text_type(fn)
903 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
905 if len(txt) >= len(eol):
906 if txt[-len(eol):] != eol:
910 txt=self.ajoutVersionCataDsJDC(txt)
911 checksum=self.get_checksum(txt)
913 if self.code=="TELEMAC" : return 1
919 except IOError as why:
920 if (self.appliEficas.ssIhm == False):
921 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
922 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
927 #-----------------------------------------------------------#
928 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
929 #-----------------------------------------------------------#
930 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
931 if format in generator.plugins:
933 # Le generateur existe on l'utilise
934 self.generator=generator.plugins[format]()
936 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
937 if pourRun : jdc_formate=self.generator.textePourRun
938 except ValueError as e:
939 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
942 if not self.generator.cr.estvide():
943 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
944 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
949 # Il n'existe pas c'est une erreur
950 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
951 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
954 #----------------------#
956 #---------------------#
957 if 'dicoImbrique' in generator.plugins:
958 self.generator=generator.plugins['dicoImbrique']()
959 jdc_formate=self.generator.gener(self.jdc)
960 dico=self.generator.Dico
963 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
964 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
971 fonction="run"+self.code
973 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
978 fonction="saveRun"+self.code
979 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
985 if not(self.jdc.isvalid()):
986 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
988 if len(self.jdc.etapes) != 1 :
989 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
991 if self.modified or self.fichier==None :
992 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
993 texte=self.get_text_JDC("MAP")
994 self.writeFile( self.fichierMapInput, txt = texte)
996 self.fichierMapInput=self.fichier
997 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1000 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
1001 # then instantiate corresponding class and call getUseSalome() method
1003 from mapengine.spec import factory
1004 mapComponent = factory.new(composant)[0]
1007 if mapComponent.getUseSalome():
1008 command += " -r sappli"
1009 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
1011 #textePython="ls -l"
1012 self._viewTextExecute( textePython,"map_run",".sh")
1014 # commande="rm "+self.fichierMapInput
1015 # os.system(commande)
1018 except Exception as e:
1019 print((traceback.print_exc()))
1021 #-------------------#
1022 def runZCRACKS(self):
1023 #-------------------#
1024 if not(self.jdc.isvalid()):
1025 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1027 if self.modified or self.fichier==None :
1029 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1030 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1031 self.writeFile( self.fichierZcracksInput, txt = texte)
1033 self.fichierZcracksInput=self.fichier
1035 #commande ="Zrun -zp "
1037 textePython=(commande + self.fichierZcracksInput)
1038 self._viewTextExecute( textePython,"run_zcracks",".sh")
1039 except Exception as e:
1040 print((traceback.print_exc()))
1042 #-------------------#
1043 def runCARMELCND(self):
1044 #-------------------#
1045 #if not(self.jdc.isvalid()):
1046 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1048 if self.modified or self.fichier==None :
1049 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1051 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1052 from PrepareRunCarmel import prepareRunCarmel
1053 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1054 repMed=os.path.dirname(self.fichier)
1055 repExeCarmel=self.generator.get_repExeCarmel()
1056 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1057 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1058 f=open(nomFichier,'w')
1059 f.write(textePython)
1061 commande="xterm -e sh "+nomFichier +"\n"
1064 #-------------------#
1065 def runCarmelCS(self):
1066 #-------------------#
1068 commande="runSession pilotyacsCS.py"
1070 except Exception as e:
1071 print((traceback.print_exc()))
1073 #-----------------------------------------------------#
1074 def determineNomFichier(self,path,extension):
1075 #-----------------------------------------------------#
1076 if self.appli.code in DictExtensions:
1077 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1078 extensions= tr(chaine1+ "All Files (*)")
1080 extensions= tr("JDC (*.comm);;" "All Files (*)")
1082 if self.appli.code == "MAP" :
1083 extensions = extensions + ";; Run (*.input);;"
1085 fn = QFileDialog.getSaveFileName( self,
1086 tr("sauvegarde"), path,
1088 QFileDialog.DontConfirmOverwrite)
1089 if fn == None : return (0, None)
1091 if fn=='': return (0, None)
1093 ext = QFileInfo(fn).suffix()
1094 if ext == '': fn+=extension
1096 if QFileInfo(fn).exists():
1097 msgBox = QMessageBox(self)
1098 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1099 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1100 msgBox.addButton(tr("&Ecraser"),0)
1101 msgBox.addButton(tr("&Abandonner"),1)
1102 abort=msgBox.exec_()
1103 if abort == 1 : return (0, "")
1107 def saveRunMAP(self):
1110 if not(self.jdc.isvalid()):
1111 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1112 tr("Un JdC valide est necessaire pour creer un .input")
1116 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1118 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1119 tr("Choix du composant obligatoire")
1122 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1126 if self.fichier is not None and self.fichier != "" :
1127 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1128 monPath=str(QFileInfo(self.fichier).absolutePath())
1129 monNomFichier=os.path.join(monPath,maBase)
1130 elif hasattr(self,'monNomFichierInput'):
1131 monNomFichier=self.monNomFichierInput
1134 monDialog=QFileDialog(self.appliEficas)
1135 monDialog.setDirectory (path)
1136 monDialog.setWindowTitle ("Save")
1138 for c in monDialog.children():
1139 if isinstance(c,QDialogButtonBox):
1140 for b in c.children():
1141 if isinstance(b,QPushButton):
1143 if avant=="&Open": b.setText("Save")
1144 mesFiltres= "input Map (*.input);;All Files (*)"
1145 monDialog.setNameFilters(mesFiltres)
1146 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1147 BOk=monDialog.exec_()
1149 fn=str(monDialog.selectedFiles()[0])
1150 if fn == "" or fn == None : return
1151 if not fn.endswith(".input"):
1153 self.monNomFichierInput=fn
1155 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1156 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1157 texte=self.get_text_JDC("MAP")
1158 self.writeFile( self.fichierMapInput, txt = texte)
1160 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1161 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1162 (output, err) = p.communicate()
1166 def saveRunPSEN(self):
1168 #print ("saveRunPSEN")
1172 #-----------------------------------------#
1173 def cherche_Groupes(self):
1174 #-----------------------------------------#
1175 listeMA,listeNO=self.get_text_JDC("GroupMA")
1176 return listeMA,listeNO
1178 #-----------------------------------------#
1179 def cherche_Dico(self):
1180 #-----------------------------------------#
1182 format = self.appliEficas.format_fichier
1183 if format in generator.plugins:
1184 # Le generateur existe on l'utilise
1185 self.generator=generator.plugins[format]()
1186 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1187 dicoCourant=self.generator.dico
1192 #-----------------------------------------#
1193 def handleAjoutGroup(self,listeGroup):
1194 #-----------------------------------------#
1197 from ajoutGroupe import handleAjoutGroupFiltre
1199 handleAjoutGroupFiltre(self,listeGroup)
1200 #print "apres handleAjoutGroupFiltre"
1205 #-----------------------------------------------------------------#
1206 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1207 #-----------------------------------------------------------------#
1210 #saveas=True # Pour forcer le nom
1211 self.generator=generator.plugins[self.format]()
1212 if self.fichier is None or saveas:
1213 if path is None: path=self.CONFIGURATION.savedir
1214 bOK, fn=self.determineNomFichier(path,extension)
1215 if bOK == 0 : return (0, None)
1216 if fn == None : return (0, None)
1217 if fn== '' : return (0, None)
1219 ulfile = os.path.abspath(six.text_type(fn))
1220 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1221 fn = six.text_type(QDir.toNativeSeparators(fn))
1223 self.fichier = os.path.splitext(fn)[0]+extension
1225 if hasattr(self.generator, "writeLeger"):
1226 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1228 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1231 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1232 self.appliEficas.setWindowTitle(nouveauTitre)
1233 return (1, self.fichier)
1235 #-----------------------------------------------------------------#
1236 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1237 #-----------------------------------------------------------------#
1239 Public slot to save the text to a file.
1241 @param path directory to save the file in (string or QString)
1242 @return tuple of two values (boolean, string) giving a success indicator and
1243 the name of the saved file
1247 if not self.modified and not saveas:
1248 return (0, None) # do nothing if text wasn't changed
1250 if self.appli.code in DictExtensions :
1251 extension=DictExtensions[self.appli.code]
1257 if self.fichier is None or saveas:
1258 if path is None: path=self.CONFIGURATION.savedir
1259 bOK, fn=self.determineNomFichier(path,extension)
1260 if bOK == 0 : return (0, None)
1261 if fn == None : return (0, None)
1262 if fn== '' : return (0, None)
1264 ulfile = os.path.abspath(six.text_type(fn))
1265 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1266 fn = six.text_type(QDir.toNativeSeparators(fn))
1270 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1272 self.modified = False
1273 if self.fileInfo is None or saveas:
1274 self.fileInfo = QFileInfo(self.fichier)
1275 self.fileInfo.setCaching(0)
1276 self.lastModified = self.fileInfo.lastModified()
1277 if newName is not None:
1278 self.appliEficas.addToRecentList(newName)
1279 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1280 self.tree.racine.update_node_label()
1282 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1283 self.generator.writeDefault(fn)
1284 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1285 self.generator.writeDefault(fn)
1288 self.appliEficas.addJdcInSalome( self.fichier)
1290 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1291 self.appliEficas.setWindowTitle(nouveauTitre)
1293 return (1, self.fichier)
1296 #----------------------------------------------#
1297 def sauveLigneFile(self):
1298 #----------------------------------------------#
1300 return self.saveFile(formatLigne="Ligne")
1303 #----------------------------------------------#
1304 def saveFileAs(self, path = None,fileName=None):
1305 #----------------------------------------------#
1307 Public slot to save a file with a new name.
1309 @param path directory to save the file in (string or QString)
1310 @return tuple of two values (boolean, string) giving a success indicator and
1311 the name of the saved file
1313 if fileName != None :
1314 self.fichier = fileName
1315 return self.saveFile()
1316 return self.saveFile(path,1,"beautifie")
1320 #---------------------------------------------#
1321 def get_file(self,unite=None,fic_origine = ''):
1322 #---------------------------------------------#
1330 titre = tr("Choix unite %d ", unite)
1331 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1332 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1333 labeltexte = tr('Fichier pour unite ') + repr( unite)
1335 titre = tr("Choix d'un fichier de poursuite")
1336 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1337 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1339 QMessageBox.information( self, titre,texte)
1340 fn = QFileDialog.getOpenFileName(self.appliEficas,
1342 self.appliEficas.CONFIGURATION.savedir)
1344 # ce retour est impose par le get_file d'I_JDC
1345 if fn== '' : return None," "
1346 if not fn : return (0, " ")
1349 ulfile = os.path.abspath(six.text_type(fn))
1350 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1352 # On utilise le convertisseur defini par format_fichier
1353 source=self.get_source(ulfile)
1355 # On a reussia convertir le fichier self.ulfile
1358 # Une erreur a ete rencontree
1360 return ulfile, jdcText
1362 #-------------------------------#
1363 def updateJdc(self, itemApres,texte):
1364 #--------------------------------#
1366 etape=monItem.item.object
1368 CONTEXT.set_current_step(etape)
1369 etape.build_includeInclude(texte)
1370 self.tree.racine.build_children()
1372 #-------------------------------------#
1373 def deleteEtape(self,etape):
1374 #-------------------------------------#
1375 self.jdc.suppentite(etape)
1377 #-------------------------------------#
1378 def deleteMC(self,etape,MCFils,listeAvant=()):
1379 #-------------------------------------#
1381 for mot in listeAvant :
1382 ouChercher=ouChercher.get_child(mot,restreint="oui")
1383 monMC=ouChercher.get_child(MCFils,restreint="oui")
1384 if monMC != None : ouChercher.suppentite(monMC)
1385 ouChercher.state='changed'
1386 ouChercher.isvalid()
1388 #-------------------------------------#
1389 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1390 #-------------------------------------#
1392 for mot in listeAvant :
1393 ouChercher=ouChercher.get_child(mot,restreint="oui")
1394 monMC=etape.get_child(ouChercher,restreint="oui")
1395 if monMC== None : monMC= ouChercher.addentite(MCFils)
1396 monMC.valeur=valeurs
1398 monMC.state='changed'
1401 #-----------------------------------------------------------#
1402 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1403 #-----------------------------------------------------------#
1405 for mot in listeAvant :
1406 ouChercher=ouChercher.get_child(mot,restreint="oui")
1407 if ouChercher ==None : print ('SOUCI'); return
1408 monMC=ouChercher.get_child(MCFils,restreint="oui")
1409 if monMC== None : monMC= ouChercher.addentite(MCFils)
1411 monMC.definition.into=valeurs
1412 from Noyau.N_VALIDATOR import IntoProtocol
1413 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1414 monMC.state='changed'
1417 #----------------------------------------------------#
1418 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1419 #----------------------------------------------------#
1420 for e in self.jdc.etapes:
1421 if e.nom == nomEtape : ouChercher=e; break
1423 for mot in listeAvant :
1425 ouChercher=ouChercher.get_child(mot,restreint="oui")
1426 # Le mot clef n est pas la
1429 monMC=ouChercher.get_child(MCFils,restreint="oui")
1430 # Le mot clef n est pas la
1433 #print ('________',monMC)
1434 if hasattr(monMC.definition,'into') :
1435 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1436 else : maListeDeValeur=monMC.definition.into
1440 monMC.state='changed'
1444 #-------------------------------------#
1445 def changeIntoDefMC(self,etape,listeMC,valeurs):
1446 #-------------------------------------#
1447 definitionEtape=getattr(self.jdc.cata[0],etape)
1448 ouChercher=definitionEtape
1449 if len(listeMC) > 1 :
1451 for mc in listeMC[0:-1]:
1452 mcfact=ouChercher.entites[mc]
1455 mcAccas=ouChercher.entites[listeMC[-1]]
1457 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1458 else : oldValeurs=None
1459 if oldValeurs==valeurs : return 0
1461 mcAccas.into=valeurs
1462 from Noyau.N_VALIDATOR import IntoProtocol
1463 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1466 #-------------------------------------------------------------#
1467 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1468 #-------------------------------------------------------------#
1469 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1470 definitionEtape=getattr(self.jdc.cata[0],etape)
1471 ouChercher=definitionEtape
1472 for k in listeAvant :
1473 ouChercher=ouChercher.entites[k]
1474 MCADetruire=ouChercher.entites[nomDuMC]
1475 ouChercher.ordre_mc.remove(nomDuMC)
1476 del ouChercher.entites[nomDuMC]
1477 del self.dicoNouveauxMC[nomDuMC]
1480 #-------------------------------------------------------------#
1481 def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1482 #-------------------------------------------------------------#
1483 definitionEtape=getattr(self.jdc.cata[0],etape)
1484 ouChercher=definitionEtape
1485 for k in listeAvant :
1486 ouChercher=ouChercher.entites[k]
1487 from Accas import A_SIMP
1488 Nouveau=A_SIMP.SIMP(typ,**args)
1489 Nouveau.pere=ouChercher
1492 ouChercher.entites[nomDuMC]=Nouveau
1493 ouChercher.ordre_mc.append(nomDuMC)
1494 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1495 #print self.dicoNouveauxMC
1497 #----------------------------------------------------#
1498 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1499 #----------------------------------------------------#
1500 monMC=etape.get_child(MCFils,restreint="oui")
1501 if monMC== None : monMC= etape.addentite(MCFils)
1502 monMC.definition.into=into
1503 monMC.valeur=valeurs
1505 monMC.state='changed'
1508 #-------------------------------------#
1509 def ajoutVersionCataDsJDC(self,txt):
1510 #-------------------------------------#
1511 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1512 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1513 texte=txt+ligneVersion
1516 #-------------------------------------#
1517 def verifieVersionCataDuJDC(self,text):
1518 #-------------------------------------#
1520 indexDeb=text.find("#VERSION_CATALOGUE:")
1521 indexFin=text.find(":FIN VERSION_CATALOGUE")
1523 self.versionCataDuJDC="sans"
1526 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1527 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1529 self.versionCata="sans"
1530 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1532 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1533 return memeVersion,textJDC
1535 #-------------------------------#
1536 def traduitCatalogue(self,texte):
1537 #-------------------------------#
1538 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1539 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1541 traducteur=__import__(nomTraducteur)
1542 monTraducteur=traducteur.MonTraducteur(texte)
1543 nouveauTexte=monTraducteur.traduit()
1549 #------------------------------#
1550 def verifieCHECKSUM(self,text):
1551 #------------------------------#
1552 indexDeb=text.find("#CHECKSUM:")
1555 indexFin=text.find(":FIN CHECKSUM")
1556 checkAvant=text[indexDeb:indexFin+13]
1557 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1558 checksum=self.get_checksum(textJDC)
1559 pareil=(checkAvant==checksum)
1560 return pareil, textJDC
1562 #---------------------------#
1563 def get_checksum(self,texte):
1564 #---------------------------#
1565 newtexte=texte.replace('"','\\"')
1566 commande='echo "'+newtexte+'"|md5sum'
1567 a=os.popen(commande)
1570 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1574 #---------------------------#
1576 #---------------------------#
1577 texte="CONDUITE_FORCEE();"
1581 #---------------------------#
1582 def _newTELEMAC(self):
1583 #---------------------------#
1584 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1585 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1589 #---------------------------#
1591 #---------------------------#
1592 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1596 #---------------------------#
1597 def _newPSEN_N1(self):
1598 #---------------------------#
1599 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1600 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1603 #---------------------------#
1605 #---------------------------#
1606 def _newZCRACKS(self):
1607 #---------------------------#
1608 texte="MAILLAGES();REMESHING();"
1611 #---------------------------#
1612 def _newJDCCND(self):
1613 #---------------------------#
1614 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1616 #if self.salome == 0 :
1617 QMessageBox.information( self,
1619 tr("Veuillez selectionner un fichier Med"))
1620 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1621 caption='Fichier Med',
1623 QSfichier=QSfichier[0]
1624 self.fichierMED=QSfichier
1625 from acquiertGroupes import getGroupes
1626 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1627 if erreur != "" : print ("a traiter")
1628 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1634 for groupe in self.listeGroupes :
1635 if groupe[0:8]=='CURRENT_':
1636 texteSources +=groupe[8:]+"=SOURCE("
1637 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1638 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1639 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1640 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1641 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1642 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1643 self.newTexteCND=texte
1648 #---------------------------#
1649 def BoutonFileSelected(self):
1650 #---------------------------#
1652 QSfichier=self.openfile.selectedFiles()[0]
1653 self.fichierMED=str(QSfichier)
1654 from acquiertGroupes import getGroupes
1655 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1656 if erreur != "" : print ("a traiter")
1658 #-----------------------------
1659 def BoutonSalomePressed(self):
1660 #----------------------------
1661 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1662 self.fichierMED="A_partir_de_SMESH"
1663 self.nomMaillage="A_partir_de_SMESH"
1664 self.openfile.close()
1667 #-----------------------------------------
1668 def initSplitterSizes(self, nbWidget=3):
1669 #-----------------------------------------
1670 #print ("je passe ds initSplitterSizes", nbWidget)
1672 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1673 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1674 else : self.splitterSizes3=[150,1000,300]
1676 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1677 else : self.splitterSizes2=[300,1000]
1681 #-----------------------------------------
1682 def restoreSplitterSizes(self,nbWidget=3):
1683 #----------------------------------------
1685 #traceback.print_stack()
1686 #print ("je passe ds restoreSplitterSizes")
1687 if not(hasattr(self,'splitter')) : return
1688 if nbWidget==2 : newSizes=self.splitterSizes2
1689 if nbWidget==3 : newSizes=self.splitterSizes3
1690 #self.inhibeSplitter = 1
1691 self.splitter.setSizes(newSizes)
1692 #self.inhibeSplitter = 0
1693 QApplication.processEvents()
1694 # seule la fentetre du milieu est necessaire
1695 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1697 #-----------------------------------------
1698 def saveSplitterSizes(self,event):
1699 #-----------------------------------------
1700 #print ("je passe ds saveSplitterSizes")
1701 if self.inhibeSplitter : return
1702 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1703 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1705 #------------------------
1706 def fermeOptionnel(self):
1707 #------------------------
1708 if self.widgetOptionnel == None : return
1710 self.inhibeSplitter=1
1711 self.widgetOptionnel.setParent(None)
1712 self.widgetOptionnel.close()
1713 self.widgetOptionnel.deleteLater()
1714 self.widgetOptionnel=None
1715 self.inhibeSplitter=0
1716 self.restoreSplitterSizes(2)
1718 #------------------------
1719 def ajoutOptionnel(self):
1720 #------------------------
1721 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1722 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1723 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1725 self.restoreSplitterSizes(3)
1728 #------------------------
1729 def fermeArbre(self):
1730 #------------------------
1731 #print (self.widgetTree)
1732 self.oldWidgetTree=self.widgetTree
1733 self.widgetTree.hide()
1734 #self.widgetTree=None
1736 #------------------------
1737 def ouvreArbre(self):
1738 #------------------------
1739 #print ('je passe la')
1740 #print (self.widgetTree)
1741 #self.widgetTree=self.oldWidgetTree
1742 self.widgetTree.show()
1743 #self.restoreSplitterSizes(3)
1745 #-----------------------------
1746 def getTreeIndex(self,noeud):
1747 #----------------------------
1749 if noeud in noeud.treeParent.children :
1750 indexNoeud=noeud.treeParent.children.index(noeud)
1752 if hasattr(noeud,'vraiParent') :
1754 noeudVraiParent = noeud.vraiParent
1755 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1756 noeudVrai = noeudVraiParent
1757 noeudVraiParent = noeudVraiParent.vraiParent
1759 if noeudVraiParent == noeud.treeParent :
1760 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1766 if __name__ == "__main__":
1768 name='prefs_'+prefs.code
1769 prefsCode=__import__(name)
1772 if hasattr(prefsCode,'encoding'):
1773 # Hack pour changer le codage par defaut des strings
1776 sys.setdefaultencoding(prefs.encoding)
1777 del sys.setdefaultencoding
1782 app = QApplication(sys.argv)
1783 mw = JDCEditor(None,'azAster.comm')
1784 app.setMainWidget(mw)
1785 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1788 res = app.exec_loop()