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 :
226 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
229 #lancement avec le .bat
230 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
231 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
233 p = subprocess.Popen(['python',WrapperFilePath])
234 (out,err)=p.communicate()
238 #--------------------------------#
239 def _newJDC( self ,units = None):
240 #--------------------------------#
242 Initialise un nouveau JDC vierge
245 CONTEXT.unset_current_step()
248 if self.code == "CARMELCND" : texte=self._newJDCCND()
249 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
250 if self.code == "TELEMAC" : texte=self._newTELEMAC()
251 if self.code == "PSEN" : texte = self._newPSEN()
252 # texte=self.newTexteCND
254 jdc=self.readercata.cata[0].JdC( procedure =texte,
256 cata=self.readercata.cata,
257 cata_ord_dico=self.readercata.cata_ordonne_dico,
258 rep_mat=self.CONFIGURATION.rep_mat
260 jdc.lang = self.appli.langue
261 if units is not None:
262 jdc.recorded_units=units
263 jdc.old_recorded_units=units
264 ## PNPN est ce que la ligne suivante est bien utile ?
265 if texte == "" :jdc.analyse()
268 #--------------------------------#
269 def _newJDCInclude( self ,units = None):
270 #--------------------------------#
272 Initialise un nouveau JDC vierge
274 import Extensions.jdc_include
275 JdC_aux=Extensions.jdc_include.JdC_include
276 CONTEXT.unset_current_step()
278 jaux=self.readercata.cata[0].JdC( procedure="",
280 cata=self.readercata.cata,
281 cata_ord_dico=self.readercata.cata_ordonne_dico,
282 rep_mat=self.CONFIGURATION.rep_mat,
286 J=JdC_aux( procedure="",
288 cata=self.readercata.cata,
289 cata_ord_dico=self.readercata.cata_ordonne_dico,
291 rep_mat=self.CONFIGURATION.rep_mat,
294 if units is not None:
295 J.recorded_units=units
296 J.old_recorded_units=units
300 #-------------------------------#
301 def readFile(self, fn):
302 #--------------------------------#
304 Public slot to read the text from a file.
305 @param fn filename to read from (string or QString)
309 # ------------------------------------------------------------------------------------
311 # ------------------------------------------------------------------------------------
313 jdcName=os.path.basename(fn)
314 # Il faut convertir le contenu du fichier en fonction du format
315 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
316 # Le convertisseur existe on l'utilise
318 p=convert.plugins[self.appliEficas.format_fichier_in]()
320 if p.text=="" : self.nouveau=1
321 pareil,texteNew=self.verifieCHECKSUM(p.text)
323 if pareil == False and (self.appliEficas.ssIhm == False) :
324 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
326 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
327 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
329 text=p.convert('exec',self.appliEficas)
330 if not p.cr.estvide():
331 self.affiche_infos("Erreur a la conversion",Qt.red)
333 self.affiche_infos("Type de fichier non reconnu",Qt.red)
334 if self.appliEficas.ssIhm == False:
335 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
336 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
339 CONTEXT.unset_current_step()
340 jdc=self.readercata.cata[0].JdC(procedure=text,
342 cata=self.readercata.cata,
343 cata_ord_dico=self.readercata.cata_ordonne_dico,
345 rep_mat=self.CONFIGURATION.rep_mat
347 # ----------------------------------------------------
349 # ----------------------------------------------------
350 self.modified = False
352 # qApp.restoreOverrideCursor()
353 if self.fileInfo!= None :
354 self.lastModified = self.fileInfo.lastModified()
356 self.lastModified = 1
357 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
358 self.appliEficas.setWindowTitle(nouveauTitre)
362 #-----------------------#
363 def get_source(self,file):
364 #-----------------------#
366 # Il faut convertir le contenu du fichier en fonction du format
367 if convert.plugins.has_key(self.format):
368 # Le convertisseur existe on l'utilise
369 p=convert.plugins[self.format]()
371 text=p.convert('execnoparseur')
372 if not p.cr.estvide():
373 self.affiche_infos("Erreur a la conversion",Qt.red)
376 # Il n'existe pas c'est une erreur
377 self.affiche_infos("Type de fichier non reconnu",Qt.red)
378 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
381 #-----------------------------------------------------------------------#
382 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
383 #--------------------------------------------------------------------#
384 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
388 #----------------------------------------------#
389 def __generateTempFilename(self, prefix, suffix):
390 #----------------------------------------------#
392 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
398 #----------------------------------------------#
399 def _viewTextExecute(self, txt, prefix, suffix):
400 #----------------------------------------------#
401 self.w = ViewText( self.QWParent )
402 self.w.setWindowTitle( "execution" )
403 self.monExe=QProcess(self.w)
404 pid=self.monExe.pid()
405 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
406 f=open(nomFichier,'w')
409 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
410 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
411 exe='sh ' + nomFichier
412 self.monExe.start(exe)
413 self.monExe.closeWriteChannel()
416 commande="rm "+ nomFichier
422 def readFromStdErr(self):
423 a=self.monExe.readAllStandardError()
424 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
426 def readFromStdOut(self) :
427 a=self.monExe.readAllStandardOutput()
428 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
432 #-----------------------#
433 def gestionParam(self):
434 #-----------------------#
435 w = MonWidgetCreeParam( self)
438 #-----------------------#
439 def viewJdcSource(self):
440 #-----------------------#
441 f=open(self.fichier,'r')
444 self._viewText(texteSource, "JDC_SOURCE")
446 #-----------------------#
448 #-----------------------#
449 strSource = str( self.get_text_JDC(self.format) )
450 self._viewText(strSource, "JDC_RESULTAT")
452 #-----------------------#
453 def viewJdcRapport(self):
454 #-----------------------#
455 strRapport = unicode( self.jdc.report() )
456 # on ajoute les regles
458 self._viewText(strRapport, "JDC_RAPPORT")
460 #-----------------------#
461 def viewJdcRegles(self):
462 #-----------------------#
463 if self.tree :self.tree.AppelleBuildLBRegles()
470 Public method called by the viewmanager to finally get rid of us.
476 #----------------------------------------------#
477 def affiche_infos(self,message,couleur=Qt.black):
478 #----------------------------------------------#
480 mapalette=self.sb.palette()
481 from PyQt4.QtGui import QPalette
482 mapalette.setColor( QPalette.WindowText, couleur )
483 self.sb.setPalette( mapalette );
484 self.sb.showMessage(QString.fromUtf8(message))#,2000)
486 #------------------------------#
487 def affiche_alerte(self,titre,message):
488 #------------------------------#
489 # appele par I_MACRO_ETAPE
490 QMessageBox.information( self, titre, message)
492 #-----------------------------------#
493 def affiche_commentaire(self,message):
494 #-----------------------------------#
495 self.labelCommentaire.setText(message)
497 #-------------------#
498 def init_modif(self):
499 #-------------------#
501 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
502 si un JDC doit etre sauvegarde avant destruction ou non
506 #---------------------------------------#
507 def chercheNoeudSelectionne(self,copie=1):
508 #---------------------------------------#
510 appele par Cut et Copy pour positionner self.node_selected
512 self.node_selected=[]
513 if len(self.tree.selectedItems()) == 0 : return
514 self.node_selected=self.tree.selectedItems()
517 #---------------------#
518 def handleSupprimer(self):
519 #---------------------#
520 self.chercheNoeudSelectionne()
521 if len(self.node_selected) == 0 : return
522 self.QWParent.noeud_a_editer = []
523 if self.node_selected[0]==self.tree.racine: return
524 if len(self.node_selected) == 1 : self.node_selected[0].delete()
525 else : self.node_selected[0].deleteMultiple(self.node_selected)
527 #---------------------#
528 def handleRechercher(self):
529 #---------------------#
530 from monRecherche import DRecherche
531 monRechercheDialg=DRecherche(parent=self,fl=0)
532 monRechercheDialg.show()
534 #---------------------#
535 def handleDeplier(self):
536 #---------------------#
538 if self.tree == None : return
539 #self.tree.collapseAll()
542 self.tree.expandItem(self.tree.topLevelItem(0))
544 if self.fenetreCentraleAffichee != None :
545 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
546 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
549 self.tree.expandItem(self.tree.topLevelItem(0))
551 if self.fenetreCentraleAffichee != None :
552 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
553 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
555 #---------------------#
556 def handleEditCut(self):
557 #---------------------#
559 Stocke dans Eficas.noeud_a_editer le noeud a couper
561 #print "handleEditCut"
562 self.chercheNoeudSelectionne()
563 self.QWParent.edit="couper"
564 self.QWParent.noeud_a_editer = self.node_selected
566 #-----------------------#
567 def handleEditCopy(self):
568 #-----------------------#
570 Stocke dans Eficas.noeud_a_editer le noeud a copier
572 self.chercheNoeudSelectionne()
573 if len(self.node_selected) == 0 : return
574 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
575 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
576 self.QWParent.edit="copier"
577 self.QWParent.noeud_a_editer = self.node_selected
579 #------------------------#
580 def handleEditPaste(self):
581 #------------------------#
583 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
584 Ne permet que la copie d'objets de type Commande ou MCF
586 self.chercheNoeudSelectionne()
587 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
588 QMessageBox.information( self,
589 tr("Copie impossible"),
590 tr("Veuillez selectionner un objet a copier"))
592 if len(self.node_selected) != 1 :
593 QMessageBox.information( self,
594 tr("Copie impossible"),
595 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
598 if len(self.QWParent.noeud_a_editer)!=1:
599 self.handleEditPasteMultiple()
602 noeudOuColler=self.node_selected[0]
604 if noeudOuColler == self.tree.racine:
608 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
611 noeudACopier=self.QWParent.noeud_a_editer[0]
612 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
614 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
617 if (self.QWParent.edit != "couper"):
619 if noeudOuColler == self.tree.racine :
620 child=noeudOuColler.doPastePremier(noeudACopier)
622 child=noeudACopier.doPaste(noeudOuColler,pos)
623 if child==None or child==0:
624 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
626 self.affiche_infos("Copie refusee",Qt.red)
627 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
629 nom=noeudACopier.item.sd.nom
630 child.item.nomme_sd(nom)
637 traceback.print_exc()
638 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
640 self.affiche_infos("Copie refusee",Qt.red)
643 # il faut declarer le JDCDisplay_courant modifie
644 # suppression eventuelle du noeud selectionne
645 # si possible on renomme l objet comme le noeud couper
647 if (self.QWParent.edit == "couper"):
649 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
650 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
654 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
655 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
656 noeudACopier.treeParent.build_children()
661 self.QWParent.noeud_a_editer=[]
663 # on rend la copie a nouveau possible en liberant le flag edit
664 self.QWParent.edit="copier"
665 noeudACopier.select()
667 #----------------------------------#
668 def handleDeplaceMultiple(self):
669 #----------------------------------#
672 #----------------------------------#
673 def handleEditPasteMultiple(self):
674 #----------------------------------#
676 # On ne garde que les niveaux "Etape"
677 # On insere dans l'ordre du JDC
678 listeNoeudsACouper=[]
682 from InterfaceQT4 import compojdc
683 noeudOuColler=self.node_selected[0]
684 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
685 QMessageBox.information( self,
686 tr("Copie impossible a cet endroit",),
687 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
689 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
691 for noeud in self.QWParent.noeud_a_editer :
692 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
693 indexInTree=noeud.treeParent.children.index(noeud)
695 for index in listeIndex:
696 if index < indexInTree : indice = indice +1
697 listeIndex.insert(indice, indexInTree)
698 listeNoeudsACouper.insert(indice, noeud)
700 noeudJdc=noeudOuColler.treeParent
702 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
704 for index in listeIndex:
706 if indexNoeudOuColler < index:
707 indexTravail=indexTravail+dejaCrees
708 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
709 noeud=noeudJdc.children[indexTravail]
710 child=noeud.doPaste(noeudOuColler)
711 listeChild.append(child)
712 dejaCrees=dejaCrees+1
714 self.QWParent.noeud_a_editer = []
715 for i in range(len(listeIndex)):
716 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
717 self.QWParent.noeud_a_editer.append(noeud)
720 if self.QWParent.edit !="couper" : return
722 for index in listeIndex:
724 if indexNoeudOuColler < index:
725 indexTravail=indexTravail+(len(listeIndex))
726 noeud=noeudJdc.children[indexTravail]
728 listeItem.append(noeud.item)
729 listeASupprimer.append(noeud)
731 for i in range(len(listeChild)):
732 self.tree.item.suppitem(listeItem[i])
733 listeChild[i].item.update(listeItem[i])
735 self.QWParent.noeud_a_editer = []
738 #---------------------#
739 def getFileName(self):
740 #---------------------#
743 #---------------------------#
744 def get_file_variable(self) :
745 #---------------------------#
746 titre = tr("Choix d'un fichier XML")
747 texte = tr("Le fichier contient une commande MODEL\n")
748 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
749 QMessageBox.information( self, titre,tr(texte))
751 fichier = QFileDialog.getOpenFileName(self.appliEficas,
752 tr('Ouvrir Fichier'),
753 self.appliEficas.CONFIGURATION.savedir,
754 self.appliEficas.trUtf8('Wrapper Files (*.xml);;''All Files (*)'))
757 #--------------------------------------------------#
758 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
759 #--------------------------------------------------#
761 Public slot to write the text to a file.
763 @param fn filename to write to (string or QString)
764 @return flag indicating success
770 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
772 if len(txt) >= len(eol):
773 if txt[-len(eol):] != eol:
777 txt=self.ajoutVersionCataDsJDC(txt)
778 checksum=self.get_checksum(txt)
786 QMessageBox.critical(self, self.trUtf8('Save File'),
787 self.trUtf8('The file <b>%1</b> could not be saved.<br>Reason: %2')
788 .arg(unicode(fn)).arg(str(why)))
791 #-----------------------------------------------------------#
792 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
793 #-----------------------------------------------------------#
794 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
795 if generator.plugins.has_key(format):
797 # Le generateur existe on l'utilise
798 self.generator=generator.plugins[format]()
800 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION)
801 if pourRun : jdc_formate=self.generator.textePourRun
803 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
804 if not self.generator.cr.estvide():
805 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
806 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
811 # Il n'existe pas c'est une erreur
812 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
813 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
819 fonction="run"+self.code
820 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
825 fonction="saveRun"+self.code
826 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
832 if not(self.jdc.isvalid()):
833 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
835 if len(self.jdc.etapes) != 1 :
836 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
838 if self.modified or self.fichier==None :
839 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
840 texte=self.get_text_JDC("MAP")
841 self.writeFile( self.fichierMapInput, txt = texte)
843 self.fichierMapInput=self.fichier
844 composant=self.jdc.etapes[0].nom.lower()[0:-5]
847 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
848 # then instantiate corresponding class and call getUseSalome() method
850 from mapengine.spec import factory
851 mapComponent = factory.new(composant)[0]
854 if mapComponent.getUseSalome():
855 command += " -r sappli"
856 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
859 self._viewTextExecute( textePython,"map_run",".sh")
861 # commande="rm "+self.fichierMapInput
862 # os.system(commande)
866 print traceback.print_exc()
868 #-------------------#
869 def runZCRACKS(self):
870 #-------------------#
871 if not(self.jdc.isvalid()):
872 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
874 if self.modified or self.fichier==None :
876 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
877 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
878 self.writeFile( self.fichierZcracksInput, txt = texte)
880 self.fichierZcracksInput=self.fichier
882 #commande ="Zrun -zp "
884 textePython=(commande + self.fichierZcracksInput)
885 self._viewTextExecute( textePython,"run_zcracks",".sh")
887 print traceback.print_exc()
889 #-------------------#
890 def runCARMELCND(self):
891 #-------------------#
892 #if not(self.jdc.isvalid()):
893 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
895 if self.modified or self.fichier==None :
896 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
898 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
899 from PrepareRunCarmel import prepareRunCarmel
900 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
901 repMed=os.path.dirname(self.fichier)
902 repExeCarmel=self.generator.get_repExeCarmel()
903 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
904 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
905 f=open(nomFichier,'w')
908 commande="xterm -e sh "+nomFichier +"\n"
911 # self._viewTextExecute( textePython,"carmel_run",".sh")
912 #except Exception, e:
913 # print traceback.print_exc()
915 #-------------------#
916 def runCarmelCS(self):
917 #-------------------#
919 commande="runSession pilotyacsCS.py"
922 print traceback.print_exc()
924 #-----------------------------------------------------#
925 def determineNomFichier(self,path,extension):
926 #-----------------------------------------------------#
927 if DictExtensions.has_key(self.appli.code) :
928 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
929 extensions= self.trUtf8(chaine1+ "All Files (*)")
931 extensions= self.trUtf8("JDC (*.comm);;" "All Files (*)")
933 if self.appli.code == "MAP" :
934 extensions = extensions + ";; Run (*.input);;"
936 fn = QFileDialog.getSaveFileName( self,
937 tr("sauvegarde"), path,
939 QFileDialog.DontConfirmOverwrite)
940 if fn.isNull(): return (0, None)
941 ext = QFileInfo(fn).suffix()
942 if ext.isEmpty(): fn.append(extension)
944 if QFileInfo(fn).exists():
945 abort = QMessageBox.warning(self,
946 tr("Sauvegarde du Fichier"),
947 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
949 self.trUtf8("&Abandonner"))
950 if abort == 1 : return (0, "")
954 def saveRunMAP(self):
957 if not(self.jdc.isvalid()):
958 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
959 tr("Un JdC valide est necessaire pour creer un .input")
963 composant=self.jdc.etapes[0].nom.lower()[0:-5]
965 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
966 tr("Choix du composant obligatoire")
969 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
973 if self.fichier is not None and self.fichier != "" :
974 maBase=str(QFileInfo(self.fichier).baseName())+".input"
975 monPath=str(QFileInfo(self.fichier).absolutePath())
976 monNomFichier=os.path.join(monPath,maBase)
977 elif hasattr(self,'monNomFichierInput'):
978 monNomFichier=self.monNomFichierInput
981 monDialog=QFileDialog(self.appliEficas)
982 monDialog.setDirectory (path)
983 monDialog.setWindowTitle ("Save")
985 for c in monDialog.children():
986 if isinstance(c,QDialogButtonBox):
987 for b in c.children():
988 if isinstance(b,QPushButton):
990 if avant.toLatin1()=="&Open":
992 mesFiltres=QStringList()
993 mesFiltres << "input Map (*.input)" << "All Files (*)"
994 monDialog.setNameFilters(mesFiltres)
995 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
996 BOk=monDialog.exec_()
998 fn=str(monDialog.selectedFiles()[0].toLatin1())
999 if fn == "" or fn == None : return
1000 if not fn.endswith(".input"):
1002 self.monNomFichierInput=fn
1004 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1005 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1006 texte=self.get_text_JDC("MAP")
1007 self.writeFile( self.fichierMapInput, txt = texte)
1009 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1010 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1011 (output, err) = p.communicate()
1015 def saveRunPSEN(self):
1020 if not(self.jdc.isvalid()):
1021 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1022 tr("Un JdC valide est necessaire pour creer un .input")
1026 print generator.plugins.has_key(self.format)
1027 if generator.plugins.has_key(self.format):
1028 # Le generateur existe on l'utilise
1029 self.generator=generator.plugins[self.format]()
1031 self.generator.gener(self.jdc)
1032 self.generator.writeDefault('')
1033 except ValueError,e:
1034 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1035 if not self.generator.cr.estvide():
1036 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1037 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1040 # Il n'existe pas c'est une erreur
1041 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1042 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1049 #-----------------------------------------#
1050 def cherche_Groupes(self):
1051 #-----------------------------------------#
1052 listeMA,listeNO=self.get_text_JDC("GroupMA")
1053 return listeMA,listeNO
1055 #-----------------------------------------#
1056 def cherche_Dico(self):
1057 #-----------------------------------------#
1059 format = self.appliEficas.format_fichier
1060 if generator.plugins.has_key(format):
1061 # Le generateur existe on l'utilise
1062 self.generator=generator.plugins[format]()
1063 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1064 dicoCourant=self.generator.dico
1069 #-----------------------------------------#
1070 def handleAjoutGroup(self,listeGroup):
1071 #-----------------------------------------#
1074 from ajoutGroupe import handleAjoutGroupFiltre
1076 handleAjoutGroupFiltre(self,listeGroup)
1077 #print "apres handleAjoutGroupFiltre"
1082 #-----------------------------------------------------------------#
1083 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1084 #-----------------------------------------------------------------#
1086 Public slot to save the text to a file.
1088 @param path directory to save the file in (string or QString)
1089 @return tuple of two values (boolean, string) giving a success indicator and
1090 the name of the saved file
1094 if not self.modified and not saveas:
1095 return (0, None) # do nothing if text wasn't changed
1098 if DictExtensions.has_key(self.appli.code) :
1099 extension=DictExtensions[self.appli.code]
1105 if self.fichier is None or saveas:
1107 path=self.CONFIGURATION.savedir
1108 bOK, fn=self.determineNomFichier(path,extension)
1109 if bOK == 0 : return (0, None)
1110 if fn == None : return (0, None)
1111 if fn.isNull(): return (0, None)
1113 ulfile = os.path.abspath(unicode(fn))
1114 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1115 fn = unicode(QDir.convertSeparators(fn))
1119 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1121 self.modified = False
1122 if self.fileInfo is None or saveas:
1123 self.fileInfo = QFileInfo(self.fichier)
1124 self.fileInfo.setCaching(0)
1125 self.lastModified = self.fileInfo.lastModified()
1126 if newName is not None:
1127 self.appliEficas.addToRecentList(newName)
1128 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1129 self.tree.racine.update_node_label()
1131 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1132 self.generator.writeDefault(fn)
1135 self.appliEficas.addJdcInSalome( self.fichier)
1137 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1138 self.appliEficas.setWindowTitle(nouveauTitre)
1140 return (1, self.fichier)
1143 #----------------------------------------------#
1144 def sauveLigneFile(self):
1145 #----------------------------------------------#
1147 return self.saveFile(formatLigne="Ligne")
1150 #----------------------------------------------#
1151 def saveFileAs(self, path = None,fileName=None):
1152 #----------------------------------------------#
1154 Public slot to save a file with a new name.
1156 @param path directory to save the file in (string or QString)
1157 @return tuple of two values (boolean, string) giving a success indicator and
1158 the name of the saved file
1160 if fileName != None :
1161 self.fichier = fileName
1162 return self.saveFile()
1163 return self.saveFile(path,1,"beautifie")
1167 #---------------------------------------------#
1168 def get_file(self,unite=None,fic_origine = ''):
1169 #---------------------------------------------#
1177 titre = tr("Choix unite %d ", unite)
1178 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1179 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1180 labeltexte = tr('Fichier pour unite ') + repr( unite)
1182 titre = tr("Choix d'un fichier de poursuite")
1183 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1184 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1186 QMessageBox.information( self, titre,QString.fromUtf8(texte))
1187 fn = QFileDialog.getOpenFileName(self.appliEficas,
1189 self.appliEficas.CONFIGURATION.savedir)
1192 # ce retour est impose par le get_file d'I_JDC
1195 ulfile = os.path.abspath(unicode(fn))
1196 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1198 # On utilise le convertisseur defini par format_fichier
1199 source=self.get_source(ulfile)
1201 # On a reussia convertir le fichier self.ulfile
1204 # Une erreur a ete rencontree
1206 return ulfile, jdcText
1208 #-------------------------------#
1209 def updateJdc(self, itemApres,texte):
1210 #--------------------------------#
1212 etape=monItem.item.object
1214 CONTEXT.set_current_step(etape)
1215 etape.build_includeInclude(texte)
1216 self.tree.racine.build_children()
1221 #-------------------------------------#
1222 def ajoutVersionCataDsJDC(self,txt):
1223 #-------------------------------------#
1224 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1225 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1226 texte=txt+ligneVersion
1229 #-------------------------------------#
1230 def verifieVersionCataDuJDC(self,text):
1231 #-------------------------------------#
1233 indexDeb=text.find("#VERSION_CATALOGUE:")
1234 indexFin=text.find(":FIN VERSION_CATALOGUE")
1236 self.versionCataDuJDC="sans"
1239 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1240 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1242 self.versionCata="sans"
1243 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1245 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1246 return memeVersion,textJDC
1248 #-------------------------------#
1249 def traduitCatalogue(self,texte):
1250 #-------------------------------#
1251 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1252 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1254 traducteur=__import__(nomTraducteur)
1255 monTraducteur=traducteur.MonTraducteur(texte)
1256 nouveauTexte=monTraducteur.traduit()
1262 #------------------------------#
1263 def verifieCHECKSUM(self,text):
1264 #------------------------------#
1265 indexDeb=text.find("#CHECKSUM:")
1268 indexFin=text.find(":FIN CHECKSUM")
1269 checkAvant=text[indexDeb:indexFin+13]
1270 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1271 checksum=self.get_checksum(textJDC)
1272 pareil=(checkAvant==checksum)
1273 return pareil, textJDC
1275 #---------------------------#
1276 def get_checksum(self,texte):
1277 #---------------------------#
1278 newtexte=texte.replace('"','\\"')
1279 commande='echo "'+newtexte+'"|md5sum'
1280 a=os.popen(commande)
1283 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1287 #---------------------------#
1288 def _newTELEMAC(self):
1289 #---------------------------#
1290 texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1294 #---------------------------#
1296 #---------------------------#
1297 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1301 #---------------------------#
1303 #---------------------------#
1304 def _newZCRACKS(self):
1305 #---------------------------#
1306 texte="MAILLAGES();REMESHING();"
1309 #---------------------------#
1310 def _newJDCCND(self):
1311 #---------------------------#
1312 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1314 #if self.salome == 0 :
1315 QMessageBox.information( self,
1317 tr("Veuillez selectionner un fichier Med"))
1318 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1319 caption='Fichier Med',
1321 self.fichierMED=str(QSfichier.toLatin1())
1322 from acquiertGroupes import getGroupes
1323 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1324 if erreur != "" : print "a traiter"
1325 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1331 for groupe in self.listeGroupes :
1332 if groupe[0:8]=='CURRENT_':
1333 texteSources +=groupe[8:]+"=SOURCE("
1334 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1335 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1336 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1337 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1338 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1339 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1340 self.newTexteCND=texte
1345 #---------------------------#
1346 def BoutonFileSelected(self):
1347 #---------------------------#
1349 QSfichier=self.openfile.selectedFiles()[0]
1350 self.fichierMED=str(QSfichier.toLatin1())
1351 from acquiertGroupes import getGroupes
1352 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1353 if erreur != "" : print "a traiter"
1355 #-----------------------------
1356 def BoutonSalomePressed(self):
1357 #----------------------------
1358 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1359 self.fichierMED="A_partir_de_SMESH"
1360 self.nomMaillage="A_partir_de_SMESH"
1361 self.openfile.close()
1364 if __name__ == "__main__":
1366 name='prefs_'+prefs.code
1367 prefsCode=__import__(name)
1370 if hasattr(prefsCode,'encoding'):
1371 # Hack pour changer le codage par defaut des strings
1374 sys.setdefaultencoding(prefs.encoding)
1375 del sys.setdefaultencoding
1380 app = QApplication(sys.argv)
1381 mw = JDCEditor(None,'azAster.comm')
1382 app.setMainWidget(mw)
1383 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1386 res = app.exec_loop()