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.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
109 #self.taille = self.appliEficas.taille
111 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
112 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
113 if self.code in ['MAP',]:
114 self.widgetTree.close()
116 if self.closeArbre: self.fermeArbre()
118 self.version_code = session.d_env.cata
121 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
122 self.readercata = readercata.READERCATA( self, self.appliEficas )
123 self.appliEficas.readercata=self.readercata
124 self.appliEficas.code=self.code
126 self.readercata=self.appliEficas.readercata
127 if self.readercata.fic_cata == None : return #Sortie Salome
128 self.titre=self.readercata.titre
129 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
130 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
132 self.format = self.appliEficas.format_fichier
135 self.liste_simp_reel=[]
137 self.dicoNouveauxMC={}
139 nameConf='configuration_'+self.code
140 configuration=__import__(nameConf)
141 self.CONFIGURATION = self.appliEficas.CONFIGURATION
142 self.CONFIGStyle = self.appliEficas.CONFIGStyle
145 self.CONFIGURATION.generator_module
146 _module = __import__(self.CONFIGURATION.generator_module)
147 info = _module.entryPoint()
148 generator.plugins.addEntryPoint(info)
153 self.CONFIGURATION.convert_module
154 #print self.CONFIGURATION.convert_module
155 _module = __import__(self.CONFIGURATION.convert_module)
156 info = _module.entryPoint()
157 convert.plugins.addEntryPoint(info)
162 if hasattr(self.appliEficas,"statusBar"):
163 self.sb = self.appliEficas.statusBar()
166 self.lastModified = 0
168 self.modified = False
169 self.isReadOnly = False
170 self.node_selected = []
173 if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
174 else : self.afficheApresInsert=False
175 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
176 else : self.enteteQTree='complet'
177 if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
178 else : self.affichePlie=False
180 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
182 #------- construction du jdc --------------
187 if self.fichier is not None: # fichier jdc fourni
188 self.fileInfo = QFileInfo(self.fichier)
189 self.fileInfo.setCaching(0)
192 self.jdc = self.readFile(self.fichier)
194 # print ("mauvaise lecture")
197 if self.jdc is not None and units is not None:
198 self.jdc.recorded_units=units
199 self.jdc.old_recorded_units=units
201 if not self.jdc: # nouveau jdc
203 self.jdc = self._newJDC(units=units)
205 self.jdc = self._newJDCInclude(units=units)
209 self.jdc.appli = self # a resorber
210 self.jdc.editor = self
211 self.jdc.lang = self.appli.langue
212 self.jdc.aReafficher=False
216 txt_exception = self.jdc.cr.get_mess_exception()
219 QApplication.restoreOverrideCursor()
220 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
221 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
223 comploader.charger_composants("QT")
224 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
225 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
226 self.viewJdcRapport()
230 if jdc_item and self.appliEficas.ssIhm==False:
231 self.tree = browser.JDCTree( jdc_item, self )
232 self.appliEficas.construitMenu()
239 #-------------------# Pour execution avec output et error dans le bash
241 #-------------------#
243 #if self.modified or self.fichier==None : self.saveFile()
246 #lancement avec le .bat
247 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
248 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
250 p = subprocess.Popen(['python',WrapperFilePath])
251 (out,err)=p.communicate()
255 #-------------------# Pour execution avec output et error dans le bash
256 def runPSEN_N1(self):
257 #-------------------#
261 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
262 sys.path.append(path1)
264 if not(self.jdc.isvalid()):
265 QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
266 if 'dicoImbrique' in generator.plugins:
267 self.generator=generator.plugins['dicoImbrique']()
268 jdc_formate=self.generator.gener(self.jdc)
269 dico=self.generator.Dico
272 #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
273 fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
274 f = open( str(fileDico), 'w')
275 f.write("Dico =" + str(dico) )
280 #print ('in runPSEN_N1', dico)
283 #res,txt_exception=run(dico)
284 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
285 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
287 #-------------------# Pour execution avec output et error dans le bash
288 def process_N1(self):
289 #-------------------#
291 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
292 sys.path.append(path1)
295 if 'dicoImbrique' in generator.plugins:
296 self.generator=generator.plugins['dicoImbrique']()
297 jdc_formate=self.generator.gener(self.jdc)
298 dico=self.get_Dico() #generator.Dico
301 for k in dico['CONTINGENCY_PROCESSING']:
303 if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
304 newK=k.replace('___',' ')
306 dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
307 del dico['CONTINGENCY_PROCESSING'][k]
310 fileDico = os.path.join(path1, 'dicoN1_process.py')
311 f = open( str(fileDico), 'w')
312 f.write("Dico =" + str(dico) )
317 #return self.get_Dico()
321 #--------------------------------#
322 def _newJDC( self ,units = None):
323 #--------------------------------#
325 Initialise un nouveau JDC vierge
328 CONTEXT.unset_current_step()
331 if self.code == "CARMELCND" : texte=self._newJDCCND()
332 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
333 if self.code == "TELEMAC" : texte=self._newTELEMAC()
334 if self.code == "PSEN" : texte = self._newPSEN()
335 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
337 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
339 #if self.code == "CF" : texte = self._new_CF()
340 # texte=self.newTexteCND
342 jdc=self.readercata.cata[0].JdC( procedure =texte,
344 cata=self.readercata.cata,
345 cata_ord_dico=self.readercata.cata_ordonne_dico,
346 rep_mat=self.CONFIGURATION.rep_mat
348 jdc.lang = self.appli.langue
349 if units is not None:
350 jdc.recorded_units=units
351 jdc.old_recorded_units=units
352 ## PNPN est ce que la ligne suivante est bien utile ?
353 if texte == "" :jdc.analyse()
356 #--------------------------------#
357 def _newJDCInclude( self ,units = None):
358 #--------------------------------#
360 Initialise un nouveau JDC vierge
362 import Extensions.jdc_include
363 JdC_aux=Extensions.jdc_include.JdC_include
364 CONTEXT.unset_current_step()
366 jaux=self.readercata.cata[0].JdC( procedure="",
368 cata=self.readercata.cata,
369 cata_ord_dico=self.readercata.cata_ordonne_dico,
370 rep_mat=self.CONFIGURATION.rep_mat,
374 J=JdC_aux( procedure="",
376 cata=self.readercata.cata,
377 cata_ord_dico=self.readercata.cata_ordonne_dico,
379 rep_mat=self.CONFIGURATION.rep_mat,
382 if units is not None:
383 J.recorded_units=units
384 J.old_recorded_units=units
388 #-------------------------------#
389 def readFile(self, fn):
390 #--------------------------------#
392 Public slot to read the text from a file.
393 @param fn filename to read from (string or QString)
395 fn = six.text_type(fn)
397 # ------------------------------------------------------------------------------------
399 # ------------------------------------------------------------------------------------
401 jdcName=os.path.basename(fn)
402 # Il faut convertir le contenu du fichier en fonction du format
403 if self.appliEficas.format_fichier_in in convert.plugins:
404 # Le convertisseur existe on l'utilise
406 p=convert.plugins[self.appliEficas.format_fichier_in]()
408 if p.text=="" : self.nouveau=1
409 pareil,texteNew=self.verifieCHECKSUM(p.text)
411 if pareil == False and (self.appliEficas.ssIhm == False) :
412 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
414 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
415 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
417 text=p.convert('exec',self.appliEficas)
418 if not p.cr.estvide():
419 self.affiche_infos("Erreur a la conversion",Qt.red)
421 self.affiche_infos("Type de fichier non reconnu",Qt.red)
422 if self.appliEficas.ssIhm == False:
423 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
424 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
427 CONTEXT.unset_current_step()
428 jdc=self.readercata.cata[0].JdC(procedure=text,
430 cata=self.readercata.cata,
431 cata_ord_dico=self.readercata.cata_ordonne_dico,
433 rep_mat=self.CONFIGURATION.rep_mat
435 # ----------------------------------------------------
437 # ----------------------------------------------------
438 self.modified = False
440 # qApp.restoreOverrideCursor()
441 if self.fileInfo!= None :
442 self.lastModified = self.fileInfo.lastModified()
444 self.lastModified = 1
445 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
446 self.appliEficas.setWindowTitle(nouveauTitre)
450 #-----------------------#
451 def get_source(self,file):
452 #-----------------------#
454 # Il faut convertir le contenu du fichier en fonction du format
455 if self.format in convert.plugins :
456 # Le convertisseur existe on l'utilise
457 p=convert.plugins[self.format]()
459 text=p.convert('execnoparseur')
460 if not p.cr.estvide():
461 self.affiche_infos("Erreur a la conversion",Qt.red)
464 # Il n'existe pas c'est une erreur
465 self.affiche_infos("Type de fichier non reconnu",Qt.red)
466 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
469 #-----------------------------------------------------------------------#
470 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
471 #--------------------------------------------------------------------#
472 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
476 #----------------------------------------------#
477 def __generateTempFilename(self, prefix, suffix):
478 #----------------------------------------------#
480 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
486 #----------------------------------------------#
487 def _viewTextExecute(self, txt, prefix, suffix):
488 #----------------------------------------------#
489 self.w = ViewText( self.QWParent )
490 self.w.setWindowTitle( "execution" )
491 self.monExe=QProcess(self.w)
492 pid=self.monExe.pid()
493 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
494 f=open(nomFichier,'w')
497 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
498 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
499 exe='sh ' + nomFichier
500 self.monExe.start(exe)
501 self.monExe.closeWriteChannel()
504 commande="rm "+ nomFichier
509 def readFromStdErr(self):
510 a=self.monExe.readAllStandardError()
511 self.w.view.append(str(a.data(),len(a)))
513 def readFromStdErr(self) :
514 a=self.monExe.readAllStandardOutput()
515 self.w.view.append(str(a.data(),len(a)))
517 def readFromStdErrQT4(self):
518 a=self.monExe.readAllStandardError()
519 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
521 def readFromStdOutQT4(self) :
522 a=self.monExe.readAllStandardOutput()
523 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
525 #-----------------------#
527 #-----------------------#
528 if 'dico' in generator.plugins:
529 self.generator=generator.plugins['dico']()
530 jdc_formate=self.generator.gener(self.jdc)
531 dico=self.generator.Dico
534 #-----------------------#
535 def gestionParam(self):
536 #-----------------------#
537 w = MonWidgetCreeParam( self)
540 #-----------------------#
541 def viewJdcSource(self):
542 #-----------------------#
543 if self.fichier == None : return
544 f=open(self.fichier,'r')
547 self._viewText(texteSource, "JDC_SOURCE")
549 #-----------------------#
551 #-----------------------#
552 strSource = str( self.get_text_JDC(self.format) )
553 self._viewText(strSource, "JDC_RESULTAT")
555 #-----------------------#
556 def viewJdcRapport(self):
557 #-----------------------#
558 strRapport = six.text_type( self.jdc.report() )
559 # on ajoute les regles
561 self._viewText(strRapport, "JDC_RAPPORT")
563 #-----------------------#
564 def viewJdcRegles(self):
565 #-----------------------#
566 if self.tree :self.tree.AppelleBuildLBRegles()
573 Public method called by the viewmanager to finally get rid of us.
579 #----------------------------------------------#
580 def affiche_infos(self,message,couleur=Qt.black):
581 #----------------------------------------------#
583 mapalette=self.sb.palette()
584 mapalette.setColor( QPalette.WindowText, couleur )
585 self.sb.setPalette( mapalette );
586 self.sb.showMessage(message,4000)
589 #------------------------------#
590 def affiche_alerte(self,titre,message):
591 #------------------------------#
592 # appele par I_MACRO_ETAPE
593 QMessageBox.information( self, titre, message)
595 #-----------------------------------#
596 def affiche_commentaire(self,message):
597 #-----------------------------------#
598 self.labelCommentaire.setText(message)
599 QTimer.singleShot(6000, self.rendInvisible)
601 #----------------------#
602 def rendInvisible(self):
603 #----------------------#
604 self.labelCommentaire.setText("")
606 #-------------------#
607 def init_modif(self):
608 #-------------------#
610 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
611 si un JDC doit etre sauvegarde avant destruction ou non
615 #---------------------------------------#
616 def chercheNoeudSelectionne(self,copie=1):
617 #---------------------------------------#
619 appele par Cut et Copy pour positionner self.node_selected
621 self.node_selected=[]
622 if len(self.tree.selectedItems()) == 0 : return
623 self.node_selected=self.tree.selectedItems()
626 #---------------------#
627 def handleSupprimer(self):
628 #---------------------#
629 self.chercheNoeudSelectionne()
630 if len(self.node_selected) == 0 : return
631 self.QWParent.noeud_a_editer = []
632 if self.node_selected[0]==self.tree.racine: return
633 if len(self.node_selected) == 1 : self.node_selected[0].delete()
634 else : self.node_selected[0].deleteMultiple(self.node_selected)
636 #---------------------#
637 def handleRechercher(self):
638 #---------------------#
639 from .monRecherche import DRecherche
640 monRechercheDialg=DRecherche(parent=self,fl=0)
641 monRechercheDialg.show()
644 #--------------------------------#
645 def handleRechercherDsCatalogue(self):
646 #-----------------------------#
647 from .monRechercheCatalogue import DRechercheCatalogue
648 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
649 monRechercheDialg.show()
651 #---------------------#
652 def handleDeplier(self):
653 #---------------------#
654 if self.tree == None : return
655 #self.tree.collapseAll()
658 self.tree.expandItem(self.tree.topLevelItem(0))
660 if self.fenetreCentraleAffichee != None :
661 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
662 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
665 self.tree.expandItem(self.tree.topLevelItem(0))
667 if self.fenetreCentraleAffichee != None :
668 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
669 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
671 #---------------------#
672 def handleEditCut(self):
673 #---------------------#
675 Stocke dans Eficas.noeud_a_editer le noeud a couper
677 #print "handleEditCut"
678 self.chercheNoeudSelectionne()
679 self.QWParent.edit="couper"
680 self.QWParent.noeud_a_editer = self.node_selected
682 #-----------------------#
683 def handleEditCopy(self):
684 #-----------------------#
686 Stocke dans Eficas.noeud_a_editer le noeud a copier
688 self.chercheNoeudSelectionne()
689 if len(self.node_selected) == 0 : return
690 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
691 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
692 self.QWParent.edit="copier"
693 self.QWParent.noeud_a_editer = self.node_selected
695 #------------------------#
696 def handleEditPaste(self):
697 #------------------------#
699 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
700 Ne permet que la copie d'objets de type Commande ou MCF
702 self.chercheNoeudSelectionne()
703 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
704 QMessageBox.information( self,
705 tr("Copie impossible"),
706 tr("Veuillez selectionner un objet a copier"))
708 if len(self.node_selected) != 1 :
709 QMessageBox.information( self,
710 tr("Copie impossible"),
711 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
714 if len(self.QWParent.noeud_a_editer)!=1:
715 self.handleEditPasteMultiple()
718 noeudOuColler=self.node_selected[0]
720 if noeudOuColler == self.tree.racine:
724 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
725 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
728 noeudACopier=self.QWParent.noeud_a_editer[0]
729 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
730 indexNoeudACopier=self.getTreeIndex(noeudACopier)
732 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
735 if (self.QWParent.edit != "couper"):
737 if noeudOuColler == self.tree.racine :
738 child=noeudOuColler.doPastePremier(noeudACopier)
740 child=noeudACopier.doPaste(noeudOuColler,pos)
741 if child==None or child==0:
742 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
744 self.affiche_infos("Copie refusee",Qt.red)
745 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
747 nom=noeudACopier.item.sd.nom
748 child.item.nomme_sd(nom)
755 traceback.print_exc()
756 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
758 self.affiche_infos("Copie refusee",Qt.red)
761 # il faut declarer le JDCDisplay_courant modifie
762 # suppression eventuelle du noeud selectionne
763 # si possible on renomme l objet comme le noeud couper
765 if (self.QWParent.edit == "couper"):
766 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
767 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
771 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
772 indexNoeudACopier=self.getTreeIndex(noeudACopier)
773 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
774 noeudACopier.treeParent.build_children()
779 self.QWParent.noeud_a_editer=[]
781 # on rend la copie a nouveau possible en liberant le flag edit
782 self.QWParent.edit="copier"
783 noeudACopier.select()
785 #----------------------------------#
786 def handleDeplaceMultiple(self):
787 #----------------------------------#
790 #----------------------------------#
791 def handleEditPasteMultiple(self):
792 #----------------------------------#
794 # On ne garde que les niveaux "Etape"
795 # On insere dans l'ordre du JDC
796 listeNoeudsACouper=[]
800 from InterfaceQT4 import compojdc
801 noeudOuColler=self.node_selected[0]
802 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
803 QMessageBox.information( self,
804 tr("Copie impossible a cet endroit",),
805 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
807 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
809 for noeud in self.QWParent.noeud_a_editer :
810 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
811 indexInTree=noeud.treeParent.children.index(noeud)
813 for index in listeIndex:
814 if index < indexInTree : indice = indice +1
815 listeIndex.insert(indice, indexInTree)
816 listeNoeudsACouper.insert(indice, noeud)
818 noeudJdc=noeudOuColler.treeParent
820 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
822 for index in listeIndex:
824 if indexNoeudOuColler < index:
825 indexTravail=indexTravail+dejaCrees
826 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
827 noeud=noeudJdc.children[indexTravail]
828 child=noeud.doPaste(noeudOuColler)
829 listeChild.append(child)
830 dejaCrees=dejaCrees+1
832 self.QWParent.noeud_a_editer = []
833 for i in range(len(listeIndex)):
834 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
835 self.QWParent.noeud_a_editer.append(noeud)
838 if self.QWParent.edit !="couper" : return
840 for index in listeIndex:
842 if indexNoeudOuColler < index:
843 indexTravail=indexTravail+(len(listeIndex))
844 noeud=noeudJdc.children[indexTravail]
846 listeItem.append(noeud.item)
847 listeASupprimer.append(noeud)
849 for i in range(len(listeChild)):
850 self.tree.item.suppitem(listeItem[i])
851 listeChild[i].item.update(listeItem[i])
853 self.QWParent.noeud_a_editer = []
856 #---------------------#
857 def getFileName(self):
858 #---------------------#
861 #---------------------------#
862 def get_file_variable(self) :
863 #---------------------------#
864 titre = tr("Choix d'un fichier XML")
865 texte = tr("Le fichier contient une commande MODEL\n")
866 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
867 QMessageBox.information( self, titre,tr(texte))
869 fichier = QFileDialog.getOpenFileName(self.appliEficas,
870 tr('Ouvrir Fichier'),
871 self.appliEficas.CONFIGURATION.savedir,
872 tr('Wrapper Files (*.xml);;''All Files (*)'))
875 #--------------------------------------------------#
876 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
877 #--------------------------------------------------#
879 Public slot to write the text to a file.
881 @param fn filename to write to string
882 @return flag indicating success
885 fn = six.text_type(fn)
888 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
890 if len(txt) >= len(eol):
891 if txt[-len(eol):] != eol:
895 txt=self.ajoutVersionCataDsJDC(txt)
896 checksum=self.get_checksum(txt)
898 if self.code=="TELEMAC" : return 1
904 except IOError as why:
905 if (self.appliEficas.ssIhm == False):
906 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
907 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
912 #-----------------------------------------------------------#
913 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
914 #-----------------------------------------------------------#
915 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
916 if format in generator.plugins:
918 # Le generateur existe on l'utilise
919 self.generator=generator.plugins[format]()
921 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
922 if pourRun : jdc_formate=self.generator.textePourRun
923 except ValueError as e:
924 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
927 if not self.generator.cr.estvide():
928 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
929 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
934 # Il n'existe pas c'est une erreur
935 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
936 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
939 #----------------------#
941 #---------------------#
942 if 'dicoImbrique' in generator.plugins:
943 self.generator=generator.plugins['dicoImbrique']()
944 jdc_formate=self.generator.gener(self.jdc)
945 dico=self.generator.Dico
948 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
949 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
956 fonction="run"+self.code
958 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
963 fonction="saveRun"+self.code
964 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
970 if not(self.jdc.isvalid()):
971 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
973 if len(self.jdc.etapes) != 1 :
974 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
976 if self.modified or self.fichier==None :
977 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
978 texte=self.get_text_JDC("MAP")
979 self.writeFile( self.fichierMapInput, txt = texte)
981 self.fichierMapInput=self.fichier
982 composant=self.jdc.etapes[0].nom.lower()[0:-5]
985 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
986 # then instantiate corresponding class and call getUseSalome() method
988 from mapengine.spec import factory
989 mapComponent = factory.new(composant)[0]
992 if mapComponent.getUseSalome():
993 command += " -r sappli"
994 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
997 self._viewTextExecute( textePython,"map_run",".sh")
999 # commande="rm "+self.fichierMapInput
1000 # os.system(commande)
1003 except Exception as e:
1004 print((traceback.print_exc()))
1006 #-------------------#
1007 def runZCRACKS(self):
1008 #-------------------#
1009 if not(self.jdc.isvalid()):
1010 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1012 if self.modified or self.fichier==None :
1014 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1015 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1016 self.writeFile( self.fichierZcracksInput, txt = texte)
1018 self.fichierZcracksInput=self.fichier
1020 #commande ="Zrun -zp "
1022 textePython=(commande + self.fichierZcracksInput)
1023 self._viewTextExecute( textePython,"run_zcracks",".sh")
1024 except Exception as e:
1025 print((traceback.print_exc()))
1027 #-------------------#
1028 def runCARMELCND(self):
1029 #-------------------#
1030 #if not(self.jdc.isvalid()):
1031 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1033 if self.modified or self.fichier==None :
1034 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1036 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1037 from PrepareRunCarmel import prepareRunCarmel
1038 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1039 repMed=os.path.dirname(self.fichier)
1040 repExeCarmel=self.generator.get_repExeCarmel()
1041 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1042 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1043 f=open(nomFichier,'w')
1044 f.write(textePython)
1046 commande="xterm -e sh "+nomFichier +"\n"
1049 #-------------------#
1050 def runCarmelCS(self):
1051 #-------------------#
1053 commande="runSession pilotyacsCS.py"
1055 except Exception as e:
1056 print((traceback.print_exc()))
1058 #-----------------------------------------------------#
1059 def determineNomFichier(self,path,extension):
1060 #-----------------------------------------------------#
1061 if self.appli.code in DictExtensions:
1062 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1063 extensions= tr(chaine1+ "All Files (*)")
1065 extensions= tr("JDC (*.comm);;" "All Files (*)")
1067 if self.appli.code == "MAP" :
1068 extensions = extensions + ";; Run (*.input);;"
1070 fn = QFileDialog.getSaveFileName( self,
1071 tr("sauvegarde"), path,
1073 QFileDialog.DontConfirmOverwrite)
1074 if fn == None : return (0, None)
1076 if fn=='': return (0, None)
1078 ext = QFileInfo(fn).suffix()
1079 if ext == '': fn+=extension
1081 if QFileInfo(fn).exists():
1082 msgBox = QMessageBox(self)
1083 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1084 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1085 msgBox.addButton(tr("&Ecraser"),0)
1086 msgBox.addButton(tr("&Abandonner"),1)
1087 abort=msgBox.exec_()
1088 if abort == 1 : return (0, "")
1092 def saveRunMAP(self):
1095 if not(self.jdc.isvalid()):
1096 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1097 tr("Un JdC valide est necessaire pour creer un .input")
1101 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1103 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1104 tr("Choix du composant obligatoire")
1107 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1111 if self.fichier is not None and self.fichier != "" :
1112 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1113 monPath=str(QFileInfo(self.fichier).absolutePath())
1114 monNomFichier=os.path.join(monPath,maBase)
1115 elif hasattr(self,'monNomFichierInput'):
1116 monNomFichier=self.monNomFichierInput
1119 monDialog=QFileDialog(self.appliEficas)
1120 monDialog.setDirectory (path)
1121 monDialog.setWindowTitle ("Save")
1123 for c in monDialog.children():
1124 if isinstance(c,QDialogButtonBox):
1125 for b in c.children():
1126 if isinstance(b,QPushButton):
1128 if avant=="&Open": b.setText("Save")
1129 mesFiltres= "input Map (*.input);;All Files (*)"
1130 monDialog.setNameFilters(mesFiltres)
1131 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1132 BOk=monDialog.exec_()
1134 fn=str(monDialog.selectedFiles()[0])
1135 if fn == "" or fn == None : return
1136 if not fn.endswith(".input"):
1138 self.monNomFichierInput=fn
1140 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1141 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1142 texte=self.get_text_JDC("MAP")
1143 self.writeFile( self.fichierMapInput, txt = texte)
1145 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1146 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1147 (output, err) = p.communicate()
1151 def saveRunPSEN(self):
1153 #print ("saveRunPSEN")
1157 #-----------------------------------------#
1158 def cherche_Groupes(self):
1159 #-----------------------------------------#
1160 listeMA,listeNO=self.get_text_JDC("GroupMA")
1161 return listeMA,listeNO
1163 #-----------------------------------------#
1164 def cherche_Dico(self):
1165 #-----------------------------------------#
1167 format = self.appliEficas.format_fichier
1168 if format in generator.plugins:
1169 # Le generateur existe on l'utilise
1170 self.generator=generator.plugins[format]()
1171 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1172 dicoCourant=self.generator.dico
1177 #-----------------------------------------#
1178 def handleAjoutGroup(self,listeGroup):
1179 #-----------------------------------------#
1182 from ajoutGroupe import handleAjoutGroupFiltre
1184 handleAjoutGroupFiltre(self,listeGroup)
1185 #print "apres handleAjoutGroupFiltre"
1190 #-----------------------------------------------------------------#
1191 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1192 #-----------------------------------------------------------------#
1195 #saveas=True # Pour forcer le nom
1196 self.generator=generator.plugins[self.format]()
1197 if self.fichier is None or saveas:
1198 if path is None: path=self.CONFIGURATION.savedir
1199 bOK, fn=self.determineNomFichier(path,extension)
1200 if bOK == 0 : return (0, None)
1201 if fn == None : return (0, None)
1202 if fn== '' : return (0, None)
1204 ulfile = os.path.abspath(six.text_type(fn))
1205 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1206 fn = six.text_type(QDir.toNativeSeparators(fn))
1208 self.fichier = os.path.splitext(fn)[0]+extension
1210 if hasattr(self.generator, "writeLeger"):
1211 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1213 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1216 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1217 self.appliEficas.setWindowTitle(nouveauTitre)
1218 return (1, self.fichier)
1220 #-----------------------------------------------------------------#
1221 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1222 #-----------------------------------------------------------------#
1224 Public slot to save the text to a file.
1226 @param path directory to save the file in (string or QString)
1227 @return tuple of two values (boolean, string) giving a success indicator and
1228 the name of the saved file
1231 print (self.generDico())
1233 if not self.modified and not saveas:
1234 return (0, None) # do nothing if text wasn't changed
1236 if self.appli.code in DictExtensions :
1237 extension=DictExtensions[self.appli.code]
1243 if self.fichier is None or saveas:
1244 if path is None: path=self.CONFIGURATION.savedir
1245 bOK, fn=self.determineNomFichier(path,extension)
1246 if bOK == 0 : return (0, None)
1247 if fn == None : return (0, None)
1248 if fn== '' : return (0, None)
1250 ulfile = os.path.abspath(six.text_type(fn))
1251 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1252 fn = six.text_type(QDir.toNativeSeparators(fn))
1256 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1258 self.modified = False
1259 if self.fileInfo is None or saveas:
1260 self.fileInfo = QFileInfo(self.fichier)
1261 self.fileInfo.setCaching(0)
1262 self.lastModified = self.fileInfo.lastModified()
1263 if newName is not None:
1264 self.appliEficas.addToRecentList(newName)
1265 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1266 self.tree.racine.update_node_label()
1268 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1269 self.generator.writeDefault(fn)
1270 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1271 self.generator.writeDefault(fn)
1274 self.appliEficas.addJdcInSalome( self.fichier)
1276 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1277 self.appliEficas.setWindowTitle(nouveauTitre)
1279 return (1, self.fichier)
1282 #----------------------------------------------#
1283 def sauveLigneFile(self):
1284 #----------------------------------------------#
1286 return self.saveFile(formatLigne="Ligne")
1289 #----------------------------------------------#
1290 def saveFileAs(self, path = None,fileName=None):
1291 #----------------------------------------------#
1293 Public slot to save a file with a new name.
1295 @param path directory to save the file in (string or QString)
1296 @return tuple of two values (boolean, string) giving a success indicator and
1297 the name of the saved file
1299 if fileName != None :
1300 self.fichier = fileName
1301 return self.saveFile()
1302 return self.saveFile(path,1,"beautifie")
1306 #---------------------------------------------#
1307 def get_file(self,unite=None,fic_origine = ''):
1308 #---------------------------------------------#
1316 titre = tr("Choix unite %d ", unite)
1317 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1318 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1319 labeltexte = tr('Fichier pour unite ') + repr( unite)
1321 titre = tr("Choix d'un fichier de poursuite")
1322 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1323 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1325 QMessageBox.information( self, titre,texte)
1326 fn = QFileDialog.getOpenFileName(self.appliEficas,
1328 self.appliEficas.CONFIGURATION.savedir)
1330 # ce retour est impose par le get_file d'I_JDC
1331 if fn== '' : return None," "
1332 if not fn : return (0, " ")
1335 ulfile = os.path.abspath(six.text_type(fn))
1336 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1338 # On utilise le convertisseur defini par format_fichier
1339 source=self.get_source(ulfile)
1341 # On a reussia convertir le fichier self.ulfile
1344 # Une erreur a ete rencontree
1346 return ulfile, jdcText
1348 #-------------------------------#
1349 def updateJdc(self, itemApres,texte):
1350 #--------------------------------#
1352 etape=monItem.item.object
1354 CONTEXT.set_current_step(etape)
1355 etape.build_includeInclude(texte)
1356 self.tree.racine.build_children()
1358 #-------------------------------------#
1359 def deleteEtape(self,etape):
1360 #-------------------------------------#
1361 self.jdc.suppentite(etape)
1363 #-------------------------------------#
1364 def deleteMC(self,etape,MCFils,listeAvant=()):
1365 #-------------------------------------#
1367 for mot in listeAvant :
1368 ouChercher=ouChercher.get_child(mot,restreint="oui")
1369 monMC=ouChercher.get_child(MCFils,restreint="oui")
1370 if monMC != None : ouChercher.suppentite(monMC)
1371 ouChercher.state='changed'
1372 ouChercher.isvalid()
1374 #-------------------------------------#
1375 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1376 #-------------------------------------#
1378 for mot in listeAvant :
1379 ouChercher=ouChercher.get_child(mot,restreint="oui")
1380 monMC=etape.get_child(ouChercher,restreint="oui")
1381 if monMC== None : monMC= ouChercher.addentite(MCFils)
1382 monMC.valeur=valeurs
1384 monMC.state='changed'
1387 #-----------------------------------------------------------#
1388 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1389 #-----------------------------------------------------------#
1391 for mot in listeAvant :
1392 ouChercher=ouChercher.get_child(mot,restreint="oui")
1393 if ouChercher ==None : print ('SOUCI'); return
1394 monMC=ouChercher.get_child(MCFils,restreint="oui")
1395 if monMC== None : monMC= ouChercher.addentite(MCFils)
1396 monMC.definition.into=valeurs
1397 monMC.state='changed'
1400 #-------------------------------------#
1401 def changeIntoDefMC(self,etape,listeMC,valeurs):
1402 #-------------------------------------#
1403 definitionEtape=getattr(self.jdc.cata[0],etape)
1404 ouChercher=definitionEtape
1405 if len(listeMC) > 1 :
1406 for mc in listeMC[0:-1]:
1407 mcfact=ouChercher.entites[mc]
1410 mcAccas=ouChercher.entites[listeMC[-1]]
1411 mcAccas.into=valeurs
1413 #-------------------------------------------------------------#
1414 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1415 #-------------------------------------------------------------#
1416 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1417 definitionEtape=getattr(self.jdc.cata[0],etape)
1418 ouChercher=definitionEtape
1419 for k in listeAvant :
1420 ouChercher=ouChercher.entites[k]
1421 MCADetruire=ouChercher.entites[nomDuMC]
1422 ouChercher.ordre_mc.remove(nomDuMC)
1423 del ouChercher.entites[nomDuMC]
1424 del self.dicoNouveauxMC[nomDuMC]
1427 #-------------------------------------------------------------#
1428 def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1429 #-------------------------------------------------------------#
1430 definitionEtape=getattr(self.jdc.cata[0],etape)
1431 ouChercher=definitionEtape
1432 for k in listeAvant :
1433 ouChercher=ouChercher.entites[k]
1434 from Accas import A_SIMP
1435 Nouveau=A_SIMP.SIMP(typ,**args)
1436 Nouveau.pere=ouChercher
1439 ouChercher.entites[nomDuMC]=Nouveau
1440 ouChercher.ordre_mc.append(nomDuMC)
1441 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1442 #print self.dicoNouveauxMC
1444 #----------------------------------------------------#
1445 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1446 #----------------------------------------------------#
1447 monMC=etape.get_child(MCFils,restreint="oui")
1448 if monMC== None : monMC= etape.addentite(MCFils)
1449 monMC.definition.into=into
1450 monMC.valeur=valeurs
1452 monMC.state='changed'
1455 #-------------------------------------#
1456 def ajoutVersionCataDsJDC(self,txt):
1457 #-------------------------------------#
1458 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1459 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1460 texte=txt+ligneVersion
1463 #-------------------------------------#
1464 def verifieVersionCataDuJDC(self,text):
1465 #-------------------------------------#
1467 indexDeb=text.find("#VERSION_CATALOGUE:")
1468 indexFin=text.find(":FIN VERSION_CATALOGUE")
1470 self.versionCataDuJDC="sans"
1473 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1474 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1476 self.versionCata="sans"
1477 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1479 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1480 return memeVersion,textJDC
1482 #-------------------------------#
1483 def traduitCatalogue(self,texte):
1484 #-------------------------------#
1485 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1486 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1488 traducteur=__import__(nomTraducteur)
1489 monTraducteur=traducteur.MonTraducteur(texte)
1490 nouveauTexte=monTraducteur.traduit()
1496 #------------------------------#
1497 def verifieCHECKSUM(self,text):
1498 #------------------------------#
1499 indexDeb=text.find("#CHECKSUM:")
1502 indexFin=text.find(":FIN CHECKSUM")
1503 checkAvant=text[indexDeb:indexFin+13]
1504 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1505 checksum=self.get_checksum(textJDC)
1506 pareil=(checkAvant==checksum)
1507 return pareil, textJDC
1509 #---------------------------#
1510 def get_checksum(self,texte):
1511 #---------------------------#
1512 newtexte=texte.replace('"','\\"')
1513 commande='echo "'+newtexte+'"|md5sum'
1514 a=os.popen(commande)
1517 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1521 #---------------------------#
1523 #---------------------------#
1524 texte="CONDUITE_FORCEE();"
1528 #---------------------------#
1529 def _newTELEMAC(self):
1530 #---------------------------#
1531 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1532 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1536 #---------------------------#
1538 #---------------------------#
1539 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1543 #---------------------------#
1544 def _newPSEN_N1(self):
1545 #---------------------------#
1546 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1547 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1550 #---------------------------#
1552 #---------------------------#
1553 def _newZCRACKS(self):
1554 #---------------------------#
1555 texte="MAILLAGES();REMESHING();"
1558 #---------------------------#
1559 def _newJDCCND(self):
1560 #---------------------------#
1561 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1563 #if self.salome == 0 :
1564 QMessageBox.information( self,
1566 tr("Veuillez selectionner un fichier Med"))
1567 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1568 caption='Fichier Med',
1570 QSfichier=QSfichier[0]
1571 self.fichierMED=QSfichier
1572 from acquiertGroupes import getGroupes
1573 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1574 if erreur != "" : print ("a traiter")
1575 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1581 for groupe in self.listeGroupes :
1582 if groupe[0:8]=='CURRENT_':
1583 texteSources +=groupe[8:]+"=SOURCE("
1584 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1585 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1586 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1587 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1588 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1589 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1590 self.newTexteCND=texte
1595 #---------------------------#
1596 def BoutonFileSelected(self):
1597 #---------------------------#
1599 QSfichier=self.openfile.selectedFiles()[0]
1600 self.fichierMED=str(QSfichier)
1601 from acquiertGroupes import getGroupes
1602 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1603 if erreur != "" : print ("a traiter")
1605 #-----------------------------
1606 def BoutonSalomePressed(self):
1607 #----------------------------
1608 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1609 self.fichierMED="A_partir_de_SMESH"
1610 self.nomMaillage="A_partir_de_SMESH"
1611 self.openfile.close()
1614 #-----------------------------------------
1615 def initSplitterSizes(self, nbWidget=3):
1616 #-----------------------------------------
1617 #print ("je passe ds initSplitterSizes", nbWidget)
1619 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1620 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1621 else : self.splitterSizes3=[150,1000,300]
1623 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1624 else : self.splitterSizes2=[300,1000]
1628 #-----------------------------------------
1629 def restoreSplitterSizes(self,nbWidget=3):
1630 #----------------------------------------
1632 #traceback.print_stack()
1633 #print ("je passe ds restoreSplitterSizes")
1634 if not(hasattr(self,'splitter')) : return
1635 if nbWidget==2 : newSizes=self.splitterSizes2
1636 if nbWidget==3 : newSizes=self.splitterSizes3
1637 #self.inhibeSplitter = 1
1638 self.splitter.setSizes(newSizes)
1639 #self.inhibeSplitter = 0
1640 QApplication.processEvents()
1641 # seule la fentetre du milieu est necessaire
1642 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1644 #-----------------------------------------
1645 def saveSplitterSizes(self,event):
1646 #-----------------------------------------
1647 #print ("je passe ds saveSplitterSizes")
1648 if self.inhibeSplitter : return
1649 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1650 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1652 #------------------------
1653 def fermeOptionnel(self):
1654 #------------------------
1655 if self.widgetOptionnel == None : return
1657 self.inhibeSplitter=1
1658 self.widgetOptionnel.setParent(None)
1659 self.widgetOptionnel.close()
1660 self.widgetOptionnel.deleteLater()
1661 self.widgetOptionnel=None
1662 self.inhibeSplitter=0
1663 self.restoreSplitterSizes(2)
1665 #------------------------
1666 def ajoutOptionnel(self):
1667 #------------------------
1668 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1669 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1670 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1672 self.restoreSplitterSizes(3)
1675 #------------------------
1676 def fermeArbre(self):
1677 #------------------------
1678 #print (self.widgetTree)
1679 self.oldWidgetTree=self.widgetTree
1680 self.widgetTree.hide()
1681 #self.widgetTree=None
1683 #------------------------
1684 def ouvreArbre(self):
1685 #------------------------
1686 #print ('je passe la')
1687 #print (self.widgetTree)
1688 #self.widgetTree=self.oldWidgetTree
1689 self.widgetTree.show()
1690 #self.restoreSplitterSizes(3)
1692 #-----------------------------
1693 def getTreeIndex(self,noeud):
1694 #----------------------------
1696 if noeud in noeud.treeParent.children :
1697 indexNoeud=noeud.treeParent.children.index(noeud)
1699 if hasattr(noeud,'vraiParent') :
1701 noeudVraiParent = noeud.vraiParent
1702 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1703 noeudVrai = noeudVraiParent
1704 noeudVraiParent = noeudVraiParent.vraiParent
1706 if noeudVraiParent == noeud.treeParent :
1707 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1713 if __name__ == "__main__":
1715 name='prefs_'+prefs.code
1716 prefsCode=__import__(name)
1719 if hasattr(prefsCode,'encoding'):
1720 # Hack pour changer le codage par defaut des strings
1723 sys.setdefaultencoding(prefs.encoding)
1724 del sys.setdefaultencoding
1729 app = QApplication(sys.argv)
1730 mw = JDCEditor(None,'azAster.comm')
1731 app.setMainWidget(mw)
1732 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1735 res = app.exec_loop()