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()
324 #--------------------------------#
325 def _newJDC( self ,units = None):
326 #--------------------------------#
328 Initialise un nouveau JDC vierge
331 CONTEXT.unset_current_step()
334 if self.code == "CARMELCND" : texte=self._newJDCCND()
335 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
336 if self.code == "TELEMAC" : texte=self._newTELEMAC()
337 if self.code == "PSEN" : texte = self._newPSEN()
338 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
340 if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
342 #if self.code == "CF" : texte = self._new_CF()
343 # texte=self.newTexteCND
345 jdc=self.readercata.cata[0].JdC( procedure =texte,
347 cata=self.readercata.cata,
348 cata_ord_dico=self.readercata.cata_ordonne_dico,
349 rep_mat=self.CONFIGURATION.rep_mat
351 jdc.lang = self.appli.langue
352 if units is not None:
353 jdc.recorded_units=units
354 jdc.old_recorded_units=units
355 ## PNPN est ce que la ligne suivante est bien utile ?
356 if texte == "" :jdc.analyse()
359 #--------------------------------#
360 def _newJDCInclude( self ,units = None):
361 #--------------------------------#
363 Initialise un nouveau JDC vierge
365 import Extensions.jdc_include
366 JdC_aux=Extensions.jdc_include.JdC_include
367 CONTEXT.unset_current_step()
369 jaux=self.readercata.cata[0].JdC( procedure="",
371 cata=self.readercata.cata,
372 cata_ord_dico=self.readercata.cata_ordonne_dico,
373 rep_mat=self.CONFIGURATION.rep_mat,
377 J=JdC_aux( procedure="",
379 cata=self.readercata.cata,
380 cata_ord_dico=self.readercata.cata_ordonne_dico,
382 rep_mat=self.CONFIGURATION.rep_mat,
385 if units is not None:
386 J.recorded_units=units
387 J.old_recorded_units=units
391 #-------------------------------#
392 def readFile(self, fn):
393 #--------------------------------#
395 Public slot to read the text from a file.
396 @param fn filename to read from (string or QString)
398 fn = six.text_type(fn)
400 # ------------------------------------------------------------------------------------
402 # ------------------------------------------------------------------------------------
404 jdcName=os.path.basename(fn)
405 # Il faut convertir le contenu du fichier en fonction du format
406 if self.appliEficas.format_fichier_in in convert.plugins:
407 # Le convertisseur existe on l'utilise
409 p=convert.plugins[self.appliEficas.format_fichier_in]()
411 if p.text=="" : self.nouveau=1
412 pareil,texteNew=self.verifieCHECKSUM(p.text)
414 if pareil == False and (self.appliEficas.ssIhm == False) :
415 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
417 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
418 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
420 text=p.convert('exec',self.appliEficas)
421 if not p.cr.estvide():
422 self.affiche_infos("Erreur a la conversion",Qt.red)
424 self.affiche_infos("Type de fichier non reconnu",Qt.red)
425 if self.appliEficas.ssIhm == False:
426 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
427 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
430 CONTEXT.unset_current_step()
431 jdc=self.readercata.cata[0].JdC(procedure=text,
433 cata=self.readercata.cata,
434 cata_ord_dico=self.readercata.cata_ordonne_dico,
436 rep_mat=self.CONFIGURATION.rep_mat
438 # ----------------------------------------------------
440 # ----------------------------------------------------
441 self.modified = False
443 # qApp.restoreOverrideCursor()
444 if self.fileInfo!= None :
445 self.lastModified = self.fileInfo.lastModified()
447 self.lastModified = 1
448 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
449 self.appliEficas.setWindowTitle(nouveauTitre)
453 #-----------------------#
454 def get_source(self,file):
455 #-----------------------#
457 # Il faut convertir le contenu du fichier en fonction du format
458 if self.format in convert.plugins :
459 # Le convertisseur existe on l'utilise
460 p=convert.plugins[self.format]()
462 text=p.convert('execnoparseur')
463 if not p.cr.estvide():
464 self.affiche_infos("Erreur a la conversion",Qt.red)
467 # Il n'existe pas c'est une erreur
468 self.affiche_infos("Type de fichier non reconnu",Qt.red)
469 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
472 #-----------------------------------------------------------------------#
473 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
474 #--------------------------------------------------------------------#
475 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
479 #----------------------------------------------#
480 def __generateTempFilename(self, prefix, suffix):
481 #----------------------------------------------#
483 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
489 #----------------------------------------------#
490 def _viewTextExecute(self, txt, prefix, suffix):
491 #----------------------------------------------#
492 self.w = ViewText( self.QWParent )
493 self.w.setWindowTitle( "execution" )
494 self.monExe=QProcess(self.w)
495 pid=self.monExe.pid()
496 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
497 f=open(nomFichier,'w')
500 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
501 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
502 exe='sh ' + nomFichier
503 self.monExe.start(exe)
504 self.monExe.closeWriteChannel()
507 commande="rm "+ nomFichier
512 def readFromStdErr(self):
513 a=self.monExe.readAllStandardError()
514 self.w.view.append(str(a.data()))
516 def readFromStdOut(self) :
517 a=self.monExe.readAllStandardOutput()
518 self.w.view.append(str(a.data()))
520 def readFromStdErrQT4(self):
521 a=self.monExe.readAllStandardError()
522 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
524 def readFromStdOutQT4(self) :
525 a=self.monExe.readAllStandardOutput()
526 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
528 #-----------------------#
530 #-----------------------#
531 if 'dico' in generator.plugins:
532 self.generator=generator.plugins['dico']()
533 jdc_formate=self.generator.gener(self.jdc)
534 dico=self.generator.Dico
537 #-----------------------#
538 def gestionParam(self):
539 #-----------------------#
540 w = MonWidgetCreeParam( self)
543 #-----------------------#
544 def viewJdcSource(self):
545 #-----------------------#
546 if self.fichier == None : return
547 f=open(self.fichier,'r')
550 self._viewText(texteSource, "JDC_SOURCE")
552 #-----------------------#
554 #-----------------------#
555 strSource = str( self.get_text_JDC(self.format) )
556 self._viewText(strSource, "JDC_RESULTAT")
558 #-----------------------#
559 def viewJdcRapport(self):
560 #-----------------------#
561 strRapport = six.text_type( self.jdc.report() )
562 # on ajoute les regles
564 self._viewText(strRapport, "JDC_RAPPORT")
566 #-----------------------#
567 def viewJdcRegles(self):
568 #-----------------------#
569 if self.tree :self.tree.AppelleBuildLBRegles()
576 Public method called by the viewmanager to finally get rid of us.
582 #----------------------------------------------#
583 def affiche_infos(self,message,couleur=Qt.black):
584 #----------------------------------------------#
586 mapalette=self.sb.palette()
587 mapalette.setColor( QPalette.WindowText, couleur )
588 self.sb.setPalette( mapalette );
589 self.sb.showMessage(message,4000)
592 #------------------------------#
593 def affiche_alerte(self,titre,message):
594 #------------------------------#
595 # appele par I_MACRO_ETAPE
596 QMessageBox.information( self, titre, message)
598 #-----------------------------------#
599 def affiche_commentaire(self,message):
600 #-----------------------------------#
601 self.labelCommentaire.setText(message)
602 QTimer.singleShot(6000, self.rendInvisible)
604 #----------------------#
605 def rendInvisible(self):
606 #----------------------#
607 self.labelCommentaire.setText("")
609 #-------------------#
610 def init_modif(self):
611 #-------------------#
613 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
614 si un JDC doit etre sauvegarde avant destruction ou non
618 #---------------------------------------#
619 def chercheNoeudSelectionne(self,copie=1):
620 #---------------------------------------#
622 appele par Cut et Copy pour positionner self.node_selected
624 self.node_selected=[]
625 if len(self.tree.selectedItems()) == 0 : return
626 self.node_selected=self.tree.selectedItems()
629 #---------------------#
630 def handleSupprimer(self):
631 #---------------------#
632 self.chercheNoeudSelectionne()
633 if len(self.node_selected) == 0 : return
634 self.QWParent.noeud_a_editer = []
635 if self.node_selected[0]==self.tree.racine: return
636 if len(self.node_selected) == 1 : self.node_selected[0].delete()
637 else : self.node_selected[0].deleteMultiple(self.node_selected)
639 #---------------------#
640 def handleRechercher(self):
641 #---------------------#
642 from .monRecherche import DRecherche
643 monRechercheDialg=DRecherche(parent=self,fl=0)
644 monRechercheDialg.show()
647 #--------------------------------#
648 def handleRechercherDsCatalogue(self):
649 #-----------------------------#
650 from .monRechercheCatalogue import DRechercheCatalogue
651 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
652 monRechercheDialg.show()
654 #---------------------#
655 def handleDeplier(self):
656 #---------------------#
657 if self.tree == None : return
658 #self.tree.collapseAll()
661 self.tree.expandItem(self.tree.topLevelItem(0))
663 if self.fenetreCentraleAffichee != None :
664 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
665 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
668 self.tree.expandItem(self.tree.topLevelItem(0))
670 if self.fenetreCentraleAffichee != None :
671 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
672 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
674 #---------------------#
675 def handleEditCut(self):
676 #---------------------#
678 Stocke dans Eficas.noeud_a_editer le noeud a couper
680 #print "handleEditCut"
681 self.chercheNoeudSelectionne()
682 self.QWParent.edit="couper"
683 self.QWParent.noeud_a_editer = self.node_selected
685 #-----------------------#
686 def handleEditCopy(self):
687 #-----------------------#
689 Stocke dans Eficas.noeud_a_editer le noeud a copier
691 self.chercheNoeudSelectionne()
692 if len(self.node_selected) == 0 : return
693 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
694 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
695 self.QWParent.edit="copier"
696 self.QWParent.noeud_a_editer = self.node_selected
698 #------------------------#
699 def handleEditPaste(self):
700 #------------------------#
702 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
703 Ne permet que la copie d'objets de type Commande ou MCF
705 self.chercheNoeudSelectionne()
706 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
707 QMessageBox.information( self,
708 tr("Copie impossible"),
709 tr("Veuillez selectionner un objet a copier"))
711 if len(self.node_selected) != 1 :
712 QMessageBox.information( self,
713 tr("Copie impossible"),
714 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
717 if len(self.QWParent.noeud_a_editer)!=1:
718 self.handleEditPasteMultiple()
721 noeudOuColler=self.node_selected[0]
723 if noeudOuColler == self.tree.racine:
727 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
728 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
731 noeudACopier=self.QWParent.noeud_a_editer[0]
732 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
733 indexNoeudACopier=self.getTreeIndex(noeudACopier)
735 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
738 if (self.QWParent.edit != "couper"):
740 if noeudOuColler == self.tree.racine :
741 child=noeudOuColler.doPastePremier(noeudACopier)
743 child=noeudACopier.doPaste(noeudOuColler,pos)
744 if child==None or child==0:
745 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
747 self.affiche_infos("Copie refusee",Qt.red)
748 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
750 nom=noeudACopier.item.sd.nom
751 child.item.nomme_sd(nom)
758 traceback.print_exc()
759 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
761 self.affiche_infos("Copie refusee",Qt.red)
764 # il faut declarer le JDCDisplay_courant modifie
765 # suppression eventuelle du noeud selectionne
766 # si possible on renomme l objet comme le noeud couper
768 if (self.QWParent.edit == "couper"):
769 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
770 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
774 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
775 indexNoeudACopier=self.getTreeIndex(noeudACopier)
776 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
777 noeudACopier.treeParent.build_children()
782 self.QWParent.noeud_a_editer=[]
784 # on rend la copie a nouveau possible en liberant le flag edit
785 self.QWParent.edit="copier"
786 noeudACopier.select()
788 #----------------------------------#
789 def handleDeplaceMultiple(self):
790 #----------------------------------#
793 #----------------------------------#
794 def handleEditPasteMultiple(self):
795 #----------------------------------#
797 # On ne garde que les niveaux "Etape"
798 # On insere dans l'ordre du JDC
799 listeNoeudsACouper=[]
803 from InterfaceQT4 import compojdc
804 noeudOuColler=self.node_selected[0]
805 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
806 QMessageBox.information( self,
807 tr("Copie impossible a cet endroit",),
808 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
810 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
812 for noeud in self.QWParent.noeud_a_editer :
813 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
814 indexInTree=noeud.treeParent.children.index(noeud)
816 for index in listeIndex:
817 if index < indexInTree : indice = indice +1
818 listeIndex.insert(indice, indexInTree)
819 listeNoeudsACouper.insert(indice, noeud)
821 noeudJdc=noeudOuColler.treeParent
823 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
825 for index in listeIndex:
827 if indexNoeudOuColler < index:
828 indexTravail=indexTravail+dejaCrees
829 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
830 noeud=noeudJdc.children[indexTravail]
831 child=noeud.doPaste(noeudOuColler)
832 listeChild.append(child)
833 dejaCrees=dejaCrees+1
835 self.QWParent.noeud_a_editer = []
836 for i in range(len(listeIndex)):
837 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
838 self.QWParent.noeud_a_editer.append(noeud)
841 if self.QWParent.edit !="couper" : return
843 for index in listeIndex:
845 if indexNoeudOuColler < index:
846 indexTravail=indexTravail+(len(listeIndex))
847 noeud=noeudJdc.children[indexTravail]
849 listeItem.append(noeud.item)
850 listeASupprimer.append(noeud)
852 for i in range(len(listeChild)):
853 self.tree.item.suppitem(listeItem[i])
854 listeChild[i].item.update(listeItem[i])
856 self.QWParent.noeud_a_editer = []
859 #---------------------#
860 def getFileName(self):
861 #---------------------#
864 #---------------------------#
865 def get_file_variable(self) :
866 #---------------------------#
867 titre = tr("Choix d'un fichier XML")
868 texte = tr("Le fichier contient une commande MODEL\n")
869 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
870 QMessageBox.information( self, titre,tr(texte))
872 fichier = QFileDialog.getOpenFileName(self.appliEficas,
873 tr('Ouvrir Fichier'),
874 self.appliEficas.CONFIGURATION.savedir,
875 tr('Wrapper Files (*.xml);;''All Files (*)'))
878 #--------------------------------------------------#
879 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
880 #--------------------------------------------------#
882 Public slot to write the text to a file.
884 @param fn filename to write to string
885 @return flag indicating success
888 fn = six.text_type(fn)
891 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
893 if len(txt) >= len(eol):
894 if txt[-len(eol):] != eol:
898 txt=self.ajoutVersionCataDsJDC(txt)
899 checksum=self.get_checksum(txt)
901 if self.code=="TELEMAC" : return 1
907 except IOError as why:
908 if (self.appliEficas.ssIhm == False):
909 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
910 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
915 #-----------------------------------------------------------#
916 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
917 #-----------------------------------------------------------#
918 if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
919 if format in generator.plugins:
921 # Le generateur existe on l'utilise
922 self.generator=generator.plugins[format]()
924 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
925 if pourRun : jdc_formate=self.generator.textePourRun
926 except ValueError as e:
927 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
930 if not self.generator.cr.estvide():
931 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
932 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
937 # Il n'existe pas c'est une erreur
938 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
939 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
942 #----------------------#
944 #---------------------#
945 if 'dicoImbrique' in generator.plugins:
946 self.generator=generator.plugins['dicoImbrique']()
947 jdc_formate=self.generator.gener(self.jdc)
948 dico=self.generator.Dico
951 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
952 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
959 fonction="run"+self.code
961 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
966 fonction="saveRun"+self.code
967 if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction],(self,)
973 if not(self.jdc.isvalid()):
974 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
976 if len(self.jdc.etapes) != 1 :
977 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
979 if self.modified or self.fichier==None :
980 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
981 texte=self.get_text_JDC("MAP")
982 self.writeFile( self.fichierMapInput, txt = texte)
984 self.fichierMapInput=self.fichier
985 composant=self.jdc.etapes[0].nom.lower()[0:-5]
988 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
989 # then instantiate corresponding class and call getUseSalome() method
991 from mapengine.spec import factory
992 mapComponent = factory.new(composant)[0]
995 if mapComponent.getUseSalome():
996 command += " -r sappli"
997 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
1000 self._viewTextExecute( textePython,"map_run",".sh")
1002 # commande="rm "+self.fichierMapInput
1003 # os.system(commande)
1006 except Exception as e:
1007 print((traceback.print_exc()))
1009 #-------------------#
1010 def runZCRACKS(self):
1011 #-------------------#
1012 if not(self.jdc.isvalid()):
1013 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1015 if self.modified or self.fichier==None :
1017 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
1018 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
1019 self.writeFile( self.fichierZcracksInput, txt = texte)
1021 self.fichierZcracksInput=self.fichier
1023 #commande ="Zrun -zp "
1025 textePython=(commande + self.fichierZcracksInput)
1026 self._viewTextExecute( textePython,"run_zcracks",".sh")
1027 except Exception as e:
1028 print((traceback.print_exc()))
1030 #-------------------#
1031 def runCARMELCND(self):
1032 #-------------------#
1033 #if not(self.jdc.isvalid()):
1034 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
1036 if self.modified or self.fichier==None :
1037 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
1039 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
1040 from PrepareRunCarmel import prepareRunCarmel
1041 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
1042 repMed=os.path.dirname(self.fichier)
1043 repExeCarmel=self.generator.get_repExeCarmel()
1044 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
1045 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
1046 f=open(nomFichier,'w')
1047 f.write(textePython)
1049 commande="xterm -e sh "+nomFichier +"\n"
1052 #-------------------#
1053 def runCarmelCS(self):
1054 #-------------------#
1056 commande="runSession pilotyacsCS.py"
1058 except Exception as e:
1059 print((traceback.print_exc()))
1061 #-----------------------------------------------------#
1062 def determineNomFichier(self,path,extension):
1063 #-----------------------------------------------------#
1064 if self.appli.code in DictExtensions:
1065 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1066 extensions= tr(chaine1+ "All Files (*)")
1068 extensions= tr("JDC (*.comm);;" "All Files (*)")
1070 if self.appli.code == "MAP" :
1071 extensions = extensions + ";; Run (*.input);;"
1073 fn = QFileDialog.getSaveFileName( self,
1074 tr("sauvegarde"), path,
1076 QFileDialog.DontConfirmOverwrite)
1077 if fn == None : return (0, None)
1079 if fn=='': return (0, None)
1081 ext = QFileInfo(fn).suffix()
1082 if ext == '': fn+=extension
1084 if QFileInfo(fn).exists():
1085 msgBox = QMessageBox(self)
1086 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1087 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", six.text_type(fn)))
1088 msgBox.addButton(tr("&Ecraser"),0)
1089 msgBox.addButton(tr("&Abandonner"),1)
1090 abort=msgBox.exec_()
1091 if abort == 1 : return (0, "")
1095 def saveRunMAP(self):
1098 if not(self.jdc.isvalid()):
1099 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1100 tr("Un JdC valide est necessaire pour creer un .input")
1104 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1106 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1107 tr("Choix du composant obligatoire")
1110 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1114 if self.fichier is not None and self.fichier != "" :
1115 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1116 monPath=str(QFileInfo(self.fichier).absolutePath())
1117 monNomFichier=os.path.join(monPath,maBase)
1118 elif hasattr(self,'monNomFichierInput'):
1119 monNomFichier=self.monNomFichierInput
1122 monDialog=QFileDialog(self.appliEficas)
1123 monDialog.setDirectory (path)
1124 monDialog.setWindowTitle ("Save")
1126 for c in monDialog.children():
1127 if isinstance(c,QDialogButtonBox):
1128 for b in c.children():
1129 if isinstance(b,QPushButton):
1131 if avant=="&Open": b.setText("Save")
1132 mesFiltres= "input Map (*.input);;All Files (*)"
1133 monDialog.setNameFilters(mesFiltres)
1134 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1135 BOk=monDialog.exec_()
1137 fn=str(monDialog.selectedFiles()[0])
1138 if fn == "" or fn == None : return
1139 if not fn.endswith(".input"):
1141 self.monNomFichierInput=fn
1143 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1144 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1145 texte=self.get_text_JDC("MAP")
1146 self.writeFile( self.fichierMapInput, txt = texte)
1148 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1149 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1150 (output, err) = p.communicate()
1154 def saveRunPSEN(self):
1156 #print ("saveRunPSEN")
1160 #-----------------------------------------#
1161 def cherche_Groupes(self):
1162 #-----------------------------------------#
1163 listeMA,listeNO=self.get_text_JDC("GroupMA")
1164 return listeMA,listeNO
1166 #-----------------------------------------#
1167 def cherche_Dico(self):
1168 #-----------------------------------------#
1170 format = self.appliEficas.format_fichier
1171 if format in generator.plugins:
1172 # Le generateur existe on l'utilise
1173 self.generator=generator.plugins[format]()
1174 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1175 dicoCourant=self.generator.dico
1180 #-----------------------------------------#
1181 def handleAjoutGroup(self,listeGroup):
1182 #-----------------------------------------#
1185 from ajoutGroupe import handleAjoutGroupFiltre
1187 handleAjoutGroupFiltre(self,listeGroup)
1188 #print "apres handleAjoutGroupFiltre"
1193 #-----------------------------------------------------------------#
1194 def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
1195 #-----------------------------------------------------------------#
1198 #saveas=True # Pour forcer le nom
1199 self.generator=generator.plugins[self.format]()
1200 if self.fichier is None or saveas:
1201 if path is None: path=self.CONFIGURATION.savedir
1202 bOK, fn=self.determineNomFichier(path,extension)
1203 if bOK == 0 : return (0, None)
1204 if fn == None : return (0, None)
1205 if fn== '' : return (0, None)
1207 ulfile = os.path.abspath(six.text_type(fn))
1208 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1209 fn = six.text_type(QDir.toNativeSeparators(fn))
1211 self.fichier = os.path.splitext(fn)[0]+extension
1213 if hasattr(self.generator, "writeLeger"):
1214 self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
1216 if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
1219 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1220 self.appliEficas.setWindowTitle(nouveauTitre)
1221 return (1, self.fichier)
1223 #-----------------------------------------------------------------#
1224 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1225 #-----------------------------------------------------------------#
1227 Public slot to save the text to a file.
1229 @param path directory to save the file in (string or QString)
1230 @return tuple of two values (boolean, string) giving a success indicator and
1231 the name of the saved file
1234 print (self.generDico())
1236 if not self.modified and not saveas:
1237 return (0, None) # do nothing if text wasn't changed
1239 if self.appli.code in DictExtensions :
1240 extension=DictExtensions[self.appli.code]
1246 if self.fichier is None or saveas:
1247 if path is None: path=self.CONFIGURATION.savedir
1248 bOK, fn=self.determineNomFichier(path,extension)
1249 if bOK == 0 : return (0, None)
1250 if fn == None : return (0, None)
1251 if fn== '' : return (0, None)
1253 ulfile = os.path.abspath(six.text_type(fn))
1254 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1255 fn = six.text_type(QDir.toNativeSeparators(fn))
1259 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1261 self.modified = False
1262 if self.fileInfo is None or saveas:
1263 self.fileInfo = QFileInfo(self.fichier)
1264 self.fileInfo.setCaching(0)
1265 self.lastModified = self.fileInfo.lastModified()
1266 if newName is not None:
1267 self.appliEficas.addToRecentList(newName)
1268 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1269 self.tree.racine.update_node_label()
1271 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1272 self.generator.writeDefault(fn)
1273 elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1274 self.generator.writeDefault(fn)
1277 self.appliEficas.addJdcInSalome( self.fichier)
1279 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1280 self.appliEficas.setWindowTitle(nouveauTitre)
1282 return (1, self.fichier)
1285 #----------------------------------------------#
1286 def sauveLigneFile(self):
1287 #----------------------------------------------#
1289 return self.saveFile(formatLigne="Ligne")
1292 #----------------------------------------------#
1293 def saveFileAs(self, path = None,fileName=None):
1294 #----------------------------------------------#
1296 Public slot to save a file with a new name.
1298 @param path directory to save the file in (string or QString)
1299 @return tuple of two values (boolean, string) giving a success indicator and
1300 the name of the saved file
1302 if fileName != None :
1303 self.fichier = fileName
1304 return self.saveFile()
1305 return self.saveFile(path,1,"beautifie")
1309 #---------------------------------------------#
1310 def get_file(self,unite=None,fic_origine = ''):
1311 #---------------------------------------------#
1319 titre = tr("Choix unite %d ", unite)
1320 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1321 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1322 labeltexte = tr('Fichier pour unite ') + repr( unite)
1324 titre = tr("Choix d'un fichier de poursuite")
1325 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1326 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1328 QMessageBox.information( self, titre,texte)
1329 fn = QFileDialog.getOpenFileName(self.appliEficas,
1331 self.appliEficas.CONFIGURATION.savedir)
1333 # ce retour est impose par le get_file d'I_JDC
1334 if fn== '' : return None," "
1335 if not fn : return (0, " ")
1338 ulfile = os.path.abspath(six.text_type(fn))
1339 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1341 # On utilise le convertisseur defini par format_fichier
1342 source=self.get_source(ulfile)
1344 # On a reussia convertir le fichier self.ulfile
1347 # Une erreur a ete rencontree
1349 return ulfile, jdcText
1351 #-------------------------------#
1352 def updateJdc(self, itemApres,texte):
1353 #--------------------------------#
1355 etape=monItem.item.object
1357 CONTEXT.set_current_step(etape)
1358 etape.build_includeInclude(texte)
1359 self.tree.racine.build_children()
1361 #-------------------------------------#
1362 def deleteEtape(self,etape):
1363 #-------------------------------------#
1364 self.jdc.suppentite(etape)
1366 #-------------------------------------#
1367 def deleteMC(self,etape,MCFils,listeAvant=()):
1368 #-------------------------------------#
1370 for mot in listeAvant :
1371 ouChercher=ouChercher.get_child(mot,restreint="oui")
1372 monMC=ouChercher.get_child(MCFils,restreint="oui")
1373 if monMC != None : ouChercher.suppentite(monMC)
1374 ouChercher.state='changed'
1375 ouChercher.isvalid()
1377 #-------------------------------------#
1378 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1379 #-------------------------------------#
1381 for mot in listeAvant :
1382 ouChercher=ouChercher.get_child(mot,restreint="oui")
1383 monMC=etape.get_child(ouChercher,restreint="oui")
1384 if monMC== None : monMC= ouChercher.addentite(MCFils)
1385 monMC.valeur=valeurs
1387 monMC.state='changed'
1390 #-----------------------------------------------------------#
1391 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1392 #-----------------------------------------------------------#
1394 for mot in listeAvant :
1395 ouChercher=ouChercher.get_child(mot,restreint="oui")
1396 if ouChercher ==None : print ('SOUCI'); return
1397 monMC=ouChercher.get_child(MCFils,restreint="oui")
1398 if monMC== None : monMC= ouChercher.addentite(MCFils)
1400 monMC.definition.into=valeurs
1401 from Noyau.N_VALIDATOR import IntoProtocol
1402 monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
1403 monMC.state='changed'
1406 #----------------------------------------------------#
1407 def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
1408 #----------------------------------------------------#
1409 for e in self.jdc.etapes:
1410 if e.nom == nomEtape : ouChercher=e; break
1412 for mot in listeAvant :
1414 ouChercher=ouChercher.get_child(mot,restreint="oui")
1415 # Le mot clef n est pas la
1418 monMC=ouChercher.get_child(MCFils,restreint="oui")
1419 # Le mot clef n est pas la
1422 #print ('________',monMC)
1423 if hasattr(monMC.definition,'into') :
1424 if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
1425 else : maListeDeValeur=monMC.definition.into
1429 monMC.state='changed'
1433 #-------------------------------------#
1434 def changeIntoDefMC(self,etape,listeMC,valeurs):
1435 #-------------------------------------#
1436 definitionEtape=getattr(self.jdc.cata[0],etape)
1437 ouChercher=definitionEtape
1438 if len(listeMC) > 1 :
1440 for mc in listeMC[0:-1]:
1441 mcfact=ouChercher.entites[mc]
1444 mcAccas=ouChercher.entites[listeMC[-1]]
1446 if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
1447 else : oldValeurs=None
1448 if oldValeurs==valeurs : return 0
1450 mcAccas.into=valeurs
1451 from Noyau.N_VALIDATOR import IntoProtocol
1452 mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
1455 #-------------------------------------------------------------#
1456 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1457 #-------------------------------------------------------------#
1458 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1459 definitionEtape=getattr(self.jdc.cata[0],etape)
1460 ouChercher=definitionEtape
1461 for k in listeAvant :
1462 ouChercher=ouChercher.entites[k]
1463 MCADetruire=ouChercher.entites[nomDuMC]
1464 ouChercher.ordre_mc.remove(nomDuMC)
1465 del ouChercher.entites[nomDuMC]
1466 del self.dicoNouveauxMC[nomDuMC]
1469 #-------------------------------------------------------------#
1470 def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1471 #-------------------------------------------------------------#
1472 definitionEtape=getattr(self.jdc.cata[0],etape)
1473 ouChercher=definitionEtape
1474 for k in listeAvant :
1475 ouChercher=ouChercher.entites[k]
1476 from Accas import A_SIMP
1477 Nouveau=A_SIMP.SIMP(typ,**args)
1478 Nouveau.pere=ouChercher
1481 ouChercher.entites[nomDuMC]=Nouveau
1482 ouChercher.ordre_mc.append(nomDuMC)
1483 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1484 #print self.dicoNouveauxMC
1486 #----------------------------------------------------#
1487 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1488 #----------------------------------------------------#
1489 monMC=etape.get_child(MCFils,restreint="oui")
1490 if monMC== None : monMC= etape.addentite(MCFils)
1491 monMC.definition.into=into
1492 monMC.valeur=valeurs
1494 monMC.state='changed'
1497 #-------------------------------------#
1498 def ajoutVersionCataDsJDC(self,txt):
1499 #-------------------------------------#
1500 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1501 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1502 texte=txt+ligneVersion
1505 #-------------------------------------#
1506 def verifieVersionCataDuJDC(self,text):
1507 #-------------------------------------#
1509 indexDeb=text.find("#VERSION_CATALOGUE:")
1510 indexFin=text.find(":FIN VERSION_CATALOGUE")
1512 self.versionCataDuJDC="sans"
1515 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1516 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1518 self.versionCata="sans"
1519 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1521 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1522 return memeVersion,textJDC
1524 #-------------------------------#
1525 def traduitCatalogue(self,texte):
1526 #-------------------------------#
1527 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1528 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1530 traducteur=__import__(nomTraducteur)
1531 monTraducteur=traducteur.MonTraducteur(texte)
1532 nouveauTexte=monTraducteur.traduit()
1538 #------------------------------#
1539 def verifieCHECKSUM(self,text):
1540 #------------------------------#
1541 indexDeb=text.find("#CHECKSUM:")
1544 indexFin=text.find(":FIN CHECKSUM")
1545 checkAvant=text[indexDeb:indexFin+13]
1546 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1547 checksum=self.get_checksum(textJDC)
1548 pareil=(checkAvant==checksum)
1549 return pareil, textJDC
1551 #---------------------------#
1552 def get_checksum(self,texte):
1553 #---------------------------#
1554 newtexte=texte.replace('"','\\"')
1555 commande='echo "'+newtexte+'"|md5sum'
1556 a=os.popen(commande)
1559 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1563 #---------------------------#
1565 #---------------------------#
1566 texte="CONDUITE_FORCEE();"
1570 #---------------------------#
1571 def _newTELEMAC(self):
1572 #---------------------------#
1573 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1574 texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
1578 #---------------------------#
1580 #---------------------------#
1581 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1585 #---------------------------#
1586 def _newPSEN_N1(self):
1587 #---------------------------#
1588 texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1589 texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
1592 #---------------------------#
1594 #---------------------------#
1595 def _newZCRACKS(self):
1596 #---------------------------#
1597 texte="MAILLAGES();REMESHING();"
1600 #---------------------------#
1601 def _newJDCCND(self):
1602 #---------------------------#
1603 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1605 #if self.salome == 0 :
1606 QMessageBox.information( self,
1608 tr("Veuillez selectionner un fichier Med"))
1609 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1610 caption='Fichier Med',
1612 QSfichier=QSfichier[0]
1613 self.fichierMED=QSfichier
1614 from acquiertGroupes import getGroupes
1615 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1616 if erreur != "" : print ("a traiter")
1617 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1623 for groupe in self.listeGroupes :
1624 if groupe[0:8]=='CURRENT_':
1625 texteSources +=groupe[8:]+"=SOURCE("
1626 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1627 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1628 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1629 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1630 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1631 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1632 self.newTexteCND=texte
1637 #---------------------------#
1638 def BoutonFileSelected(self):
1639 #---------------------------#
1641 QSfichier=self.openfile.selectedFiles()[0]
1642 self.fichierMED=str(QSfichier)
1643 from acquiertGroupes import getGroupes
1644 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1645 if erreur != "" : print ("a traiter")
1647 #-----------------------------
1648 def BoutonSalomePressed(self):
1649 #----------------------------
1650 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1651 self.fichierMED="A_partir_de_SMESH"
1652 self.nomMaillage="A_partir_de_SMESH"
1653 self.openfile.close()
1656 #-----------------------------------------
1657 def initSplitterSizes(self, nbWidget=3):
1658 #-----------------------------------------
1659 #print ("je passe ds initSplitterSizes", nbWidget)
1661 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
1662 elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
1663 else : self.splitterSizes3=[150,1000,300]
1665 if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
1666 else : self.splitterSizes2=[300,1000]
1670 #-----------------------------------------
1671 def restoreSplitterSizes(self,nbWidget=3):
1672 #----------------------------------------
1674 #traceback.print_stack()
1675 #print ("je passe ds restoreSplitterSizes")
1676 if not(hasattr(self,'splitter')) : return
1677 if nbWidget==2 : newSizes=self.splitterSizes2
1678 if nbWidget==3 : newSizes=self.splitterSizes3
1679 #self.inhibeSplitter = 1
1680 self.splitter.setSizes(newSizes)
1681 #self.inhibeSplitter = 0
1682 QApplication.processEvents()
1683 # seule la fentetre du milieu est necessaire
1684 self.splitter.widget(1).resizeEvent=self.saveSplitterSizes
1686 #-----------------------------------------
1687 def saveSplitterSizes(self,event):
1688 #-----------------------------------------
1689 #print ("je passe ds saveSplitterSizes")
1690 if self.inhibeSplitter : return
1691 if self.widgetOptionnel == None : self.splitterSizes2 = self.splitter.sizes()[0:2]
1692 else : self.splitterSizes3 = self.splitter.sizes()[0:3]
1694 #------------------------
1695 def fermeOptionnel(self):
1696 #------------------------
1697 if self.widgetOptionnel == None : return
1699 self.inhibeSplitter=1
1700 self.widgetOptionnel.setParent(None)
1701 self.widgetOptionnel.close()
1702 self.widgetOptionnel.deleteLater()
1703 self.widgetOptionnel=None
1704 self.inhibeSplitter=0
1705 self.restoreSplitterSizes(2)
1707 #------------------------
1708 def ajoutOptionnel(self):
1709 #------------------------
1710 #if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
1711 #else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
1712 #self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1714 self.restoreSplitterSizes(3)
1717 #------------------------
1718 def fermeArbre(self):
1719 #------------------------
1720 #print (self.widgetTree)
1721 self.oldWidgetTree=self.widgetTree
1722 self.widgetTree.hide()
1723 #self.widgetTree=None
1725 #------------------------
1726 def ouvreArbre(self):
1727 #------------------------
1728 #print ('je passe la')
1729 #print (self.widgetTree)
1730 #self.widgetTree=self.oldWidgetTree
1731 self.widgetTree.show()
1732 #self.restoreSplitterSizes(3)
1734 #-----------------------------
1735 def getTreeIndex(self,noeud):
1736 #----------------------------
1738 if noeud in noeud.treeParent.children :
1739 indexNoeud=noeud.treeParent.children.index(noeud)
1741 if hasattr(noeud,'vraiParent') :
1743 noeudVraiParent = noeud.vraiParent
1744 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1745 noeudVrai = noeudVraiParent
1746 noeudVraiParent = noeudVraiParent.vraiParent
1748 if noeudVraiParent == noeud.treeParent :
1749 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1755 if __name__ == "__main__":
1757 name='prefs_'+prefs.code
1758 prefsCode=__import__(name)
1761 if hasattr(prefsCode,'encoding'):
1762 # Hack pour changer le codage par defaut des strings
1765 sys.setdefaultencoding(prefs.encoding)
1766 del sys.setdefaultencoding
1771 app = QApplication(sys.argv)
1772 mw = JDCEditor(None,'azAster.comm')
1773 app.setMainWidget(mw)
1774 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1777 res = app.exec_loop()