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
27 from PyQt5.QtGui import QPalette
28 from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt
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"}
54 class JDCEditor(Ui_baseWidget,QWidget):
55 # ----------------------------------------- #
60 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
61 #----------------------------------------------------------------------------------------------------------#
63 QWidget.__init__(self,None)
65 self.widgetOptionnel=None
66 self.fenetreCentraleAffichee=None
67 self.dejaDansPlieTout=False
68 self.afficheCommandesPliees = True
69 self.listeDesListesOuvertes=set()
70 self.appliEficas = appli
71 self.appli = appli #---- attendu par IHM
73 self.fichier = fichier
76 self.QWParent = QWParent
77 self.couleur = Qt.black
80 self.salome = self.appliEficas.salome
83 print "dans JDC pas d appli ????????"
85 # ces attributs sont mis a jour par definitCode appelee par newEditor
86 self.code = self.appliEficas.CONFIGURATION.code
87 # tres vite a cause du tag. doit etre pase dans CONFIGURATION
89 self.afficheListesPliees=False
90 if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
92 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
93 self.affiche=self.appliEficas.CONFIGURATION.affiche
94 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
95 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
96 if self.code in ['MAP',] :
97 self.widgetTree.close()
99 self.appliEficas.resize(1440,self.appliEficas.height())
101 self.appliEficas.resize(2000,self.appliEficas.height())
103 self.version_code = session.d_env.cata
105 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
106 self.readercata = readercata.READERCATA( self, self.appliEficas )
107 self.appliEficas.readercata=self.readercata
109 self.readercata=self.appliEficas.readercata
110 if self.readercata.fic_cata == None : return #Sortie Salome
111 self.titre=self.readercata.titre
112 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
113 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
115 self.format = self.appliEficas.format_fichier
118 self.liste_simp_reel=[]
121 nameConf='configuration_'+self.code
122 configuration=__import__(nameConf)
123 self.CONFIGURATION = self.appliEficas.CONFIGURATION
124 self.CONFIGStyle = self.appliEficas.CONFIGStyle
127 self.CONFIGURATION.generator_module
128 _module = __import__(self.CONFIGURATION.generator_module)
129 info = _module.entryPoint()
130 generator.plugins.addEntryPoint(info)
135 self.CONFIGURATION.convert_module
136 print self.CONFIGURATION.convert_module
137 _module = __import__(self.CONFIGURATION.convert_module)
138 info = _module.entryPoint()
139 convert.plugins.addEntryPoint(info)
144 if hasattr(self.appliEficas,"statusBar"):
145 self.sb = self.appliEficas.statusBar()
148 self.lastModified = 0
150 self.modified = False
151 self.isReadOnly = False
152 self.node_selected = []
155 if self.code in ['Adao','MAP'] : self.afficheApresInsert=True
156 else : self.afficheApresInsert=False
157 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
158 else : self.enteteQTree='complet'
159 if self.code in ['Adao','TELEMAC'] : self.affichePlie=True
160 else : self.affichePlie=False
162 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
164 #------- construction du jdc --------------
169 if self.fichier is not None: # fichier jdc fourni
170 self.fileInfo = QFileInfo(self.fichier)
171 self.fileInfo.setCaching(0)
175 self.jdc = self.readFile(self.fichier)
178 print "mauvaise lecture"
181 if self.jdc is not None and units is not None:
182 self.jdc.recorded_units=units
183 self.jdc.old_recorded_units=units
185 if not self.jdc: # nouveau jdc
187 self.jdc = self._newJDC(units=units)
189 self.jdc = self._newJDCInclude(units=units)
193 self.jdc.appli = self
194 self.jdc.lang = self.appli.langue
195 self.jdc.aReafficher=False
199 txt_exception = self.jdc.cr.get_mess_exception()
202 QApplication.restoreOverrideCursor()
203 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
204 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
206 comploader.charger_composants("QT")
207 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
208 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
209 self.viewJdcRapport()
214 self.tree = browser.JDCTree( jdc_item, self )
215 self.appliEficas.construitMenu()
216 self.splitterSizes = []
220 #-------------------# Pour execution avec output et error dans le bash
222 #-------------------#
223 if self.modified or self.fichier==None : self.saveFile()
225 #lancement avec le .bat
226 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
227 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
229 p = subprocess.Popen(['python',WrapperFilePath])
230 (out,err)=p.communicate()
234 #--------------------------------#
235 def _newJDC( self ,units = None):
236 #--------------------------------#
238 Initialise un nouveau JDC vierge
241 CONTEXT.unset_current_step()
244 if self.code == "CARMELCND" : texte=self._newJDCCND()
245 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
246 if self.code == "TELEMAC" : texte=self._newTELEMAC()
247 if self.code == "PSEN" : texte = self._newPSEN()
248 # texte=self.newTexteCND
250 jdc=self.readercata.cata[0].JdC( procedure =texte,
252 cata=self.readercata.cata,
253 cata_ord_dico=self.readercata.cata_ordonne_dico,
254 rep_mat=self.CONFIGURATION.rep_mat
256 jdc.lang = self.appli.langue
257 if units is not None:
258 jdc.recorded_units=units
259 jdc.old_recorded_units=units
260 ## PNPN est ce que la ligne suivante est bien utile ?
261 if texte == "" :jdc.analyse()
264 #--------------------------------#
265 def _newJDCInclude( self ,units = None):
266 #--------------------------------#
268 Initialise un nouveau JDC vierge
270 import Extensions.jdc_include
271 JdC_aux=Extensions.jdc_include.JdC_include
272 CONTEXT.unset_current_step()
274 jaux=self.readercata.cata[0].JdC( procedure="",
276 cata=self.readercata.cata,
277 cata_ord_dico=self.readercata.cata_ordonne_dico,
278 rep_mat=self.CONFIGURATION.rep_mat,
282 J=JdC_aux( procedure="",
284 cata=self.readercata.cata,
285 cata_ord_dico=self.readercata.cata_ordonne_dico,
287 rep_mat=self.CONFIGURATION.rep_mat,
290 if units is not None:
291 J.recorded_units=units
292 J.old_recorded_units=units
296 #-------------------------------#
297 def readFile(self, fn):
298 #--------------------------------#
300 Public slot to read the text from a file.
301 @param fn filename to read from (string or QString)
305 # ------------------------------------------------------------------------------------
307 # ------------------------------------------------------------------------------------
309 jdcName=os.path.basename(fn)
310 # Il faut convertir le contenu du fichier en fonction du format
311 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
312 # Le convertisseur existe on l'utilise
314 p=convert.plugins[self.appliEficas.format_fichier_in]()
316 if p.text=="" : self.nouveau=1
317 pareil,texteNew=self.verifieCHECKSUM(p.text)
319 if pareil == False and (self.appliEficas.ssIhm == False) :
320 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
322 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
323 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
325 text=p.convert('exec',self.appliEficas)
326 if not p.cr.estvide():
327 self.affiche_infos("Erreur a la conversion",Qt.red)
329 self.affiche_infos("Type de fichier non reconnu",Qt.red)
330 if self.appliEficas.ssIhm == False:
331 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
332 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
335 CONTEXT.unset_current_step()
336 jdc=self.readercata.cata[0].JdC(procedure=text,
338 cata=self.readercata.cata,
339 cata_ord_dico=self.readercata.cata_ordonne_dico,
341 rep_mat=self.CONFIGURATION.rep_mat
343 # ----------------------------------------------------
345 # ----------------------------------------------------
346 self.modified = False
348 # qApp.restoreOverrideCursor()
349 if self.fileInfo!= None :
350 self.lastModified = self.fileInfo.lastModified()
352 self.lastModified = 1
353 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
354 self.appliEficas.setWindowTitle(nouveauTitre)
358 #-----------------------#
359 def get_source(self,file):
360 #-----------------------#
362 # Il faut convertir le contenu du fichier en fonction du format
363 if convert.plugins.has_key(self.format):
364 # Le convertisseur existe on l'utilise
365 p=convert.plugins[self.format]()
367 text=p.convert('execnoparseur')
368 if not p.cr.estvide():
369 self.affiche_infos("Erreur a la conversion",Qt.red)
372 # Il n'existe pas c'est une erreur
373 self.affiche_infos("Type de fichier non reconnu",Qt.red)
374 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
377 #-----------------------------------------------------------------------#
378 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
379 #--------------------------------------------------------------------#
380 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
384 #----------------------------------------------#
385 def __generateTempFilename(self, prefix, suffix):
386 #----------------------------------------------#
388 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
394 #----------------------------------------------#
395 def _viewTextExecute(self, txt, prefix, suffix):
396 #----------------------------------------------#
397 self.w = ViewText( self.QWParent )
398 self.w.setWindowTitle( "execution" )
399 self.monExe=QProcess(self.w)
400 pid=self.monExe.pid()
401 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
402 f=open(nomFichier,'w')
406 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
407 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
409 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
410 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
411 exe='sh ' + nomFichier
412 self.monExe.start(exe)
413 self.monExe.closeWriteChannel()
416 commande="rm "+ nomFichier
421 def readFromStdErr(self):
422 a=self.monExe.readAllStandardError()
423 self.w.view.append(str(a.data(),len(a)))
425 def readFromStdErr(self) :
426 a=self.monExe.readAllStandardOutput()
427 self.w.view.append(str(a.data(),len(a)))
429 def readFromStdErrQT4(self):
430 a=self.monExe.readAllStandardError()
431 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
433 def readFromStdOutQT4(self) :
434 a=self.monExe.readAllStandardOutput()
435 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
439 #-----------------------#
440 def gestionParam(self):
441 #-----------------------#
442 w = MonWidgetCreeParam( self)
445 #-----------------------#
446 def viewJdcSource(self):
447 #-----------------------#
448 f=open(self.fichier,'r')
451 self._viewText(texteSource, "JDC_SOURCE")
453 #-----------------------#
455 #-----------------------#
456 strSource = str( self.get_text_JDC(self.format) )
457 self._viewText(strSource, "JDC_RESULTAT")
459 #-----------------------#
460 def viewJdcRapport(self):
461 #-----------------------#
462 strRapport = unicode( self.jdc.report() )
463 # on ajoute les regles
465 self._viewText(strRapport, "JDC_RAPPORT")
467 #-----------------------#
468 def viewJdcRegles(self):
469 #-----------------------#
470 if self.tree :self.tree.AppelleBuildLBRegles()
477 Public method called by the viewmanager to finally get rid of us.
483 #----------------------------------------------#
484 def affiche_infos(self,message,couleur=Qt.black):
485 #----------------------------------------------#
487 mapalette=self.sb.palette()
488 mapalette.setColor( QPalette.WindowText, couleur )
489 self.sb.setPalette( mapalette );
490 self.sb.showMessage(message,4000)
493 #------------------------------#
494 def affiche_alerte(self,titre,message):
495 #------------------------------#
496 # appele par I_MACRO_ETAPE
497 QMessageBox.information( self, titre, message)
499 #-----------------------------------#
500 def affiche_commentaire(self,message):
501 #-----------------------------------#
502 self.labelCommentaire.setText(message)
503 QTimer.singleShot(6000, self.rendInvisible)
505 #----------------------#
506 def rendInvisible(self):
507 #----------------------#
508 self.labelCommentaire.setText("")
510 #-------------------#
511 def init_modif(self):
512 #-------------------#
514 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
515 si un JDC doit etre sauvegarde avant destruction ou non
519 #---------------------------------------#
520 def chercheNoeudSelectionne(self,copie=1):
521 #---------------------------------------#
523 appele par Cut et Copy pour positionner self.node_selected
525 self.node_selected=[]
526 if len(self.tree.selectedItems()) == 0 : return
527 self.node_selected=self.tree.selectedItems()
530 #---------------------#
531 def handleSupprimer(self):
532 #---------------------#
533 self.chercheNoeudSelectionne()
534 if len(self.node_selected) == 0 : return
535 self.QWParent.noeud_a_editer = []
536 if self.node_selected[0]==self.tree.racine: return
537 if len(self.node_selected) == 1 : self.node_selected[0].delete()
538 else : self.node_selected[0].deleteMultiple(self.node_selected)
540 #---------------------#
541 def handleRechercher(self):
542 #---------------------#
543 from monRecherche import DRecherche
544 monRechercheDialg=DRecherche(parent=self,fl=0)
545 monRechercheDialg.show()
547 #---------------------#
548 def handleDeplier(self):
549 #---------------------#
550 if self.tree == None : return
551 #self.tree.collapseAll()
554 self.tree.expandItem(self.tree.topLevelItem(0))
556 if self.fenetreCentraleAffichee != None :
557 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
558 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
561 self.tree.expandItem(self.tree.topLevelItem(0))
563 if self.fenetreCentraleAffichee != None :
564 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
565 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
567 #---------------------#
568 def handleEditCut(self):
569 #---------------------#
571 Stocke dans Eficas.noeud_a_editer le noeud a couper
573 #print "handleEditCut"
574 self.chercheNoeudSelectionne()
575 self.QWParent.edit="couper"
576 self.QWParent.noeud_a_editer = self.node_selected
578 #-----------------------#
579 def handleEditCopy(self):
580 #-----------------------#
582 Stocke dans Eficas.noeud_a_editer le noeud a copier
584 self.chercheNoeudSelectionne()
585 if len(self.node_selected) == 0 : return
586 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
587 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
588 self.QWParent.edit="copier"
589 self.QWParent.noeud_a_editer = self.node_selected
591 #------------------------#
592 def handleEditPaste(self):
593 #------------------------#
595 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
596 Ne permet que la copie d'objets de type Commande ou MCF
598 self.chercheNoeudSelectionne()
599 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
600 QMessageBox.information( self,
601 tr("Copie impossible"),
602 tr("Veuillez selectionner un objet a copier"))
604 if len(self.node_selected) != 1 :
605 QMessageBox.information( self,
606 tr("Copie impossible"),
607 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
610 if len(self.QWParent.noeud_a_editer)!=1:
611 self.handleEditPasteMultiple()
614 noeudOuColler=self.node_selected[0]
616 if noeudOuColler == self.tree.racine:
620 #indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
621 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
624 noeudACopier=self.QWParent.noeud_a_editer[0]
625 #indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
626 indexNoeudACopier=self.getTreeIndex(noeudACopier)
628 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
631 if (self.QWParent.edit != "couper"):
633 if noeudOuColler == self.tree.racine :
635 child=noeudOuColler.doPastePremier(noeudACopier)
638 child=noeudACopier.doPaste(noeudOuColler,pos)
639 if child==None or child==0:
640 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
642 self.affiche_infos("Copie refusee",Qt.red)
643 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
645 nom=noeudACopier.item.sd.nom
646 child.item.nomme_sd(nom)
653 traceback.print_exc()
654 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
656 self.affiche_infos("Copie refusee",Qt.red)
659 # il faut declarer le JDCDisplay_courant modifie
660 # suppression eventuelle du noeud selectionne
661 # si possible on renomme l objet comme le noeud couper
663 if (self.QWParent.edit == "couper"):
665 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
666 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
670 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
671 indexNoeudACopier=self.getTreeIndex(noeudACopier)
672 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
673 noeudACopier.treeParent.build_children()
678 self.QWParent.noeud_a_editer=[]
680 # on rend la copie a nouveau possible en liberant le flag edit
681 self.QWParent.edit="copier"
682 noeudACopier.select()
684 #----------------------------------#
685 def handleDeplaceMultiple(self):
686 #----------------------------------#
689 #----------------------------------#
690 def handleEditPasteMultiple(self):
691 #----------------------------------#
693 # On ne garde que les niveaux "Etape"
694 # On insere dans l'ordre du JDC
695 listeNoeudsACouper=[]
699 from InterfaceQT4 import compojdc
700 noeudOuColler=self.node_selected[0]
701 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
702 QMessageBox.information( self,
703 tr("Copie impossible a cet endroit",),
704 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
706 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
708 for noeud in self.QWParent.noeud_a_editer :
709 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
710 indexInTree=noeud.treeParent.children.index(noeud)
712 for index in listeIndex:
713 if index < indexInTree : indice = indice +1
714 listeIndex.insert(indice, indexInTree)
715 listeNoeudsACouper.insert(indice, noeud)
717 noeudJdc=noeudOuColler.treeParent
719 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
721 for index in listeIndex:
723 if indexNoeudOuColler < index:
724 indexTravail=indexTravail+dejaCrees
725 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
726 noeud=noeudJdc.children[indexTravail]
727 child=noeud.doPaste(noeudOuColler)
728 listeChild.append(child)
729 dejaCrees=dejaCrees+1
731 self.QWParent.noeud_a_editer = []
732 for i in range(len(listeIndex)):
733 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
734 self.QWParent.noeud_a_editer.append(noeud)
737 if self.QWParent.edit !="couper" : return
739 for index in listeIndex:
741 if indexNoeudOuColler < index:
742 indexTravail=indexTravail+(len(listeIndex))
743 noeud=noeudJdc.children[indexTravail]
745 listeItem.append(noeud.item)
746 listeASupprimer.append(noeud)
748 for i in range(len(listeChild)):
749 self.tree.item.suppitem(listeItem[i])
750 listeChild[i].item.update(listeItem[i])
752 self.QWParent.noeud_a_editer = []
755 #---------------------#
756 def getFileName(self):
757 #---------------------#
760 #---------------------------#
761 def get_file_variable(self) :
762 #---------------------------#
763 titre = tr("Choix d'un fichier XML")
764 texte = tr("Le fichier contient une commande MODEL\n")
765 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
766 QMessageBox.information( self, titre,tr(texte))
768 fichier = QFileDialog.getOpenFileName(self.appliEficas,
769 tr('Ouvrir Fichier'),
770 self.appliEficas.CONFIGURATION.savedir,
771 tr('Wrapper Files (*.xml);;''All Files (*)'))
774 #--------------------------------------------------#
775 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
776 #--------------------------------------------------#
778 Public slot to write the text to a file.
780 @param fn filename to write to string
781 @return flag indicating success
787 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
789 if len(txt) >= len(eol):
790 if txt[-len(eol):] != eol:
794 txt=self.ajoutVersionCataDsJDC(txt)
795 checksum=self.get_checksum(txt)
803 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
804 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
807 #-----------------------------------------------------------#
808 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
809 #-----------------------------------------------------------#
810 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
811 if generator.plugins.has_key(format):
813 # Le generateur existe on l'utilise
814 self.generator=generator.plugins[format]()
816 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION)
817 if pourRun : jdc_formate=self.generator.textePourRun
819 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
820 if not self.generator.cr.estvide():
821 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
822 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
827 # Il n'existe pas c'est une erreur
828 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
829 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
835 fonction="run"+self.code
836 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
841 fonction="saveRun"+self.code
842 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
848 if not(self.jdc.isvalid()):
849 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
851 if len(self.jdc.etapes) != 1 :
852 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
854 if self.modified or self.fichier==None :
855 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
856 texte=self.get_text_JDC("MAP")
857 self.writeFile( self.fichierMapInput, txt = texte)
859 self.fichierMapInput=self.fichier
860 composant=self.jdc.etapes[0].nom.lower()[0:-5]
863 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
864 # then instantiate corresponding class and call getUseSalome() method
866 from mapengine.spec import factory
867 mapComponent = factory.new(composant)[0]
870 if mapComponent.getUseSalome():
871 command += " -r sappli"
872 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
875 self._viewTextExecute( textePython,"map_run",".sh")
877 # commande="rm "+self.fichierMapInput
878 # os.system(commande)
882 print traceback.print_exc()
884 #-------------------#
885 def runZCRACKS(self):
886 #-------------------#
887 if not(self.jdc.isvalid()):
888 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
890 if self.modified or self.fichier==None :
892 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
893 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
894 self.writeFile( self.fichierZcracksInput, txt = texte)
896 self.fichierZcracksInput=self.fichier
898 #commande ="Zrun -zp "
900 textePython=(commande + self.fichierZcracksInput)
901 self._viewTextExecute( textePython,"run_zcracks",".sh")
903 print traceback.print_exc()
905 #-------------------#
906 def runCARMELCND(self):
907 #-------------------#
908 #if not(self.jdc.isvalid()):
909 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
911 if self.modified or self.fichier==None :
912 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
914 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
915 from PrepareRunCarmel import prepareRunCarmel
916 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
917 repMed=os.path.dirname(self.fichier)
918 repExeCarmel=self.generator.get_repExeCarmel()
919 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
920 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
921 f=open(nomFichier,'w')
924 commande="xterm -e sh "+nomFichier +"\n"
927 # self._viewTextExecute( textePython,"carmel_run",".sh")
928 #except Exception, e:
929 # print traceback.print_exc()
931 #-------------------#
932 def runCarmelCS(self):
933 #-------------------#
935 commande="runSession pilotyacsCS.py"
938 print traceback.print_exc()
940 #-----------------------------------------------------#
941 def determineNomFichier(self,path,extension):
942 #-----------------------------------------------------#
943 if DictExtensions.has_key(self.appli.code) :
944 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
945 extensions= tr(chaine1+ "All Files (*)")
947 extensions= tr("JDC (*.comm);;" "All Files (*)")
949 if self.appli.code == "MAP" :
950 extensions = extensions + ";; Run (*.input);;"
952 fn = QFileDialog.getSaveFileName( self,
953 tr("sauvegarde"), path,
955 QFileDialog.DontConfirmOverwrite)
956 if fn.isNull(): return (0, None)
957 if fn == None : return (0, None)
958 if monEnvQT5 : fn=fn[0]
960 ext = QFileInfo(fn).suffix()
961 if ext.isEmpty(): fn.append(extension)
963 if QFileInfo(fn).exists():
964 abort = QMessageBox.warning(self,
965 tr("Sauvegarde du Fichier"),
966 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
969 if abort == 1 : return (0, "")
973 def saveRunMAP(self):
976 if not(self.jdc.isvalid()):
977 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
978 tr("Un JdC valide est necessaire pour creer un .input")
982 composant=self.jdc.etapes[0].nom.lower()[0:-5]
984 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
985 tr("Choix du composant obligatoire")
988 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
992 if self.fichier is not None and self.fichier != "" :
993 maBase=str(QFileInfo(self.fichier).baseName())+".input"
994 monPath=str(QFileInfo(self.fichier).absolutePath())
995 monNomFichier=os.path.join(monPath,maBase)
996 elif hasattr(self,'monNomFichierInput'):
997 monNomFichier=self.monNomFichierInput
1000 monDialog=QFileDialog(self.appliEficas)
1001 monDialog.setDirectory (path)
1002 monDialog.setWindowTitle ("Save")
1004 for c in monDialog.children():
1005 if isinstance(c,QDialogButtonBox):
1006 for b in c.children():
1007 if isinstance(b,QPushButton):
1009 if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
1010 if monEnvQT5 and avant=="&Open": b.setText("Save")
1012 mesFiltres= "input Map (*.input);;All Files (*)"
1014 mesFiltres=QStringList()
1015 mesFiltres << "input Map (*.input)" << "All Files (*)"
1016 monDialog.setNameFilters(mesFiltres)
1017 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1018 BOk=monDialog.exec_()
1020 if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
1021 else : fn=str(monDialog.selectedFiles()[0].toLatin1())
1022 if fn == "" or fn == None : return
1023 if not fn.endswith(".input"):
1025 self.monNomFichierInput=fn
1027 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1028 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1029 texte=self.get_text_JDC("MAP")
1030 self.writeFile( self.fichierMapInput, txt = texte)
1032 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1033 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1034 (output, err) = p.communicate()
1038 def saveRunPSEN(self):
1043 if not(self.jdc.isvalid()):
1044 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1045 tr("Un JdC valide est necessaire pour creer un .input")
1049 print generator.plugins.has_key(self.format)
1050 if generator.plugins.has_key(self.format):
1051 # Le generateur existe on l'utilise
1052 self.generator=generator.plugins[self.format]()
1054 self.generator.gener(self.jdc)
1055 self.generator.writeDefault('')
1056 except ValueError,e:
1057 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1058 if not self.generator.cr.estvide():
1059 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1060 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1063 # Il n'existe pas c'est une erreur
1064 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1065 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1072 #-----------------------------------------#
1073 def cherche_Groupes(self):
1074 #-----------------------------------------#
1075 listeMA,listeNO=self.get_text_JDC("GroupMA")
1076 return listeMA,listeNO
1078 #-----------------------------------------#
1079 def cherche_Dico(self):
1080 #-----------------------------------------#
1082 format = self.appliEficas.format_fichier
1083 if generator.plugins.has_key(format):
1084 # Le generateur existe on l'utilise
1085 self.generator=generator.plugins[format]()
1086 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1087 dicoCourant=self.generator.dico
1092 #-----------------------------------------#
1093 def handleAjoutGroup(self,listeGroup):
1094 #-----------------------------------------#
1097 from ajoutGroupe import handleAjoutGroupFiltre
1099 handleAjoutGroupFiltre(self,listeGroup)
1100 #print "apres handleAjoutGroupFiltre"
1105 #-----------------------------------------------------------------#
1106 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1107 #-----------------------------------------------------------------#
1109 Public slot to save the text to a file.
1111 @param path directory to save the file in (string or QString)
1112 @return tuple of two values (boolean, string) giving a success indicator and
1113 the name of the saved file
1117 if not self.modified and not saveas:
1118 return (0, None) # do nothing if text wasn't changed
1121 if DictExtensions.has_key(self.appli.code) :
1122 extension=DictExtensions[self.appli.code]
1128 if self.fichier is None or saveas:
1130 path=self.CONFIGURATION.savedir
1131 bOK, fn=self.determineNomFichier(path,extension)
1132 if bOK == 0 : return (0, None)
1133 if fn == None : return (0, None)
1134 if fn.isNull(): return (0, None)
1136 ulfile = os.path.abspath(unicode(fn))
1137 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1138 fn = unicode(QDir.convertSeparators(fn))
1142 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1144 self.modified = False
1145 if self.fileInfo is None or saveas:
1146 self.fileInfo = QFileInfo(self.fichier)
1147 self.fileInfo.setCaching(0)
1148 self.lastModified = self.fileInfo.lastModified()
1149 if newName is not None:
1150 self.appliEficas.addToRecentList(newName)
1151 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1152 self.tree.racine.update_node_label()
1154 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1155 self.generator.writeDefault(fn)
1158 self.appliEficas.addJdcInSalome( self.fichier)
1160 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1161 self.appliEficas.setWindowTitle(nouveauTitre)
1163 return (1, self.fichier)
1166 #----------------------------------------------#
1167 def sauveLigneFile(self):
1168 #----------------------------------------------#
1170 return self.saveFile(formatLigne="Ligne")
1173 #----------------------------------------------#
1174 def saveFileAs(self, path = None,fileName=None):
1175 #----------------------------------------------#
1177 Public slot to save a file with a new name.
1179 @param path directory to save the file in (string or QString)
1180 @return tuple of two values (boolean, string) giving a success indicator and
1181 the name of the saved file
1183 if fileName != None :
1184 self.fichier = fileName
1185 return self.saveFile()
1186 return self.saveFile(path,1,"beautifie")
1190 #---------------------------------------------#
1191 def get_file(self,unite=None,fic_origine = ''):
1192 #---------------------------------------------#
1200 titre = tr("Choix unite %d ", unite)
1201 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1202 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1203 labeltexte = tr('Fichier pour unite ') + repr( unite)
1205 titre = tr("Choix d'un fichier de poursuite")
1206 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1207 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1209 QMessageBox.information( self, titre,texte)
1210 fn = QFileDialog.getOpenFileName(self.appliEficas,
1212 self.appliEficas.CONFIGURATION.savedir)
1214 # ce retour est impose par le get_file d'I_JDC
1215 if fn.isNull(): return None," "
1216 if not fn : return (0, " ")
1217 if monEnvQT5 : fn=fn[0]
1219 ulfile = os.path.abspath(unicode(fn))
1220 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1222 # On utilise le convertisseur defini par format_fichier
1223 source=self.get_source(ulfile)
1225 # On a reussia convertir le fichier self.ulfile
1228 # Une erreur a ete rencontree
1230 return ulfile, jdcText
1232 #-------------------------------#
1233 def updateJdc(self, itemApres,texte):
1234 #--------------------------------#
1236 etape=monItem.item.object
1238 CONTEXT.set_current_step(etape)
1239 etape.build_includeInclude(texte)
1240 self.tree.racine.build_children()
1245 #-------------------------------------#
1246 def ajoutVersionCataDsJDC(self,txt):
1247 #-------------------------------------#
1248 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1249 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1250 texte=txt+ligneVersion
1253 #-------------------------------------#
1254 def verifieVersionCataDuJDC(self,text):
1255 #-------------------------------------#
1257 indexDeb=text.find("#VERSION_CATALOGUE:")
1258 indexFin=text.find(":FIN VERSION_CATALOGUE")
1260 self.versionCataDuJDC="sans"
1263 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1264 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1266 self.versionCata="sans"
1267 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1269 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1270 return memeVersion,textJDC
1272 #-------------------------------#
1273 def traduitCatalogue(self,texte):
1274 #-------------------------------#
1275 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1276 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1278 traducteur=__import__(nomTraducteur)
1279 monTraducteur=traducteur.MonTraducteur(texte)
1280 nouveauTexte=monTraducteur.traduit()
1286 #------------------------------#
1287 def verifieCHECKSUM(self,text):
1288 #------------------------------#
1289 indexDeb=text.find("#CHECKSUM:")
1292 indexFin=text.find(":FIN CHECKSUM")
1293 checkAvant=text[indexDeb:indexFin+13]
1294 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1295 checksum=self.get_checksum(textJDC)
1296 pareil=(checkAvant==checksum)
1297 return pareil, textJDC
1299 #---------------------------#
1300 def get_checksum(self,texte):
1301 #---------------------------#
1302 newtexte=texte.replace('"','\\"')
1303 commande='echo "'+newtexte+'"|md5sum'
1304 a=os.popen(commande)
1307 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1311 #---------------------------#
1312 def _newTELEMAC(self):
1313 #---------------------------#
1314 texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1318 #---------------------------#
1320 #---------------------------#
1321 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1325 #---------------------------#
1327 #---------------------------#
1328 def _newZCRACKS(self):
1329 #---------------------------#
1330 texte="MAILLAGES();REMESHING();"
1333 #---------------------------#
1334 def _newJDCCND(self):
1335 #---------------------------#
1336 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1338 #if self.salome == 0 :
1339 QMessageBox.information( self,
1341 tr("Veuillez selectionner un fichier Med"))
1342 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1343 caption='Fichier Med',
1345 if monEnvQT5 : QSfichier=QSfichier[0]
1346 self.fichierMED=QSfichier
1347 from acquiertGroupes import getGroupes
1348 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1349 if erreur != "" : print "a traiter"
1350 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1356 for groupe in self.listeGroupes :
1357 if groupe[0:8]=='CURRENT_':
1358 texteSources +=groupe[8:]+"=SOURCE("
1359 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1360 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1361 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1362 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1363 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1364 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1365 self.newTexteCND=texte
1370 #---------------------------#
1371 def BoutonFileSelected(self):
1372 #---------------------------#
1374 QSfichier=self.openfile.selectedFiles()[0]
1375 self.fichierMED=str(QSfichier)
1376 from acquiertGroupes import getGroupes
1377 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1378 if erreur != "" : print "a traiter"
1380 #-----------------------------
1381 def BoutonSalomePressed(self):
1382 #----------------------------
1383 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1384 self.fichierMED="A_partir_de_SMESH"
1385 self.nomMaillage="A_partir_de_SMESH"
1386 self.openfile.close()
1388 #-----------------------------
1389 def saveSplitterSizes(self):
1390 #----------------------------
1391 if self.splitter != None :
1392 self.splitterSizes = self.splitter.sizes()
1395 #-----------------------------
1396 def restoreSplitterSizes(self):
1397 #----------------------------
1398 if hasattr(self,'splitterSizes') :
1399 lenSizes = len(self.splitterSizes)
1401 if self.splitter != None and self.splitter.count() >= lenSizes :
1402 newSizes = self.splitter.sizes()
1403 newSizes[:len(self.splitterSizes)-1] = self.splitterSizes[:len(self.splitterSizes)-1]
1404 newSizes[len(newSizes)-1] = self.splitterSizes[len(self.splitterSizes)-1]
1405 self.splitter.setSizes(newSizes)
1407 #-----------------------------
1408 def getTreeIndex(self,noeud):
1409 #----------------------------
1411 if noeud in noeud.treeParent.children :
1412 indexNoeud=noeud.treeParent.children.index(noeud)
1414 if hasattr(noeud,'vraiParent') :
1416 noeudVraiParent = noeud.vraiParent
1417 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1418 noeudVrai = noeudVraiParent
1419 noeudVraiParent = noeudVraiParent.vraiParent
1421 if noeudVraiParent == noeud.treeParent :
1422 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1428 if __name__ == "__main__":
1430 name='prefs_'+prefs.code
1431 prefsCode=__import__(name)
1434 if hasattr(prefsCode,'encoding'):
1435 # Hack pour changer le codage par defaut des strings
1438 sys.setdefaultencoding(prefs.encoding)
1439 del sys.setdefaultencoding
1444 app = QApplication(sys.argv)
1445 mw = JDCEditor(None,'azAster.comm')
1446 app.setMainWidget(mw)
1447 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1450 res = app.exec_loop()