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 PyQt4.QtGui import *
25 from PyQt4.QtCore import *
28 from datetime import date
29 from Extensions.i18n import tr
34 import convert, generator
35 from Editeur import session
36 from Editeur import comploader
37 from Editeur import Objecttreeitem
38 from desBaseWidget import Ui_baseWidget
39 from monViewTexte import ViewText
40 from monViewTexte import ViewText2
41 from monWidgetCreeParam import MonWidgetCreeParam
45 DictExtensions= {"MAP" : ".map"}
49 class JDCEditor(Ui_baseWidget,QtGui.QWidget):
50 # ----------------------------------------- #
55 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
56 #----------------------------------------------------------------------------------------------------------#
58 QtGui.QWidget.__init__(self,None)
60 self.widgetOptionnel=None
61 self.fenetreCentraleAffichee=None
62 self.dejaDansPlieTout=False
63 self.afficheCommandesPliees = True
64 self.appliEficas = appli
65 self.appli = appli #---- attendu par IHM
67 self.fichier = fichier
70 self.QWParent = QWParent
73 self.salome = self.appliEficas.salome
76 print "dans JDC pas d appli ????????"
78 # ces attributs sont mis a jour par definitCode appelee par newEditor
79 self.code = self.appliEficas.CONFIGURATION.code
80 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
81 self.affiche=self.appliEficas.CONFIGURATION.affiche
82 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
83 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
84 if self.code in ['MAP',] :
85 self.widgetTree.close()
87 self.appliEficas.resize(1440,self.appliEficas.height())
89 self.appliEficas.resize(2000,self.appliEficas.height())
91 self.version_code = session.d_env.cata
93 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
94 self.readercata = readercata.READERCATA( self, self.appliEficas )
95 self.appliEficas.readercata=self.readercata
97 self.readercata=self.appliEficas.readercata
98 if self.readercata.fic_cata == None : return #Sortie Salome
99 self.titre=self.readercata.titre
100 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
101 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
103 self.format = self.appliEficas.format_fichier
106 self.liste_simp_reel=[]
109 nameConf='configuration_'+self.code
110 configuration=__import__(nameConf)
111 self.CONFIGURATION = self.appliEficas.CONFIGURATION
112 self.CONFIGStyle = self.appliEficas.CONFIGStyle
115 self.CONFIGURATION.generator_module
116 _module = __import__(self.CONFIGURATION.generator_module)
117 info = _module.entryPoint()
118 generator.plugins.addEntryPoint(info)
123 self.CONFIGURATION.convert_module
124 _module = __import__(self.CONFIGURATION.convert_module)
125 info = _module.entryPoint()
126 convert.plugins.addEntryPoint(info)
131 if hasattr(self.appliEficas,"statusBar"):
132 self.sb = self.appliEficas.statusBar()
135 self.lastModified = 0
137 self.modified = False
138 self.isReadOnly = False
139 self.node_selected = []
142 if self.code in ['Adao','MAP'] : self.afficheApresInsert=True
143 else : self.afficheApresInsert=False
144 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
145 else : self.enteteQTree='complet'
146 if self.code in ['Adao','TELEMAC'] : self.affichePlie=True
147 else : self.affichePlie=False
149 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
151 #------- construction du jdc --------------
156 if self.fichier is not None: # fichier jdc fourni
157 self.fileInfo = QFileInfo(self.fichier)
158 self.fileInfo.setCaching(0)
162 self.jdc = self.readFile(self.fichier)
165 print "mauvaise lecture"
168 if self.jdc is not None and units is not None:
169 self.jdc.recorded_units=units
170 self.jdc.old_recorded_units=units
172 if not self.jdc: # nouveau jdc
174 self.jdc = self._newJDC(units=units)
176 self.jdc = self._newJDCInclude(units=units)
180 self.jdc.appli = self
181 self.jdc.lang = self.appli.langue
182 self.jdc.aReafficher=False
186 txt_exception = self.jdc.cr.get_mess_exception()
189 qApp.restoreOverrideCursor()
190 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
191 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
193 comploader.charger_composants("QT")
194 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
195 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
196 self.viewJdcRapport()
201 self.tree = browser.JDCTree( jdc_item, self )
202 self.appliEficas.construitMenu()
204 #-------------------# Pour execution avec output sans une fenetre EFICAS. (erreurs encore dans la fenetre bash)
206 #-------------------#
207 if self.modified or self.fichier==None :
208 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
211 #monPython="/home/A96028/salome75/prerequisites/install/Python-273-tcl8513-tk8513/bin/python"
212 #monWrapper="/local00/home/A96028/GitEficasTravail/eficas/PSEN_Eficas/PSSEWrapper.py"
213 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
214 monWrapper = os.path.join(path1, 'PSSEWrapper.py')
215 cmd=['python',monWrapper]
217 w = ViewText2( self.QWParent, cmd )
218 w.setWindowTitle( "execution" )
222 #-------------------# Pour execution avec output et error dans le bash
224 #-------------------#
225 if self.modified or self.fichier==None : self.saveFile()
227 #lancement avec le .bat
228 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
229 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
231 p = subprocess.Popen(['python',WrapperFilePath])
232 (out,err)=p.communicate()
236 #--------------------------------#
237 def _newJDC( self ,units = None):
238 #--------------------------------#
240 Initialise un nouveau JDC vierge
243 CONTEXT.unset_current_step()
246 if self.code == "CARMELCND" : texte=self._newJDCCND()
247 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
248 if self.code == "TELEMAC" : texte=self._newTELEMAC()
249 if self.code == "PSEN" : texte = self._newPSEN()
250 # texte=self.newTexteCND
252 jdc=self.readercata.cata[0].JdC( procedure =texte,
254 cata=self.readercata.cata,
255 cata_ord_dico=self.readercata.cata_ordonne_dico,
256 rep_mat=self.CONFIGURATION.rep_mat
258 jdc.lang = self.appli.langue
259 if units is not None:
260 jdc.recorded_units=units
261 jdc.old_recorded_units=units
262 ## PNPN est ce que la ligne suivante est bien utile ?
263 if texte == "" :jdc.analyse()
266 #--------------------------------#
267 def _newJDCInclude( self ,units = None):
268 #--------------------------------#
270 Initialise un nouveau JDC vierge
272 import Extensions.jdc_include
273 JdC_aux=Extensions.jdc_include.JdC_include
274 CONTEXT.unset_current_step()
276 jaux=self.readercata.cata[0].JdC( procedure="",
278 cata=self.readercata.cata,
279 cata_ord_dico=self.readercata.cata_ordonne_dico,
280 rep_mat=self.CONFIGURATION.rep_mat,
284 J=JdC_aux( procedure="",
286 cata=self.readercata.cata,
287 cata_ord_dico=self.readercata.cata_ordonne_dico,
289 rep_mat=self.CONFIGURATION.rep_mat,
292 if units is not None:
293 J.recorded_units=units
294 J.old_recorded_units=units
298 #-------------------------------#
299 def readFile(self, fn):
300 #--------------------------------#
302 Public slot to read the text from a file.
303 @param fn filename to read from (string or QString)
307 # ------------------------------------------------------------------------------------
309 # ------------------------------------------------------------------------------------
311 jdcName=os.path.basename(fn)
312 # Il faut convertir le contenu du fichier en fonction du format
313 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
314 # Le convertisseur existe on l'utilise
316 p=convert.plugins[self.appliEficas.format_fichier_in]()
318 if p.text=="" : self.nouveau=1
319 pareil,texteNew=self.verifieCHECKSUM(p.text)
321 if pareil == False and (self.appliEficas.ssIhm == False) :
322 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
324 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
325 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
327 text=p.convert('exec',self.appliEficas)
328 if not p.cr.estvide():
329 self.affiche_infos("Erreur a la conversion",Qt.red)
331 self.affiche_infos("Type de fichier non reconnu",Qt.red)
332 if self.appliEficas.ssIhm == False:
333 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
334 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
337 CONTEXT.unset_current_step()
338 jdc=self.readercata.cata[0].JdC(procedure=text,
340 cata=self.readercata.cata,
341 cata_ord_dico=self.readercata.cata_ordonne_dico,
343 rep_mat=self.CONFIGURATION.rep_mat
345 # ----------------------------------------------------
347 # ----------------------------------------------------
348 self.modified = False
350 # qApp.restoreOverrideCursor()
351 if self.fileInfo!= None :
352 self.lastModified = self.fileInfo.lastModified()
354 self.lastModified = 1
355 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
356 self.appliEficas.setWindowTitle(nouveauTitre)
360 #-----------------------#
361 def get_source(self,file):
362 #-----------------------#
364 # Il faut convertir le contenu du fichier en fonction du format
365 if convert.plugins.has_key(self.format):
366 # Le convertisseur existe on l'utilise
367 p=convert.plugins[self.format]()
369 text=p.convert('execnoparseur')
370 if not p.cr.estvide():
371 self.affiche_infos("Erreur a la conversion",Qt.red)
374 # Il n'existe pas c'est une erreur
375 self.affiche_infos("Type de fichier non reconnu",Qt.red)
376 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
379 #-----------------------------------------------------------------------#
380 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
381 #--------------------------------------------------------------------#
382 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
386 #----------------------------------------------#
387 def __generateTempFilename(self, prefix, suffix):
388 #----------------------------------------------#
390 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
396 #----------------------------------------------#
397 def _viewTextExecute(self, txt, prefix, suffix):
398 #----------------------------------------------#
399 self.w = ViewText( self.QWParent )
400 self.w.setWindowTitle( "execution" )
401 self.monExe=QProcess(self.w)
402 pid=self.monExe.pid()
403 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
404 f=open(nomFichier,'w')
407 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
408 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
409 exe='sh ' + nomFichier
410 self.monExe.start(exe)
411 self.monExe.closeWriteChannel()
414 commande="rm "+ nomFichier
420 def readFromStdErr(self):
421 a=self.monExe.readAllStandardError()
422 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
424 def readFromStdOut(self) :
425 a=self.monExe.readAllStandardOutput()
426 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
430 #-----------------------#
431 def gestionParam(self):
432 #-----------------------#
433 w = MonWidgetCreeParam( self)
436 #-----------------------#
437 def viewJdcSource(self):
438 #-----------------------#
439 f=open(self.fichier,'r')
442 self._viewText(texteSource, "JDC_SOURCE")
444 #-----------------------#
446 #-----------------------#
447 strSource = str( self.get_text_JDC(self.format) )
448 self._viewText(strSource, "JDC_RESULTAT")
450 #-----------------------#
451 def viewJdcRapport(self):
452 #-----------------------#
453 strRapport = unicode( self.jdc.report() )
454 # on ajoute les regles
456 self._viewText(strRapport, "JDC_RAPPORT")
458 #-----------------------#
459 def viewJdcRegles(self):
460 #-----------------------#
461 if self.tree :self.tree.AppelleBuildLBRegles()
468 Public method called by the viewmanager to finally get rid of us.
474 #----------------------------------------------#
475 def affiche_infos(self,message,couleur=Qt.black):
476 #----------------------------------------------#
478 mapalette=self.sb.palette()
479 from PyQt4.QtGui import QPalette
480 mapalette.setColor( QPalette.WindowText, couleur )
481 self.sb.setPalette( mapalette );
482 self.sb.showMessage(QString.fromUtf8(message))#,2000)
484 #------------------------------#
485 def affiche_alerte(self,titre,message):
486 #------------------------------#
487 # appele par I_MACRO_ETAPE
488 QMessageBox.information( self, titre, message)
490 #-----------------------------------#
491 def affiche_commentaire(self,message):
492 #-----------------------------------#
493 self.labelCommentaire.setText(message)
495 #-------------------#
496 def init_modif(self):
497 #-------------------#
499 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
500 si un JDC doit etre sauvegarde avant destruction ou non
504 #---------------------------------------#
505 def chercheNoeudSelectionne(self,copie=1):
506 #---------------------------------------#
508 appele par Cut et Copy pour positionner self.node_selected
510 self.node_selected=[]
511 if len(self.tree.selectedItems()) == 0 : return
512 self.node_selected=self.tree.selectedItems()
515 #---------------------#
516 def handleSupprimer(self):
517 #---------------------#
518 self.chercheNoeudSelectionne()
519 if len(self.node_selected) == 0 : return
520 self.QWParent.noeud_a_editer = []
521 if self.node_selected[0]==self.tree.racine: return
522 if len(self.node_selected) == 1 : self.node_selected[0].delete()
523 else : self.node_selected[0].deleteMultiple(self.node_selected)
525 #---------------------#
526 def handleRechercher(self):
527 #---------------------#
528 from monRecherche import DRecherche
529 monRechercheDialg=DRecherche(parent=self,fl=0)
530 monRechercheDialg.show()
532 #---------------------#
533 def handleDeplier(self):
534 #---------------------#
535 if self.tree == None : return
536 #self.tree.collapseAll()
539 self.tree.expandItem(self.tree.topLevelItem(0))
541 if self.fenetreCentraleAffichee != None :
542 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
543 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
546 self.tree.expandItem(self.tree.topLevelItem(0))
548 if self.fenetreCentraleAffichee != None :
549 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
550 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
552 #---------------------#
553 def handleEditCut(self):
554 #---------------------#
556 Stocke dans Eficas.noeud_a_editer le noeud a couper
558 #print "handleEditCut"
559 self.chercheNoeudSelectionne()
560 self.QWParent.edit="couper"
561 self.QWParent.noeud_a_editer = self.node_selected
563 #-----------------------#
564 def handleEditCopy(self):
565 #-----------------------#
567 Stocke dans Eficas.noeud_a_editer le noeud a copier
569 self.chercheNoeudSelectionne()
570 if len(self.node_selected) == 0 : return
571 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
572 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
573 self.QWParent.edit="copier"
574 self.QWParent.noeud_a_editer = self.node_selected
576 #------------------------#
577 def handleEditPaste(self):
578 #------------------------#
580 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
581 Ne permet que la copie d'objets de type Commande ou MCF
583 self.chercheNoeudSelectionne()
584 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
585 QMessageBox.information( self,
586 tr("Copie impossible"),
587 tr("Veuillez selectionner un objet a copier"))
589 if len(self.node_selected) != 1 :
590 QMessageBox.information( self,
591 tr("Copie impossible"),
592 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
595 if len(self.QWParent.noeud_a_editer)!=1:
596 self.handleEditPasteMultiple()
599 noeudOuColler=self.node_selected[0]
601 if noeudOuColler == self.tree.racine:
605 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
608 noeudACopier=self.QWParent.noeud_a_editer[0]
609 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
611 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
614 if (self.QWParent.edit != "couper"):
616 if noeudOuColler == self.tree.racine :
617 child=noeudOuColler.doPastePremier(noeudACopier)
619 child=noeudACopier.doPaste(noeudOuColler,pos)
620 if child==None or child==0:
621 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
623 self.affiche_infos("Copie refusee",Qt.red)
624 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
626 nom=noeudACopier.item.sd.nom
627 child.item.nomme_sd(nom)
634 traceback.print_exc()
635 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
637 self.affiche_infos("Copie refusee",Qt.red)
640 # il faut declarer le JDCDisplay_courant modifie
641 # suppression eventuelle du noeud selectionne
642 # si possible on renomme l objet comme le noeud couper
644 if (self.QWParent.edit == "couper"):
646 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
647 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
651 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
652 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
653 noeudACopier.treeParent.build_children()
658 self.QWParent.noeud_a_editer=[]
660 # on rend la copie a nouveau possible en liberant le flag edit
661 self.QWParent.edit="copier"
662 noeudACopier.select()
664 #----------------------------------#
665 def handleDeplaceMultiple(self):
666 #----------------------------------#
669 #----------------------------------#
670 def handleEditPasteMultiple(self):
671 #----------------------------------#
673 # On ne garde que les niveaux "Etape"
674 # On insere dans l'ordre du JDC
675 listeNoeudsACouper=[]
679 from InterfaceQT4 import compojdc
680 noeudOuColler=self.node_selected[0]
681 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
682 QMessageBox.information( self,
683 tr("Copie impossible a cet endroit",),
684 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
686 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
688 for noeud in self.QWParent.noeud_a_editer :
689 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
690 indexInTree=noeud.treeParent.children.index(noeud)
692 for index in listeIndex:
693 if index < indexInTree : indice = indice +1
694 listeIndex.insert(indice, indexInTree)
695 listeNoeudsACouper.insert(indice, noeud)
697 noeudJdc=noeudOuColler.treeParent
699 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
701 for index in listeIndex:
703 if indexNoeudOuColler < index:
704 indexTravail=indexTravail+dejaCrees
705 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
706 noeud=noeudJdc.children[indexTravail]
707 child=noeud.doPaste(noeudOuColler)
708 listeChild.append(child)
709 dejaCrees=dejaCrees+1
711 self.QWParent.noeud_a_editer = []
712 for i in range(len(listeIndex)):
713 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
714 self.QWParent.noeud_a_editer.append(noeud)
717 if self.QWParent.edit !="couper" : return
719 for index in listeIndex:
721 if indexNoeudOuColler < index:
722 indexTravail=indexTravail+(len(listeIndex))
723 noeud=noeudJdc.children[indexTravail]
725 listeItem.append(noeud.item)
726 listeASupprimer.append(noeud)
728 for i in range(len(listeChild)):
729 self.tree.item.suppitem(listeItem[i])
730 listeChild[i].item.update(listeItem[i])
732 self.QWParent.noeud_a_editer = []
735 #---------------------#
736 def getFileName(self):
737 #---------------------#
740 #---------------------------#
741 def get_file_variable(self) :
742 #---------------------------#
743 titre = tr("Choix d'un fichier XML")
744 texte = tr("Le fichier contient une commande MODEL\n")
745 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
746 QMessageBox.information( self, titre,tr(texte))
748 fichier = QFileDialog.getOpenFileName(self.appliEficas,
749 tr('Ouvrir Fichier'),
750 self.appliEficas.CONFIGURATION.savedir,
751 self.appliEficas.trUtf8('Wrapper Files (*.xml);;''All Files (*)'))
754 #--------------------------------------------------#
755 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
756 #--------------------------------------------------#
758 Public slot to write the text to a file.
760 @param fn filename to write to (string or QString)
761 @return flag indicating success
767 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
769 if len(txt) >= len(eol):
770 if txt[-len(eol):] != eol:
774 txt=self.ajoutVersionCataDsJDC(txt)
775 checksum=self.get_checksum(txt)
783 QMessageBox.critical(self, self.trUtf8('Save File'),
784 self.trUtf8('The file <b>%1</b> could not be saved.<br>Reason: %2')
785 .arg(unicode(fn)).arg(str(why)))
788 #-----------------------------------------------------------#
789 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
790 #-----------------------------------------------------------#
791 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
792 if generator.plugins.has_key(format):
794 # Le generateur existe on l'utilise
795 self.generator=generator.plugins[format]()
797 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION)
798 if pourRun : jdc_formate=self.generator.textePourRun
800 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
801 if not self.generator.cr.estvide():
802 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
803 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
808 # Il n'existe pas c'est une erreur
809 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
810 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
816 fonction="run"+self.code
817 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
822 fonction="saveRun"+self.code
823 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
829 if not(self.jdc.isvalid()):
830 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
832 if len(self.jdc.etapes) != 1 :
833 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
835 if self.modified or self.fichier==None :
836 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
837 texte=self.get_text_JDC("MAP")
838 self.writeFile( self.fichierMapInput, txt = texte)
840 self.fichierMapInput=self.fichier
841 composant=self.jdc.etapes[0].nom.lower()[0:-5]
844 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
845 # then instantiate corresponding class and call getUseSalome() method
847 from mapengine.spec import factory
848 mapComponent = factory.new(composant)[0]
851 if mapComponent.getUseSalome():
852 command += " -r sappli"
853 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
856 self._viewTextExecute( textePython,"map_run",".sh")
858 # commande="rm "+self.fichierMapInput
859 # os.system(commande)
863 print traceback.print_exc()
865 #-------------------#
866 def runZCRACKS(self):
867 #-------------------#
868 if not(self.jdc.isvalid()):
869 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
871 if self.modified or self.fichier==None :
873 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
874 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
875 self.writeFile( self.fichierZcracksInput, txt = texte)
877 self.fichierZcracksInput=self.fichier
879 #commande ="Zrun -zp "
881 textePython=(commande + self.fichierZcracksInput)
882 self._viewTextExecute( textePython,"run_zcracks",".sh")
884 print traceback.print_exc()
886 #-------------------#
887 def runCARMELCND(self):
888 #-------------------#
889 #if not(self.jdc.isvalid()):
890 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
892 if self.modified or self.fichier==None :
893 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
895 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
896 from PrepareRunCarmel import prepareRunCarmel
897 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
898 repMed=os.path.dirname(self.fichier)
899 repExeCarmel=self.generator.get_repExeCarmel()
900 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
901 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
902 f=open(nomFichier,'w')
905 commande="xterm -e sh "+nomFichier +"\n"
908 # self._viewTextExecute( textePython,"carmel_run",".sh")
909 #except Exception, e:
910 # print traceback.print_exc()
912 #-------------------#
913 def runCarmelCS(self):
914 #-------------------#
916 commande="runSession pilotyacsCS.py"
919 print traceback.print_exc()
921 #-----------------------------------------------------#
922 def determineNomFichier(self,path,extension):
923 #-----------------------------------------------------#
924 if DictExtensions.has_key(self.appli.code) :
925 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
926 extensions= self.trUtf8(chaine1+ "All Files (*)")
928 extensions= self.trUtf8("JDC (*.comm);;" "All Files (*)")
930 if self.appli.code == "MAP" :
931 extensions = extensions + ";; Run (*.input);;"
933 fn = QFileDialog.getSaveFileName( self,
934 tr("sauvegarde"), path,
936 QFileDialog.DontConfirmOverwrite)
937 if fn.isNull(): return (0, None)
938 ext = QFileInfo(fn).suffix()
939 if ext.isEmpty(): fn.append(extension)
941 if QFileInfo(fn).exists():
942 abort = QMessageBox.warning(self,
943 tr("Sauvegarde du Fichier"),
944 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
946 self.trUtf8("&Abandonner"))
947 if abort == 1 : return (0, "")
951 def saveRunMAP(self):
954 if not(self.jdc.isvalid()):
955 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
956 tr("Un JdC valide est necessaire pour creer un .input")
960 composant=self.jdc.etapes[0].nom.lower()[0:-5]
962 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
963 tr("Choix du composant obligatoire")
966 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
970 if self.fichier is not None and self.fichier != "" :
971 maBase=str(QFileInfo(self.fichier).baseName())+".input"
972 monPath=str(QFileInfo(self.fichier).absolutePath())
973 monNomFichier=os.path.join(monPath,maBase)
974 elif hasattr(self,'monNomFichierInput'):
975 monNomFichier=self.monNomFichierInput
978 monDialog=QFileDialog(self.appliEficas)
979 monDialog.setDirectory (path)
980 monDialog.setWindowTitle ("Save")
982 for c in monDialog.children():
983 if isinstance(c,QDialogButtonBox):
984 for b in c.children():
985 if isinstance(b,QPushButton):
987 if avant.toLatin1()=="&Open":
989 mesFiltres=QStringList()
990 mesFiltres << "input Map (*.input)" << "All Files (*)"
991 monDialog.setNameFilters(mesFiltres)
992 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
993 BOk=monDialog.exec_()
995 fn=str(monDialog.selectedFiles()[0].toLatin1())
996 if fn == "" or fn == None : return
997 if not fn.endswith(".input"):
999 self.monNomFichierInput=fn
1001 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1002 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1003 texte=self.get_text_JDC("MAP")
1004 self.writeFile( self.fichierMapInput, txt = texte)
1006 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1007 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1008 (output, err) = p.communicate()
1012 def saveRunPSEN(self):
1017 if not(self.jdc.isvalid()):
1018 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1019 tr("Un JdC valide est necessaire pour creer un .input")
1023 print generator.plugins.has_key(self.format)
1024 if generator.plugins.has_key(self.format):
1025 # Le generateur existe on l'utilise
1026 self.generator=generator.plugins[self.format]()
1028 self.generator.gener(self.jdc)
1029 self.generator.writeDefault('')
1030 except ValueError,e:
1031 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1032 if not self.generator.cr.estvide():
1033 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1034 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1037 # Il n'existe pas c'est une erreur
1038 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1039 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1046 #-----------------------------------------#
1047 def cherche_Groupes(self):
1048 #-----------------------------------------#
1049 listeMA,listeNO=self.get_text_JDC("GroupMA")
1050 return listeMA,listeNO
1052 #-----------------------------------------#
1053 def cherche_Dico(self):
1054 #-----------------------------------------#
1056 format = self.appliEficas.format_fichier
1057 if generator.plugins.has_key(format):
1058 # Le generateur existe on l'utilise
1059 self.generator=generator.plugins[format]()
1060 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1061 dicoCourant=self.generator.dico
1066 #-----------------------------------------#
1067 def handleAjoutGroup(self,listeGroup):
1068 #-----------------------------------------#
1071 from ajoutGroupe import handleAjoutGroupFiltre
1073 handleAjoutGroupFiltre(self,listeGroup)
1074 #print "apres handleAjoutGroupFiltre"
1079 #-----------------------------------------------------------------#
1080 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1081 #-----------------------------------------------------------------#
1083 Public slot to save the text to a file.
1085 @param path directory to save the file in (string or QString)
1086 @return tuple of two values (boolean, string) giving a success indicator and
1087 the name of the saved file
1091 if not self.modified and not saveas:
1092 return (0, None) # do nothing if text wasn't changed
1095 if DictExtensions.has_key(self.appli.code) :
1096 extension=DictExtensions[self.appli.code]
1102 if self.fichier is None or saveas:
1104 path=self.CONFIGURATION.savedir
1105 bOK, fn=self.determineNomFichier(path,extension)
1106 if bOK == 0 : return (0, None)
1107 if fn == None : return (0, None)
1108 if fn.isNull(): return (0, None)
1110 ulfile = os.path.abspath(unicode(fn))
1111 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1112 fn = unicode(QDir.convertSeparators(fn))
1116 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1118 self.modified = False
1119 if self.fileInfo is None or saveas:
1120 self.fileInfo = QFileInfo(self.fichier)
1121 self.fileInfo.setCaching(0)
1122 self.lastModified = self.fileInfo.lastModified()
1123 if newName is not None:
1124 self.appliEficas.addToRecentList(newName)
1125 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1126 self.tree.racine.update_node_label()
1128 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1129 self.generator.writeDefault(fn)
1132 self.appliEficas.addJdcInSalome( self.fichier)
1134 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1135 self.appliEficas.setWindowTitle(nouveauTitre)
1137 return (1, self.fichier)
1140 #----------------------------------------------#
1141 def sauveLigneFile(self):
1142 #----------------------------------------------#
1144 return self.saveFile(formatLigne="Ligne")
1147 #----------------------------------------------#
1148 def saveFileAs(self, path = None,fileName=None):
1149 #----------------------------------------------#
1151 Public slot to save a file with a new name.
1153 @param path directory to save the file in (string or QString)
1154 @return tuple of two values (boolean, string) giving a success indicator and
1155 the name of the saved file
1157 if fileName != None :
1158 self.fichier = fileName
1159 return self.saveFile()
1160 return self.saveFile(path,1,"beautifie")
1164 #---------------------------------------------#
1165 def get_file(self,unite=None,fic_origine = ''):
1166 #---------------------------------------------#
1174 titre = tr("Choix unite %d ", unite)
1175 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1176 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1177 labeltexte = tr('Fichier pour unite ') + repr( unite)
1179 titre = tr("Choix d'un fichier de poursuite")
1180 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1181 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1183 QMessageBox.information( self, titre,QString.fromUtf8(texte))
1184 fn = QFileDialog.getOpenFileName(self.appliEficas,
1186 self.appliEficas.CONFIGURATION.savedir)
1189 # ce retour est impose par le get_file d'I_JDC
1192 ulfile = os.path.abspath(unicode(fn))
1193 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1195 # On utilise le convertisseur defini par format_fichier
1196 source=self.get_source(ulfile)
1198 # On a reussia convertir le fichier self.ulfile
1201 # Une erreur a ete rencontree
1203 return ulfile, jdcText
1205 #-------------------------------#
1206 def updateJdc(self, itemApres,texte):
1207 #--------------------------------#
1209 etape=monItem.item.object
1211 CONTEXT.set_current_step(etape)
1212 etape.build_includeInclude(texte)
1213 self.tree.racine.build_children()
1218 #-------------------------------------#
1219 def ajoutVersionCataDsJDC(self,txt):
1220 #-------------------------------------#
1221 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1222 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1223 texte=txt+ligneVersion
1226 #-------------------------------------#
1227 def verifieVersionCataDuJDC(self,text):
1228 #-------------------------------------#
1230 indexDeb=text.find("#VERSION_CATALOGUE:")
1231 indexFin=text.find(":FIN VERSION_CATALOGUE")
1233 self.versionCataDuJDC="sans"
1236 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1237 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1239 self.versionCata="sans"
1240 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1242 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1243 return memeVersion,textJDC
1245 #-------------------------------#
1246 def traduitCatalogue(self,texte):
1247 #-------------------------------#
1248 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1249 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1251 traducteur=__import__(nomTraducteur)
1252 monTraducteur=traducteur.MonTraducteur(texte)
1253 nouveauTexte=monTraducteur.traduit()
1259 #------------------------------#
1260 def verifieCHECKSUM(self,text):
1261 #------------------------------#
1262 indexDeb=text.find("#CHECKSUM:")
1265 indexFin=text.find(":FIN CHECKSUM")
1266 checkAvant=text[indexDeb:indexFin+13]
1267 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1268 checksum=self.get_checksum(textJDC)
1269 pareil=(checkAvant==checksum)
1270 return pareil, textJDC
1272 #---------------------------#
1273 def get_checksum(self,texte):
1274 #---------------------------#
1275 newtexte=texte.replace('"','\\"')
1276 commande='echo "'+newtexte+'"|md5sum'
1277 a=os.popen(commande)
1280 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1284 #---------------------------#
1285 def _newTELEMAC(self):
1286 #---------------------------#
1287 texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1291 #---------------------------#
1293 #---------------------------#
1294 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1298 #---------------------------#
1300 #---------------------------#
1301 def _newZCRACKS(self):
1302 #---------------------------#
1303 texte="MAILLAGES();REMESHING();"
1306 #---------------------------#
1307 def _newJDCCND(self):
1308 #---------------------------#
1309 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1311 #if self.salome == 0 :
1312 QMessageBox.information( self,
1314 tr("Veuillez selectionner un fichier Med"))
1315 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1316 caption='Fichier Med',
1318 self.fichierMED=str(QSfichier.toLatin1())
1319 from acquiertGroupes import getGroupes
1320 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1321 if erreur != "" : print "a traiter"
1322 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1328 for groupe in self.listeGroupes :
1329 if groupe[0:8]=='CURRENT_':
1330 texteSources +=groupe[8:]+"=SOURCE("
1331 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1332 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1333 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1334 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1335 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1336 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1337 self.newTexteCND=texte
1342 #---------------------------#
1343 def BoutonFileSelected(self):
1344 #---------------------------#
1346 QSfichier=self.openfile.selectedFiles()[0]
1347 self.fichierMED=str(QSfichier.toLatin1())
1348 from acquiertGroupes import getGroupes
1349 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1350 if erreur != "" : print "a traiter"
1352 #-----------------------------
1353 def BoutonSalomePressed(self):
1354 #----------------------------
1355 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1356 self.fichierMED="A_partir_de_SMESH"
1357 self.nomMaillage="A_partir_de_SMESH"
1358 self.openfile.close()
1361 if __name__ == "__main__":
1363 name='prefs_'+prefs.code
1364 prefsCode=__import__(name)
1367 if hasattr(prefsCode,'encoding'):
1368 # Hack pour changer le codage par defaut des strings
1371 sys.setdefaultencoding(prefs.encoding)
1372 del sys.setdefaultencoding
1377 app = QApplication(sys.argv)
1378 mw = JDCEditor(None,'azAster.comm')
1379 app.setMainWidget(mw)
1380 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1383 res = app.exec_loop()