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 import types,sys,os, re
24 from determine import monEnvQT5
26 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
27 from PyQt5.QtGui import QPalette
28 from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
30 from PyQt4.QtGui import *
31 from PyQt4.QtCore import *
34 from datetime import date
35 from Extensions.i18n import tr
40 import convert, generator
41 from Editeur import session
42 from Editeur import comploader
43 from Editeur import Objecttreeitem
44 from desBaseWidget import Ui_baseWidget
45 from monViewTexte import ViewText
46 from monWidgetCreeParam import MonWidgetCreeParam
50 DictExtensions= {"MAP" : ".map"}
55 class JDCEditor(Ui_baseWidget,QWidget):
56 # ----------------------------------------- #
61 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
62 #----------------------------------------------------------------------------------------------------------#
64 QWidget.__init__(self,None)
68 self.widgetOptionnel=None
69 self.fenetreCentraleAffichee=None
70 self.dejaDansPlieTout=False
71 self.afficheCommandesPliees = True
72 self.listeDesListesOuvertes=set()
73 self.appliEficas = appli
74 self.appli = appli #---- attendu par IHM
76 self.fichier = fichier
79 self.QWParent = QWParent
80 self.couleur = Qt.black
83 self.salome = self.appliEficas.salome
86 print "dans JDC pas d appli ????????"
88 # ces attributs sont mis a jour par definitCode appelee par newEditor
89 self.code = self.appliEficas.CONFIGURATION.code
91 #self.afficheListesPliees=False
92 self.afficheListesPliees=True
93 if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
94 if self.code == 'PSEN_N1' : self.afficheListesPliees = False
96 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
97 self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
98 self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
99 self.affiche=self.appliEficas.CONFIGURATION.affiche
100 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
101 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
102 if self.code in ['MAP',] :
103 self.widgetTree.close()
105 self.appliEficas.resize(1440,self.appliEficas.height())
107 self.appliEficas.resize(1800,self.appliEficas.height())
109 self.version_code = session.d_env.cata
111 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
112 self.readercata = readercata.READERCATA( self, self.appliEficas )
113 self.appliEficas.readercata=self.readercata
114 self.appliEficas.code=self.code
116 self.readercata=self.appliEficas.readercata
117 if self.readercata.fic_cata == None : return #Sortie Salome
118 self.titre=self.readercata.titre
119 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
120 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
122 self.format = self.appliEficas.format_fichier
125 self.splitterSizes = [320,1320,320]
126 self.oldSizeWidgetOptionnel = 320
127 self.liste_simp_reel=[]
129 self.dicoNouveauxMC={}
131 nameConf='configuration_'+self.code
132 configuration=__import__(nameConf)
133 self.CONFIGURATION = self.appliEficas.CONFIGURATION
134 self.CONFIGStyle = self.appliEficas.CONFIGStyle
137 self.CONFIGURATION.generator_module
138 _module = __import__(self.CONFIGURATION.generator_module)
139 info = _module.entryPoint()
140 generator.plugins.addEntryPoint(info)
145 self.CONFIGURATION.convert_module
146 #print self.CONFIGURATION.convert_module
147 _module = __import__(self.CONFIGURATION.convert_module)
148 info = _module.entryPoint()
149 convert.plugins.addEntryPoint(info)
154 if hasattr(self.appliEficas,"statusBar"):
155 self.sb = self.appliEficas.statusBar()
158 self.lastModified = 0
160 self.modified = False
161 self.isReadOnly = False
162 self.node_selected = []
165 if self.code in ['Adao','MAP'] : self.afficheApresInsert=True
166 else : self.afficheApresInsert=False
167 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
168 else : self.enteteQTree='complet'
169 if self.code in ['Adao','TELEMAC'] : self.affichePlie=True
170 else : self.affichePlie=False
172 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
174 #------- construction du jdc --------------
179 if self.fichier is not None: # fichier jdc fourni
180 self.fileInfo = QFileInfo(self.fichier)
181 self.fileInfo.setCaching(0)
185 self.jdc = self.readFile(self.fichier)
188 print "mauvaise lecture"
191 if self.jdc is not None and units is not None:
192 self.jdc.recorded_units=units
193 self.jdc.old_recorded_units=units
195 if not self.jdc: # nouveau jdc
197 self.jdc = self._newJDC(units=units)
199 self.jdc = self._newJDCInclude(units=units)
203 self.jdc.appli = self # a resorber
204 self.jdc.editor = self
205 self.jdc.lang = self.appli.langue
206 self.jdc.aReafficher=False
210 txt_exception = self.jdc.cr.get_mess_exception()
213 QApplication.restoreOverrideCursor()
214 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
215 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
217 comploader.charger_composants("QT")
218 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
219 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
220 self.viewJdcRapport()
224 if jdc_item and self.appliEficas.ssIhm==False:
225 self.tree = browser.JDCTree( jdc_item, self )
226 self.appliEficas.construitMenu()
230 self.splitterSizes = [320,1320,320]
231 self.splitter.setSizes(self.splitterSizes)
232 self.saveSplitterSizes()
235 #-------------------# Pour execution avec output et error dans le bash
237 #-------------------#
238 #if self.modified or self.fichier==None : self.saveFile()
241 #lancement avec le .bat
242 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
243 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
245 p = subprocess.Popen(['python',WrapperFilePath])
246 (out,err)=p.communicate()
250 #-------------------# Pour execution avec output et error dans le bash
251 def runPSEN_N1(self):
252 #-------------------#
253 #cmd = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_N1','run.py'))
254 #cmd = "from run import runPSEN_N1; dico="+str(dico)
256 #textePython=("python "+ cmd + " "+ str(dico))
257 #self._viewTextExecute( textePython,"psen_run",".sh")
258 if generator.plugins.has_key('dicoImbrique'):
259 self.generator=generator.plugins['dicoImbrique']()
260 jdc_formate=self.generator.gener(self.jdc)
261 dico=self.generator.Dico
264 #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
265 #f = open( str(fileDico), 'wb')
266 #f.write("Dico =" + str(dico) )
271 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
272 sys.path.append(path1)
273 print 'in runPSEN_N1', dico
275 #res,txt_exception=run(dico)
276 #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
277 #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
280 #-------------------# Pour execution avec output et error dans le bash
281 def process_N1(self):
282 #-------------------#
283 return self.get_Dico()
286 #--------------------------------#
287 def _newJDC( self ,units = None):
288 #--------------------------------#
290 Initialise un nouveau JDC vierge
293 CONTEXT.unset_current_step()
296 if self.code == "CARMELCND" : texte=self._newJDCCND()
297 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
298 if self.code == "TELEMAC" : texte=self._newTELEMAC()
299 if self.code == "PSEN" : texte = self._newPSEN()
300 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
301 #if self.code == "CF" : texte = self._new_CF()
302 # texte=self.newTexteCND
304 jdc=self.readercata.cata[0].JdC( procedure =texte,
306 cata=self.readercata.cata,
307 cata_ord_dico=self.readercata.cata_ordonne_dico,
308 rep_mat=self.CONFIGURATION.rep_mat
310 jdc.lang = self.appli.langue
311 if units is not None:
312 jdc.recorded_units=units
313 jdc.old_recorded_units=units
314 ## PNPN est ce que la ligne suivante est bien utile ?
315 if texte == "" :jdc.analyse()
318 #--------------------------------#
319 def _newJDCInclude( self ,units = None):
320 #--------------------------------#
322 Initialise un nouveau JDC vierge
324 import Extensions.jdc_include
325 JdC_aux=Extensions.jdc_include.JdC_include
326 CONTEXT.unset_current_step()
328 jaux=self.readercata.cata[0].JdC( procedure="",
330 cata=self.readercata.cata,
331 cata_ord_dico=self.readercata.cata_ordonne_dico,
332 rep_mat=self.CONFIGURATION.rep_mat,
336 J=JdC_aux( procedure="",
338 cata=self.readercata.cata,
339 cata_ord_dico=self.readercata.cata_ordonne_dico,
341 rep_mat=self.CONFIGURATION.rep_mat,
344 if units is not None:
345 J.recorded_units=units
346 J.old_recorded_units=units
350 #-------------------------------#
351 def readFile(self, fn):
352 #--------------------------------#
354 Public slot to read the text from a file.
355 @param fn filename to read from (string or QString)
359 # ------------------------------------------------------------------------------------
361 # ------------------------------------------------------------------------------------
363 jdcName=os.path.basename(fn)
364 # Il faut convertir le contenu du fichier en fonction du format
365 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
366 # Le convertisseur existe on l'utilise
368 p=convert.plugins[self.appliEficas.format_fichier_in]()
370 if p.text=="" : self.nouveau=1
371 pareil,texteNew=self.verifieCHECKSUM(p.text)
373 if pareil == False and (self.appliEficas.ssIhm == False) :
374 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
376 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
377 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
379 text=p.convert('exec',self.appliEficas)
380 if not p.cr.estvide():
381 self.affiche_infos("Erreur a la conversion",Qt.red)
383 self.affiche_infos("Type de fichier non reconnu",Qt.red)
384 if self.appliEficas.ssIhm == False:
385 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
386 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
389 CONTEXT.unset_current_step()
390 jdc=self.readercata.cata[0].JdC(procedure=text,
392 cata=self.readercata.cata,
393 cata_ord_dico=self.readercata.cata_ordonne_dico,
395 rep_mat=self.CONFIGURATION.rep_mat
397 # ----------------------------------------------------
399 # ----------------------------------------------------
400 self.modified = False
402 # qApp.restoreOverrideCursor()
403 if self.fileInfo!= None :
404 self.lastModified = self.fileInfo.lastModified()
406 self.lastModified = 1
407 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
408 self.appliEficas.setWindowTitle(nouveauTitre)
412 #-----------------------#
413 def get_source(self,file):
414 #-----------------------#
416 # Il faut convertir le contenu du fichier en fonction du format
417 if convert.plugins.has_key(self.format):
418 # Le convertisseur existe on l'utilise
419 p=convert.plugins[self.format]()
421 text=p.convert('execnoparseur')
422 if not p.cr.estvide():
423 self.affiche_infos("Erreur a la conversion",Qt.red)
426 # Il n'existe pas c'est une erreur
427 self.affiche_infos("Type de fichier non reconnu",Qt.red)
428 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
431 #-----------------------------------------------------------------------#
432 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
433 #--------------------------------------------------------------------#
434 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
438 #----------------------------------------------#
439 def __generateTempFilename(self, prefix, suffix):
440 #----------------------------------------------#
442 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
448 #----------------------------------------------#
449 def _viewTextExecute(self, txt, prefix, suffix):
450 #----------------------------------------------#
451 self.w = ViewText( self.QWParent )
452 self.w.setWindowTitle( "execution" )
453 self.monExe=QProcess(self.w)
454 pid=self.monExe.pid()
455 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
456 f=open(nomFichier,'w')
460 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
461 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
463 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
464 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
465 exe='sh ' + nomFichier
466 self.monExe.start(exe)
467 self.monExe.closeWriteChannel()
470 commande="rm "+ nomFichier
475 def readFromStdErr(self):
476 a=self.monExe.readAllStandardError()
477 self.w.view.append(str(a.data(),len(a)))
479 def readFromStdErr(self) :
480 a=self.monExe.readAllStandardOutput()
481 self.w.view.append(str(a.data(),len(a)))
483 def readFromStdErrQT4(self):
484 a=self.monExe.readAllStandardError()
485 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
487 def readFromStdOutQT4(self) :
488 a=self.monExe.readAllStandardOutput()
489 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
493 #-----------------------#
494 def gestionParam(self):
495 #-----------------------#
496 w = MonWidgetCreeParam( self)
499 #-----------------------#
500 def viewJdcSource(self):
501 #-----------------------#
502 f=open(self.fichier,'r')
505 self._viewText(texteSource, "JDC_SOURCE")
507 #-----------------------#
509 #-----------------------#
510 strSource = str( self.get_text_JDC(self.format) )
511 self._viewText(strSource, "JDC_RESULTAT")
513 #-----------------------#
514 def viewJdcRapport(self):
515 #-----------------------#
516 strRapport = unicode( self.jdc.report() )
517 # on ajoute les regles
519 self._viewText(strRapport, "JDC_RAPPORT")
521 #-----------------------#
522 def viewJdcRegles(self):
523 #-----------------------#
524 if self.tree :self.tree.AppelleBuildLBRegles()
531 Public method called by the viewmanager to finally get rid of us.
537 #----------------------------------------------#
538 def affiche_infos(self,message,couleur=Qt.black):
539 #----------------------------------------------#
541 mapalette=self.sb.palette()
542 mapalette.setColor( QPalette.WindowText, couleur )
543 self.sb.setPalette( mapalette );
544 self.sb.showMessage(message,4000)
547 #------------------------------#
548 def affiche_alerte(self,titre,message):
549 #------------------------------#
550 # appele par I_MACRO_ETAPE
551 QMessageBox.information( self, titre, message)
553 #-----------------------------------#
554 def affiche_commentaire(self,message):
555 #-----------------------------------#
556 self.labelCommentaire.setText(message)
557 QTimer.singleShot(6000, self.rendInvisible)
559 #----------------------#
560 def rendInvisible(self):
561 #----------------------#
562 self.labelCommentaire.setText("")
564 #-------------------#
565 def init_modif(self):
566 #-------------------#
568 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
569 si un JDC doit etre sauvegarde avant destruction ou non
573 #---------------------------------------#
574 def chercheNoeudSelectionne(self,copie=1):
575 #---------------------------------------#
577 appele par Cut et Copy pour positionner self.node_selected
579 self.node_selected=[]
580 if len(self.tree.selectedItems()) == 0 : return
581 self.node_selected=self.tree.selectedItems()
584 #---------------------#
585 def handleSupprimer(self):
586 #---------------------#
587 self.chercheNoeudSelectionne()
588 if len(self.node_selected) == 0 : return
589 self.QWParent.noeud_a_editer = []
590 if self.node_selected[0]==self.tree.racine: return
591 if len(self.node_selected) == 1 : self.node_selected[0].delete()
592 else : self.node_selected[0].deleteMultiple(self.node_selected)
594 #---------------------#
595 def handleRechercher(self):
596 #---------------------#
597 from monRecherche import DRecherche
598 monRechercheDialg=DRecherche(parent=self,fl=0)
599 monRechercheDialg.show()
602 #--------------------------------#
603 def handleRechercherDsCatalogue(self):
604 #-----------------------------#
605 from monRechercheCatalogue import DRechercheCatalogue
606 monRechercheDialg=DRechercheCatalogue(self.QWParent,self)
607 monRechercheDialg.show()
609 #---------------------#
610 def handleDeplier(self):
611 #---------------------#
612 if self.tree == None : return
613 #self.tree.collapseAll()
616 self.tree.expandItem(self.tree.topLevelItem(0))
618 if self.fenetreCentraleAffichee != None :
619 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
620 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
623 self.tree.expandItem(self.tree.topLevelItem(0))
625 if self.fenetreCentraleAffichee != None :
626 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
627 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
629 #---------------------#
630 def handleEditCut(self):
631 #---------------------#
633 Stocke dans Eficas.noeud_a_editer le noeud a couper
635 #print "handleEditCut"
636 self.chercheNoeudSelectionne()
637 self.QWParent.edit="couper"
638 self.QWParent.noeud_a_editer = self.node_selected
640 #-----------------------#
641 def handleEditCopy(self):
642 #-----------------------#
644 Stocke dans Eficas.noeud_a_editer le noeud a copier
646 self.chercheNoeudSelectionne()
647 if len(self.node_selected) == 0 : return
648 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
649 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
650 self.QWParent.edit="copier"
651 self.QWParent.noeud_a_editer = self.node_selected
653 #------------------------#
654 def handleEditPaste(self):
655 #------------------------#
657 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
658 Ne permet que la copie d'objets de type Commande ou MCF
660 self.chercheNoeudSelectionne()
661 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
662 QMessageBox.information( self,
663 tr("Copie impossible"),
664 tr("Veuillez selectionner un objet a copier"))
666 if len(self.node_selected) != 1 :
667 QMessageBox.information( self,
668 tr("Copie impossible"),
669 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
672 if len(self.QWParent.noeud_a_editer)!=1:
673 self.handleEditPasteMultiple()
676 noeudOuColler=self.node_selected[0]
678 if noeudOuColler == self.tree.racine:
682 #indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
683 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
686 noeudACopier=self.QWParent.noeud_a_editer[0]
687 #indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
688 indexNoeudACopier=self.getTreeIndex(noeudACopier)
690 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
693 if (self.QWParent.edit != "couper"):
695 if noeudOuColler == self.tree.racine :
696 child=noeudOuColler.doPastePremier(noeudACopier)
698 child=noeudACopier.doPaste(noeudOuColler,pos)
699 if child==None or child==0:
700 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
702 self.affiche_infos("Copie refusee",Qt.red)
703 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
705 nom=noeudACopier.item.sd.nom
706 child.item.nomme_sd(nom)
713 traceback.print_exc()
714 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
716 self.affiche_infos("Copie refusee",Qt.red)
719 # il faut declarer le JDCDisplay_courant modifie
720 # suppression eventuelle du noeud selectionne
721 # si possible on renomme l objet comme le noeud couper
723 if (self.QWParent.edit == "couper"):
725 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
726 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
730 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
731 indexNoeudACopier=self.getTreeIndex(noeudACopier)
732 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
733 noeudACopier.treeParent.build_children()
738 self.QWParent.noeud_a_editer=[]
740 # on rend la copie a nouveau possible en liberant le flag edit
741 self.QWParent.edit="copier"
742 noeudACopier.select()
744 #----------------------------------#
745 def handleDeplaceMultiple(self):
746 #----------------------------------#
749 #----------------------------------#
750 def handleEditPasteMultiple(self):
751 #----------------------------------#
753 # On ne garde que les niveaux "Etape"
754 # On insere dans l'ordre du JDC
755 listeNoeudsACouper=[]
759 from InterfaceQT4 import compojdc
760 noeudOuColler=self.node_selected[0]
761 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
762 QMessageBox.information( self,
763 tr("Copie impossible a cet endroit",),
764 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
766 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
768 for noeud in self.QWParent.noeud_a_editer :
769 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
770 indexInTree=noeud.treeParent.children.index(noeud)
772 for index in listeIndex:
773 if index < indexInTree : indice = indice +1
774 listeIndex.insert(indice, indexInTree)
775 listeNoeudsACouper.insert(indice, noeud)
777 noeudJdc=noeudOuColler.treeParent
779 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
781 for index in listeIndex:
783 if indexNoeudOuColler < index:
784 indexTravail=indexTravail+dejaCrees
785 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
786 noeud=noeudJdc.children[indexTravail]
787 child=noeud.doPaste(noeudOuColler)
788 listeChild.append(child)
789 dejaCrees=dejaCrees+1
791 self.QWParent.noeud_a_editer = []
792 for i in range(len(listeIndex)):
793 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
794 self.QWParent.noeud_a_editer.append(noeud)
797 if self.QWParent.edit !="couper" : return
799 for index in listeIndex:
801 if indexNoeudOuColler < index:
802 indexTravail=indexTravail+(len(listeIndex))
803 noeud=noeudJdc.children[indexTravail]
805 listeItem.append(noeud.item)
806 listeASupprimer.append(noeud)
808 for i in range(len(listeChild)):
809 self.tree.item.suppitem(listeItem[i])
810 listeChild[i].item.update(listeItem[i])
812 self.QWParent.noeud_a_editer = []
815 #---------------------#
816 def getFileName(self):
817 #---------------------#
820 #---------------------------#
821 def get_file_variable(self) :
822 #---------------------------#
823 titre = tr("Choix d'un fichier XML")
824 texte = tr("Le fichier contient une commande MODEL\n")
825 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
826 QMessageBox.information( self, titre,tr(texte))
828 fichier = QFileDialog.getOpenFileName(self.appliEficas,
829 tr('Ouvrir Fichier'),
830 self.appliEficas.CONFIGURATION.savedir,
831 tr('Wrapper Files (*.xml);;''All Files (*)'))
834 #--------------------------------------------------#
835 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
836 #--------------------------------------------------#
838 Public slot to write the text to a file.
840 @param fn filename to write to string
841 @return flag indicating success
847 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
849 if len(txt) >= len(eol):
850 if txt[-len(eol):] != eol:
854 txt=self.ajoutVersionCataDsJDC(txt)
855 checksum=self.get_checksum(txt)
863 if (self.appliEficas.ssIhm == False):
864 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
865 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
870 #-----------------------------------------------------------#
871 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
872 #-----------------------------------------------------------#
873 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
874 if generator.plugins.has_key(format):
876 # Le generateur existe on l'utilise
877 self.generator=generator.plugins[format]()
879 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
880 if pourRun : jdc_formate=self.generator.textePourRun
882 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
883 if not self.generator.cr.estvide():
884 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
885 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
890 # Il n'existe pas c'est une erreur
891 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
892 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
895 #----------------------#
897 #---------------------#
898 if generator.plugins.has_key('dicoImbrique'):
899 self.generator=generator.plugins['dicoImbrique']()
900 jdc_formate=self.generator.gener(self.jdc)
901 dico=self.generator.Dico
904 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
905 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
912 fonction="run"+self.code
914 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
919 fonction="saveRun"+self.code
920 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
926 if not(self.jdc.isvalid()):
927 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
929 if len(self.jdc.etapes) != 1 :
930 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
932 if self.modified or self.fichier==None :
933 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
934 texte=self.get_text_JDC("MAP")
935 self.writeFile( self.fichierMapInput, txt = texte)
937 self.fichierMapInput=self.fichier
938 composant=self.jdc.etapes[0].nom.lower()[0:-5]
941 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
942 # then instantiate corresponding class and call getUseSalome() method
944 from mapengine.spec import factory
945 mapComponent = factory.new(composant)[0]
948 if mapComponent.getUseSalome():
949 command += " -r sappli"
950 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
953 self._viewTextExecute( textePython,"map_run",".sh")
955 # commande="rm "+self.fichierMapInput
956 # os.system(commande)
960 print traceback.print_exc()
962 #-------------------#
963 def runZCRACKS(self):
964 #-------------------#
965 if not(self.jdc.isvalid()):
966 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
968 if self.modified or self.fichier==None :
970 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
971 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
972 self.writeFile( self.fichierZcracksInput, txt = texte)
974 self.fichierZcracksInput=self.fichier
976 #commande ="Zrun -zp "
978 textePython=(commande + self.fichierZcracksInput)
979 self._viewTextExecute( textePython,"run_zcracks",".sh")
981 print traceback.print_exc()
983 #-------------------#
984 def runCARMELCND(self):
985 #-------------------#
986 #if not(self.jdc.isvalid()):
987 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
989 if self.modified or self.fichier==None :
990 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
992 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
993 from PrepareRunCarmel import prepareRunCarmel
994 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
995 repMed=os.path.dirname(self.fichier)
996 repExeCarmel=self.generator.get_repExeCarmel()
997 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
998 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
999 f=open(nomFichier,'w')
1000 f.write(textePython)
1002 commande="xterm -e sh "+nomFichier +"\n"
1005 # self._viewTextExecute( textePython,"carmel_run",".sh")
1006 #except Exception, e:
1007 # print traceback.print_exc()
1009 #-------------------#
1010 def runCarmelCS(self):
1011 #-------------------#
1013 commande="runSession pilotyacsCS.py"
1015 except Exception, e:
1016 print traceback.print_exc()
1018 #-----------------------------------------------------#
1019 def determineNomFichier(self,path,extension):
1020 #-----------------------------------------------------#
1021 if DictExtensions.has_key(self.appli.code) :
1022 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
1023 extensions= tr(chaine1+ "All Files (*)")
1025 extensions= tr("JDC (*.comm);;" "All Files (*)")
1027 if self.appli.code == "MAP" :
1028 extensions = extensions + ";; Run (*.input);;"
1030 fn = QFileDialog.getSaveFileName( self,
1031 tr("sauvegarde"), path,
1033 QFileDialog.DontConfirmOverwrite)
1034 if fn == None : return (0, None)
1035 if monEnvQT5 : fn=fn[0]
1036 if fn=='': return (0, None)
1038 ext = QFileInfo(fn).suffix()
1039 if ext == '': fn+=extension
1041 if QFileInfo(fn).exists():
1043 msgBox = QMessageBox(self)
1044 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1045 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", unicode(fn)))
1046 msgBox.addButton(tr("&Ecraser"),0)
1047 msgBox.addButton(tr("&Abandonner"),1)
1048 abort=msgBox.exec_()
1050 abort = QMessageBox.warning(self,
1051 tr("Sauvegarde du Fichier"),
1052 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
1055 if abort == 1 : return (0, "")
1059 def saveRunMAP(self):
1062 if not(self.jdc.isvalid()):
1063 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1064 tr("Un JdC valide est necessaire pour creer un .input")
1068 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1070 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1071 tr("Choix du composant obligatoire")
1074 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1078 if self.fichier is not None and self.fichier != "" :
1079 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1080 monPath=str(QFileInfo(self.fichier).absolutePath())
1081 monNomFichier=os.path.join(monPath,maBase)
1082 elif hasattr(self,'monNomFichierInput'):
1083 monNomFichier=self.monNomFichierInput
1086 monDialog=QFileDialog(self.appliEficas)
1087 monDialog.setDirectory (path)
1088 monDialog.setWindowTitle ("Save")
1090 for c in monDialog.children():
1091 if isinstance(c,QDialogButtonBox):
1092 for b in c.children():
1093 if isinstance(b,QPushButton):
1095 if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
1096 if monEnvQT5 and avant=="&Open": b.setText("Save")
1098 mesFiltres= "input Map (*.input);;All Files (*)"
1100 mesFiltres=QStringList()
1101 mesFiltres << "input Map (*.input)" << "All Files (*)"
1102 monDialog.setNameFilters(mesFiltres)
1103 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1104 BOk=monDialog.exec_()
1106 if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
1107 else : fn=str(monDialog.selectedFiles()[0].toLatin1())
1108 if fn == "" or fn == None : return
1109 if not fn.endswith(".input"):
1111 self.monNomFichierInput=fn
1113 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1114 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1115 texte=self.get_text_JDC("MAP")
1116 self.writeFile( self.fichierMapInput, txt = texte)
1118 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1119 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1120 (output, err) = p.communicate()
1124 def saveRunPSEN(self):
1129 if not(self.jdc.isvalid()):
1130 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1131 tr("Un JdC valide est necessaire pour creer un .input")
1135 #print generator.plugins.has_key(self.format)
1136 if generator.plugins.has_key(self.format):
1137 # Le generateur existe on l'utilise
1138 self.generator=generator.plugins[self.format]()
1140 self.generator.gener(self.jdc)
1141 self.generator.writeDefault('')
1142 except ValueError,e:
1143 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1144 if not self.generator.cr.estvide():
1145 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1146 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1149 # Il n'existe pas c'est une erreur
1150 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1151 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1158 #-----------------------------------------#
1159 def cherche_Groupes(self):
1160 #-----------------------------------------#
1161 listeMA,listeNO=self.get_text_JDC("GroupMA")
1162 return listeMA,listeNO
1164 #-----------------------------------------#
1165 def cherche_Dico(self):
1166 #-----------------------------------------#
1168 format = self.appliEficas.format_fichier
1169 if generator.plugins.has_key(format):
1170 # Le generateur existe on l'utilise
1171 self.generator=generator.plugins[format]()
1172 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1173 dicoCourant=self.generator.dico
1178 #-----------------------------------------#
1179 def handleAjoutGroup(self,listeGroup):
1180 #-----------------------------------------#
1183 from ajoutGroupe import handleAjoutGroupFiltre
1185 handleAjoutGroupFiltre(self,listeGroup)
1186 #print "apres handleAjoutGroupFiltre"
1191 #-----------------------------------------------------------------#
1192 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1193 #-----------------------------------------------------------------#
1195 Public slot to save the text to a file.
1197 @param path directory to save the file in (string or QString)
1198 @return tuple of two values (boolean, string) giving a success indicator and
1199 the name of the saved file
1203 if not self.modified and not saveas:
1204 return (0, None) # do nothing if text wasn't changed
1207 if DictExtensions.has_key(self.appli.code) :
1208 extension=DictExtensions[self.appli.code]
1214 if self.fichier is None or saveas:
1215 if path is None: path=self.CONFIGURATION.savedir
1216 bOK, fn=self.determineNomFichier(path,extension)
1217 if bOK == 0 : return (0, None)
1218 if fn == None : return (0, None)
1219 if fn== '' : return (0, None)
1221 ulfile = os.path.abspath(unicode(fn))
1222 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1223 fn = unicode(QDir.toNativeSeparators(fn))
1227 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1229 self.modified = False
1230 if self.fileInfo is None or saveas:
1231 self.fileInfo = QFileInfo(self.fichier)
1232 self.fileInfo.setCaching(0)
1233 self.lastModified = self.fileInfo.lastModified()
1234 if newName is not None:
1235 self.appliEficas.addToRecentList(newName)
1236 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1237 self.tree.racine.update_node_label()
1239 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1240 self.generator.writeDefault(fn)
1241 if self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1242 self.generator.writeDefault(fn)
1245 self.appliEficas.addJdcInSalome( self.fichier)
1247 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1248 self.appliEficas.setWindowTitle(nouveauTitre)
1250 return (1, self.fichier)
1253 #----------------------------------------------#
1254 def sauveLigneFile(self):
1255 #----------------------------------------------#
1257 return self.saveFile(formatLigne="Ligne")
1260 #----------------------------------------------#
1261 def saveFileAs(self, path = None,fileName=None):
1262 #----------------------------------------------#
1264 Public slot to save a file with a new name.
1266 @param path directory to save the file in (string or QString)
1267 @return tuple of two values (boolean, string) giving a success indicator and
1268 the name of the saved file
1270 if fileName != None :
1271 self.fichier = fileName
1272 return self.saveFile()
1273 return self.saveFile(path,1,"beautifie")
1277 #---------------------------------------------#
1278 def get_file(self,unite=None,fic_origine = ''):
1279 #---------------------------------------------#
1287 titre = tr("Choix unite %d ", unite)
1288 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1289 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1290 labeltexte = tr('Fichier pour unite ') + repr( unite)
1292 titre = tr("Choix d'un fichier de poursuite")
1293 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1294 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1296 QMessageBox.information( self, titre,texte)
1297 fn = QFileDialog.getOpenFileName(self.appliEficas,
1299 self.appliEficas.CONFIGURATION.savedir)
1301 # ce retour est impose par le get_file d'I_JDC
1302 if fn== '' : return None," "
1303 if not fn : return (0, " ")
1304 if monEnvQT5 : fn=fn[0]
1306 ulfile = os.path.abspath(unicode(fn))
1307 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1309 # On utilise le convertisseur defini par format_fichier
1310 source=self.get_source(ulfile)
1312 # On a reussia convertir le fichier self.ulfile
1315 # Une erreur a ete rencontree
1317 return ulfile, jdcText
1319 #-------------------------------#
1320 def updateJdc(self, itemApres,texte):
1321 #--------------------------------#
1323 etape=monItem.item.object
1325 CONTEXT.set_current_step(etape)
1326 etape.build_includeInclude(texte)
1327 self.tree.racine.build_children()
1329 #-------------------------------------#
1330 def deleteEtape(self,etape):
1331 #-------------------------------------#
1332 self.jdc.suppentite(etape)
1334 #-------------------------------------#
1335 def deleteMC(self,etape,MCFils,listeAvant=()):
1336 #-------------------------------------#
1338 for mot in listeAvant :
1339 ouChercher=ouChercher.get_child(mot,restreint="oui")
1340 monMC=ouChercher.get_child(MCFils,restreint="oui")
1341 if monMC != None : ouChercher.suppentite(monMC)
1342 ouChercher.state='changed'
1343 ouChercher.isvalid()
1345 #-------------------------------------#
1346 def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
1347 #-------------------------------------#
1349 for mot in listeAvant :
1350 ouChercher=ouChercher.get_child(mot,restreint="oui")
1351 monMC=etape.get_child(ouChercher,restreint="oui")
1352 if monMC== None : monMC= ouChercher.addentite(MCFils)
1353 monMC.valeur=valeurs
1355 monMC.state='changed'
1358 #-----------------------------------------------------------#
1359 def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
1360 #-----------------------------------------------------------#
1362 for mot in listeAvant :
1363 ouChercher=ouChercher.get_child(mot,restreint="oui")
1364 if ouChercher ==None : print 'SOUCI'; return
1365 monMC=ouChercher.get_child(MCFils,restreint="oui")
1366 if monMC== None : monMC= ouChercher.addentite(MCFils)
1367 monMC.definition.into=valeurs
1368 monMC.state='changed'
1371 #-------------------------------------#
1372 def changeIntoDefMC(self,etape,listeMC,valeurs):
1373 #-------------------------------------#
1374 definitionEtape=getattr(self.jdc.cata[0],etape)
1375 ouChercher=definitionEtape
1376 if len(listeMC) > 1 :
1377 for mc in listeMC[0:-1]:
1378 mcfact=ouChercher.entites[mc]
1381 mcAccas=ouChercher.entites[listeMC[-1]]
1382 mcAccas.into=valeurs
1384 #-------------------------------------------------------------#
1385 def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
1386 #-------------------------------------------------------------#
1387 #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
1388 definitionEtape=getattr(self.jdc.cata[0],etape)
1389 ouChercher=definitionEtape
1390 for k in listeAvant :
1391 ouChercher=ouChercher.entites[k]
1392 MCADetruire=ouChercher.entites[nomDuMC]
1393 ouChercher.ordre_mc.remove(nomDuMC)
1394 del ouChercher.entites[nomDuMC]
1395 del self.dicoNouveauxMC[nomDuMC]
1398 #-------------------------------------------------------------#
1399 def ajoutDefinitionMC(self,etape,listeAvant,nomDuMC,typ,**args):
1400 #-------------------------------------------------------------#
1401 definitionEtape=getattr(self.jdc.cata[0],etape)
1402 ouChercher=definitionEtape
1403 for k in listeAvant :
1404 ouChercher=ouChercher.entites[k]
1405 from Accas import A_SIMP
1406 Nouveau=A_SIMP.SIMP(typ,**args)
1407 Nouveau.pere=ouChercher
1410 ouChercher.entites[nomDuMC]=Nouveau
1411 ouChercher.ordre_mc.append(nomDuMC)
1412 self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args)
1413 #print self.dicoNouveauxMC
1415 #----------------------------------------------------#
1416 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1417 #----------------------------------------------------#
1418 monMC=etape.get_child(MCFils,restreint="oui")
1419 if monMC== None : monMC= etape.addentite(MCFils)
1420 monMC.definition.into=into
1421 monMC.valeur=valeurs
1423 monMC.state='changed'
1426 #-------------------------------------#
1427 def ajoutVersionCataDsJDC(self,txt):
1428 #-------------------------------------#
1429 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1430 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1431 texte=txt+ligneVersion
1434 #-------------------------------------#
1435 def verifieVersionCataDuJDC(self,text):
1436 #-------------------------------------#
1438 indexDeb=text.find("#VERSION_CATALOGUE:")
1439 indexFin=text.find(":FIN VERSION_CATALOGUE")
1441 self.versionCataDuJDC="sans"
1444 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1445 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1447 self.versionCata="sans"
1448 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1450 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1451 return memeVersion,textJDC
1453 #-------------------------------#
1454 def traduitCatalogue(self,texte):
1455 #-------------------------------#
1456 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1457 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1459 traducteur=__import__(nomTraducteur)
1460 monTraducteur=traducteur.MonTraducteur(texte)
1461 nouveauTexte=monTraducteur.traduit()
1467 #------------------------------#
1468 def verifieCHECKSUM(self,text):
1469 #------------------------------#
1470 indexDeb=text.find("#CHECKSUM:")
1473 indexFin=text.find(":FIN CHECKSUM")
1474 checkAvant=text[indexDeb:indexFin+13]
1475 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1476 checksum=self.get_checksum(textJDC)
1477 pareil=(checkAvant==checksum)
1478 return pareil, textJDC
1480 #---------------------------#
1481 def get_checksum(self,texte):
1482 #---------------------------#
1483 newtexte=texte.replace('"','\\"')
1484 commande='echo "'+newtexte+'"|md5sum'
1485 a=os.popen(commande)
1488 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1492 #---------------------------#
1494 #---------------------------#
1495 texte="CONDUITE_FORCEE();"
1499 #---------------------------#
1500 def _newTELEMAC(self):
1501 #---------------------------#
1502 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1506 #---------------------------#
1508 #---------------------------#
1509 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1513 #---------------------------#
1514 def _newPSEN_N1(self):
1515 #---------------------------#
1516 #texte="CASE_SELECTION() ; CONTINGENCY_OPTIONS() ; OUTPUT_OPTIONS() ; "
1517 texte="CASE_SELECTION() ; N_PROCESSING_OPTIONS() ; CONTINGENCY_OPTIONS() ; CONTINGENCY_SELECTION(); CONTINGENCY_PROCESSING(); "
1520 #---------------------------#
1522 #---------------------------#
1523 def _newZCRACKS(self):
1524 #---------------------------#
1525 texte="MAILLAGES();REMESHING();"
1528 #---------------------------#
1529 def _newJDCCND(self):
1530 #---------------------------#
1531 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1533 #if self.salome == 0 :
1534 QMessageBox.information( self,
1536 tr("Veuillez selectionner un fichier Med"))
1537 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1538 caption='Fichier Med',
1540 if monEnvQT5 : QSfichier=QSfichier[0]
1541 self.fichierMED=QSfichier
1542 from acquiertGroupes import getGroupes
1543 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1544 if erreur != "" : print "a traiter"
1545 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1551 for groupe in self.listeGroupes :
1552 if groupe[0:8]=='CURRENT_':
1553 texteSources +=groupe[8:]+"=SOURCE("
1554 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1555 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1556 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1557 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1558 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1559 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1560 self.newTexteCND=texte
1565 #---------------------------#
1566 def BoutonFileSelected(self):
1567 #---------------------------#
1569 QSfichier=self.openfile.selectedFiles()[0]
1570 self.fichierMED=str(QSfichier)
1571 from acquiertGroupes import getGroupes
1572 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1573 if erreur != "" : print "a traiter"
1575 #-----------------------------
1576 def BoutonSalomePressed(self):
1577 #----------------------------
1578 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1579 self.fichierMED="A_partir_de_SMESH"
1580 self.nomMaillage="A_partir_de_SMESH"
1581 self.openfile.close()
1583 #-------------------------------------
1584 def saveSplitterSizes(self,event=None):
1585 #------------------------------------
1586 if self.inhibeSplitter : return
1587 if not hasattr(self,'splitter') : return
1588 if self.splitterSizes[2] != 0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
1589 #print self.splitterSizes
1590 #print self.splitter.sizes()
1591 # PNPNPNPN parfoir self.splitter.sizes() a une longueur de 4...
1592 nbAGarder=len(self.splitter.sizes())
1593 if nbAGarder > 3 : nbAGarder=3
1594 for i in range(nbAGarder):
1595 self.splitterSizes[i] = self.splitter.sizes()[i]
1596 self.splitter.widget(i).resizeEvent=self.saveSplitterSizes
1597 #print self.splitter.sizes()
1600 #-----------------------------------------
1601 def restoreSplitterSizes(self,nbWigdet=3):
1602 #----------------------------------------
1603 self.inhibeSplitter = 1
1605 if not(hasattr(self,'splitter')) : return
1606 newSizes=self.splitterSizes[:nbWigdet]
1607 self.splitter.setSizes(newSizes)
1608 self.inhibeSplitter = 0
1610 #------------------------
1611 def fermeOptionnel(self):
1612 #------------------------
1613 if self.widgetOptionnel == None : return
1615 self.inhibeSplitter=1
1616 self.splitterSizes[1] = self.splitterSizes[1] + self.splitterSizes[2]
1617 if self.splitterSizes[2]!=0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
1618 self.splitterSizes[2]=0
1620 self.widgetOptionnel.setParent(None)
1621 self.widgetOptionnel.close()
1622 self.widgetOptionnel.deleteLater()
1623 self.widgetOptionnel=None
1624 self.inhibeSplitter=0
1625 self.restoreSplitterSizes(2)
1627 #------------------------
1628 def ajoutOptionnel(self):
1629 #------------------------
1630 #print "ajoutOptionnel"
1631 #print self.splitterSizes
1632 self.splitterSizes[2] = self.oldSizeWidgetOptionnel
1633 self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1634 self.inhibeSplitter=0
1635 self.restoreSplitterSizes(3)
1638 #-----------------------------
1639 def getTreeIndex(self,noeud):
1640 #----------------------------
1642 if noeud in noeud.treeParent.children :
1643 indexNoeud=noeud.treeParent.children.index(noeud)
1645 if hasattr(noeud,'vraiParent') :
1647 noeudVraiParent = noeud.vraiParent
1648 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1649 noeudVrai = noeudVraiParent
1650 noeudVraiParent = noeudVraiParent.vraiParent
1652 if noeudVraiParent == noeud.treeParent :
1653 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1659 if __name__ == "__main__":
1661 name='prefs_'+prefs.code
1662 prefsCode=__import__(name)
1665 if hasattr(prefsCode,'encoding'):
1666 # Hack pour changer le codage par defaut des strings
1669 sys.setdefaultencoding(prefs.encoding)
1670 del sys.setdefaultencoding
1675 app = QApplication(sys.argv)
1676 mw = JDCEditor(None,'azAster.comm')
1677 app.setMainWidget(mw)
1678 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1681 res = app.exec_loop()