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 *
27 from datetime import date
28 from Extensions.i18n import tr
33 import convert, generator
34 from Editeur import session
35 from Editeur import comploader
36 from Editeur import Objecttreeitem
37 from desBaseWidget import Ui_baseWidget
38 from monViewTexte import ViewText
42 DictExtensions= {"MAP" : ".map"}
46 class JDCEditor(Ui_baseWidget,QtGui.QWidget):
47 # ----------------------------------------- #
52 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
53 #----------------------------------------------------------------------------------------------------------#
55 QtGui.QWidget.__init__(self,None)
57 self.monOptionnel=None
58 self.fenetreCentraleAffichee=None
59 self.appliEficas = appli
60 self.appli = appli #---- attendu par IHM
62 self.fichier = fichier
65 self.QWParent = QWParent
68 self.salome = self.appliEficas.salome
71 print "dans JDC pas d appli ????????"
73 # ces attributs sont mis a jour par definitCode appelee par newEditor
74 self.code = self.appliEficas.CONFIGURATION.code
76 if self.code in ['MAP','Adao'] :
77 self.widgetTree.close()
79 self.appliEficas.resize(1440,self.appliEficas.height())
81 self.appliEficas.resize(2000,self.appliEficas.height())
83 self.version_code = session.d_env.cata
85 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
86 self.readercata = readercata.READERCATA( self, self.appliEficas )
87 self.appliEficas.readercata=self.readercata
89 self.readercata=self.appliEficas.readercata
90 if self.readercata.fic_cata == None : return #Sortie Salome
91 self.titre=self.readercata.titre
93 self.format = self.appliEficas.format_fichier
96 self.liste_simp_reel=[]
99 nameConf='configuration_'+self.code
100 configuration=__import__(nameConf)
101 self.CONFIGURATION = self.appliEficas.CONFIGURATION
102 self.CONFIGStyle = self.appliEficas.CONFIGStyle
105 self.CONFIGURATION.generator_module
106 _module = __import__(self.CONFIGURATION.generator_module)
107 info = _module.entryPoint()
108 generator.plugins.addEntryPoint(info)
113 self.CONFIGURATION.convert_module
114 _module = __import__(self.CONFIGURATION.convert_module)
115 info = _module.entryPoint()
116 convert.plugins.addEntryPoint(info)
121 if hasattr(self.appliEficas,"statusBar"):
122 self.sb = self.appliEficas.statusBar()
125 self.lastModified = 0
127 self.modified = False
128 self.isReadOnly = False
129 self.node_selected = []
133 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
135 #------- construction du jdc --------------
138 self.mode_nouv_commande=self.readercata.mode_nouv_commande
141 if self.fichier is not None: # fichier jdc fourni
142 self.fileInfo = QFileInfo(self.fichier)
143 self.fileInfo.setCaching(0)
146 self.jdc = self.readFile(self.fichier)
148 print "mauvaise lecture"
151 if self.jdc is not None and units is not None:
152 self.jdc.recorded_units=units
153 self.jdc.old_recorded_units=units
155 if not self.jdc: # nouveau jdc
157 self.jdc = self._newJDC(units=units)
159 self.jdc = self._newJDCInclude(units=units)
163 self.jdc.appli = self
164 self.jdc.lang = self.appli.langue
169 txt_exception = self.jdc.cr.get_mess_exception()
172 qApp.restoreOverrideCursor()
173 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
174 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
176 comploader.charger_composants("QT")
177 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
178 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
179 self.viewJdcRapport()
182 self.tree = browser.JDCTree( jdc_item, self )
183 self.appliEficas.construitMenu()
185 #--------------------------------#
186 def _newJDC( self ,units = None):
187 #--------------------------------#
189 Initialise un nouveau JDC vierge
192 CONTEXT.unset_current_step()
195 if self.code == "CARMELCND" : texte=self._newJDCCND()
196 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
197 # texte=self.newTexteCND
199 jdc=self.readercata.cata[0].JdC( procedure =texte,
201 cata=self.readercata.cata,
202 cata_ord_dico=self.readercata.cata_ordonne_dico,
203 rep_mat=self.CONFIGURATION.rep_mat
205 jdc.lang = self.appli.langue
206 if units is not None:
207 jdc.recorded_units=units
208 jdc.old_recorded_units=units
209 ## PNPN est ce que la ligne suivante est bien utile ?
210 if texte == "" :jdc.analyse()
213 #--------------------------------#
214 def _newJDCInclude( self ,units = None):
215 #--------------------------------#
217 Initialise un nouveau JDC vierge
219 import Extensions.jdc_include
220 JdC_aux=Extensions.jdc_include.JdC_include
221 CONTEXT.unset_current_step()
223 jaux=self.readercata.cata[0].JdC( procedure="",
225 cata=self.readercata.cata,
226 cata_ord_dico=self.readercata.cata_ordonne_dico,
227 rep_mat=self.CONFIGURATION.rep_mat,
231 J=JdC_aux( procedure="",
233 cata=self.readercata.cata,
234 cata_ord_dico=self.readercata.cata_ordonne_dico,
236 rep_mat=self.CONFIGURATION.rep_mat,
239 if units is not None:
240 J.recorded_units=units
241 J.old_recorded_units=units
245 #-------------------------------#
246 def readFile(self, fn):
247 #--------------------------------#
249 Public slot to read the text from a file.
250 @param fn filename to read from (string or QString)
254 # ------------------------------------------------------------------------------------
256 # ------------------------------------------------------------------------------------
258 jdcName=os.path.basename(fn)
259 # Il faut convertir le contenu du fichier en fonction du format
260 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
261 # Le convertisseur existe on l'utilise
263 p=convert.plugins[self.appliEficas.format_fichier_in]()
265 if p.text=="" : self.nouveau=1
266 pareil,texteNew=self.verifieCHECKSUM(p.text)
268 if pareil == False and (self.appliEficas.ssIhm == False) :
269 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
271 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
272 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
274 text=p.convert('exec',self.appliEficas)
275 if not p.cr.estvide():
276 self.affiche_infos("Erreur a la conversion",Qt.red)
278 self.affiche_infos("Type de fichier non reconnu",Qt.red)
279 if self.appliEficas.ssIhm == False:
280 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
281 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
284 CONTEXT.unset_current_step()
285 jdc=self.readercata.cata[0].JdC(procedure=text,
287 cata=self.readercata.cata,
288 cata_ord_dico=self.readercata.cata_ordonne_dico,
290 rep_mat=self.CONFIGURATION.rep_mat
292 # ----------------------------------------------------
294 # ----------------------------------------------------
295 self.modified = False
297 # qApp.restoreOverrideCursor()
298 if self.fileInfo!= None :
299 self.lastModified = self.fileInfo.lastModified()
301 self.lastModified = 1
302 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
303 self.appliEficas.setWindowTitle(nouveauTitre)
307 #-----------------------#
308 def get_source(self,file):
309 #-----------------------#
311 # Il faut convertir le contenu du fichier en fonction du format
312 if convert.plugins.has_key(self.format):
313 # Le convertisseur existe on l'utilise
314 p=convert.plugins[self.format]()
316 text=p.convert('execnoparseur')
317 if not p.cr.estvide():
318 self.affiche_infos("Erreur a la conversion",Qt.red)
321 # Il n'existe pas c'est une erreur
322 self.affiche_infos("Type de fichier non reconnu",Qt.red)
323 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
326 #----------------------------------------------#
327 def _viewText(self, txt, caption = "FILE_VIEWER"):
328 #----------------------------------------------#
329 w = ViewText( self.QWParent )
330 w.setWindowTitle( caption )
335 #----------------------------------------------#
336 def __generateTempFilename(self, prefix, suffix):
337 #----------------------------------------------#
339 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
345 #----------------------------------------------#
346 def _viewTextExecute(self, txt, prefix, suffix):
347 #----------------------------------------------#
348 self.w = ViewText( self.QWParent )
349 self.w.setWindowTitle( "execution" )
350 self.monExe=QProcess(self.w)
351 pid=self.monExe.pid()
352 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
353 f=open(nomFichier,'w')
356 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOut )
357 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErr )
358 exe='sh /tmp/test.sh'
359 self.monExe.start(exe)
360 self.monExe.closeWriteChannel()
363 commande="rm "+ nomFichier
369 def readFromStdErr(self):
370 a=self.monExe.readAllStandardError()
371 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
373 def readFromStdOut(self) :
374 a=self.monExe.readAllStandardOutput()
375 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
379 #-----------------------#
380 def viewJdcSource(self):
381 #-----------------------#
382 f=open(self.fichier,'r')
385 self._viewText(texteSource, "JDC_SOURCE")
387 #-----------------------#
389 #-----------------------#
390 strSource = str( self.get_text_JDC(self.format) )
391 self._viewText(strSource, "JDC_RESULTAT")
393 #-----------------------#
394 def viewJdcRapport(self):
395 #-----------------------#
396 strRapport = unicode( self.jdc.report() )
397 self._viewText(strRapport, "JDC_RAPPORT")
403 Public method called by the viewmanager to finally get rid of us.
409 #----------------------------------------------#
410 def affiche_infos(self,message,couleur=Qt.black):
411 #----------------------------------------------#
413 mapalette=self.sb.palette()
414 from PyQt4.QtGui import QPalette
415 mapalette.setColor( QPalette.WindowText, couleur )
416 self.sb.setPalette( mapalette );
417 self.sb.showMessage(QString.fromUtf8(message))#,2000)
419 #------------------------------#
420 def affiche_alerte(self,titre,message):
421 #------------------------------#
422 # appele par I_MACRO_ETAPE
423 QMessageBox.information( self, titre, message)
425 #-------------------#
426 def init_modif(self):
427 #-------------------#
429 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
430 si un JDC doit etre sauvegarde avant destruction ou non
434 #---------------------------------------#
435 def chercheNoeudSelectionne(self,copie=1):
436 #---------------------------------------#
438 appele par Cut et Copy pour positionner self.node_selected
440 self.node_selected=[]
441 if len(self.tree.selectedItems()) == 0 : return
442 self.node_selected=self.tree.selectedItems()
445 #---------------------#
446 def handleSupprimer(self):
447 #---------------------#
448 self.chercheNoeudSelectionne()
449 if len(self.node_selected) == 0 : return
450 self.QWParent.noeud_a_editer = []
451 if self.node_selected[0]==self.tree.racine: return
452 if len(self.node_selected) == 1 : self.node_selected[0].delete()
453 else : self.node_selected[0].deleteMultiple(self.node_selected)
455 #---------------------#
456 def handleRechercher(self):
457 #---------------------#
458 from monRecherche import DRecherche
459 monRechercheDialg=DRecherche(parent=self,fl=0)
460 monRechercheDialg.show()
462 #---------------------#
463 def handleDeplier(self):
464 #---------------------#
465 if self.tree == None : return
466 self.tree.collapseAll()
468 self.tree.collapseItem(self.tree.topLevelItem(0))
471 self.tree.expandItem(self.tree.topLevelItem(0))
474 #---------------------#
475 def handleEditCut(self):
476 #---------------------#
478 Stocke dans Eficas.noeud_a_editer le noeud a couper
480 #print "handleEditCut"
481 self.chercheNoeudSelectionne()
482 self.QWParent.edit="couper"
483 self.QWParent.noeud_a_editer = self.node_selected
485 #-----------------------#
486 def handleEditCopy(self):
487 #-----------------------#
489 Stocke dans Eficas.noeud_a_editer le noeud a copier
491 self.chercheNoeudSelectionne()
492 if len(self.node_selected) == 0 : return
493 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
494 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
495 self.QWParent.edit="copier"
496 self.QWParent.noeud_a_editer = self.node_selected
498 #------------------------#
499 def handleEditPaste(self):
500 #------------------------#
502 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
503 Ne permet que la copie d'objets de type Commande ou MCF
505 self.chercheNoeudSelectionne()
506 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
507 QMessageBox.information( self,
508 tr("Copie impossible"),
509 tr("Veuillez selectionner un objet a copier"))
511 if len(self.node_selected) != 1 :
512 QMessageBox.information( self,
513 tr("Copie impossible"),
514 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
517 if len(self.QWParent.noeud_a_editer)!=1:
518 self.handleEditPasteMultiple()
521 noeudOuColler=self.node_selected[0]
523 if noeudOuColler == self.tree.racine:
527 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
530 noeudACopier=self.QWParent.noeud_a_editer[0]
531 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
533 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
536 if (self.QWParent.edit != "couper"):
538 if noeudOuColler == self.tree.racine :
539 child=noeudOuColler.doPastePremier(noeudACopier)
541 child=noeudACopier.doPaste(noeudOuColler,pos)
542 if child==None or child==0:
543 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
545 self.affiche_infos("Copie refusee",Qt.red)
546 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
548 nom=noeudACopier.item.sd.nom
549 child.item.nomme_sd(nom)
556 traceback.print_exc()
557 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
559 self.affiche_infos("Copie refusee",Qt.red)
562 # il faut declarer le JDCDisplay_courant modifie
563 # suppression eventuelle du noeud selectionne
564 # si possible on renomme l objet comme le noeud couper
566 if (self.QWParent.edit == "couper"):
568 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
569 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
573 indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
574 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
575 noeudACopier.treeParent.build_children()
580 self.QWParent.noeud_a_editer=[]
582 # on rend la copie a nouveau possible en liberant le flag edit
583 self.QWParent.edit="copier"
584 noeudACopier.select()
586 #----------------------------------#
587 def handleDeplaceMultiple(self):
588 #----------------------------------#
591 #----------------------------------#
592 def handleEditPasteMultiple(self):
593 #----------------------------------#
595 # On ne garde que les niveaux "Etape"
596 # On insere dans l'ordre du JDC
597 listeNoeudsACouper=[]
601 from InterfaceQT4 import compojdc
602 noeudOuColler=self.node_selected[0]
603 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
604 QMessageBox.information( self,
605 tr("Copie impossible a cet endroit",),
606 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
608 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
610 for noeud in self.QWParent.noeud_a_editer :
611 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
612 indexInTree=noeud.treeParent.children.index(noeud)
614 for index in listeIndex:
615 if index < indexInTree : indice = indice +1
616 listeIndex.insert(indice, indexInTree)
617 listeNoeudsACouper.insert(indice, noeud)
619 noeudJdc=noeudOuColler.treeParent
621 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
623 for index in listeIndex:
625 if indexNoeudOuColler < index:
626 indexTravail=indexTravail+dejaCrees
627 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
628 noeud=noeudJdc.children[indexTravail]
629 child=noeud.doPaste(noeudOuColler)
630 listeChild.append(child)
631 dejaCrees=dejaCrees+1
633 self.QWParent.noeud_a_editer = []
634 for i in range(len(listeIndex)):
635 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
636 self.QWParent.noeud_a_editer.append(noeud)
639 if self.QWParent.edit !="couper" : return
641 for index in listeIndex:
643 if indexNoeudOuColler < index:
644 indexTravail=indexTravail+(len(listeIndex))
645 noeud=noeudJdc.children[indexTravail]
647 listeItem.append(noeud.item)
648 listeASupprimer.append(noeud)
650 for i in range(len(listeChild)):
651 self.tree.item.suppitem(listeItem[i])
652 listeChild[i].item.update(listeItem[i])
654 self.QWParent.noeud_a_editer = []
657 #---------------------#
658 def getFileName(self):
659 #---------------------#
662 #---------------------------#
663 def get_file_variable(self) :
664 #---------------------------#
665 titre = tr("Choix d'un fichier XML")
666 texte = tr("Le fichier contient une commande MODEL\n")
667 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
668 QMessageBox.information( self, titre,tr(texte))
670 fichier = QFileDialog.getOpenFileName(self.appliEficas,
671 tr('Ouvrir Fichier'),
672 self.appliEficas.CONFIGURATION.savedir,
673 self.appliEficas.trUtf8('Wrapper Files (*.xml);;''All Files (*)'))
676 #----------------------------------#
677 def writeFile(self, fn, txt = None):
678 #----------------------------------#
680 Public slot to write the text to a file.
682 @param fn filename to write to (string or QString)
683 @return flag indicating success
689 txt = self.get_text_JDC(self.format)
691 if len(txt) >= len(eol):
692 if txt[-len(eol):] != eol:
696 txt=self.ajoutVersionCataDsJDC(txt)
697 checksum=self.get_checksum(txt)
705 QMessageBox.critical(self, self.trUtf8('Save File'),
706 self.trUtf8('The file <b>%1</b> could not be saved.<br>Reason: %2')
707 .arg(unicode(fn)).arg(str(why)))
710 #-------------------------------------#
711 def get_text_JDC(self,format,pourRun=0):
712 #-------------------------------------#
713 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
714 if generator.plugins.has_key(format):
715 # Le generateur existe on l'utilise
716 self.generator=generator.plugins[format]()
718 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
719 if pourRun : jdc_formate=self.generator.textePourRun
721 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
722 if not self.generator.cr.estvide():
723 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
724 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
729 # Il n'existe pas c'est une erreur
730 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
731 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
737 fonction="run"+self.code
738 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
743 fonction="saveRun"+self.code
744 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
750 if not(self.jdc.isvalid()):
751 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
753 if len(self.jdc.etapes) != 1 :
754 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
756 if self.modified or self.fichier==None :
757 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
758 texte=self.get_text_JDC("MAP")
759 self.writeFile( self.fichierMapInput, txt = texte)
761 self.fichierMapInput=self.fichier
762 composant=self.jdc.etapes[0].nom.lower()[0:-5]
765 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
766 # then instantiate corresponding class and call getUseSalome() method
768 from mapengine.spec import factory
769 mapComponent = factory.new(composant)[0]
772 if mapComponent.getUseSalome():
773 command += " -r sappli"
774 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
777 self._viewTextExecute( textePython,"map_run",".sh")
779 commande="rm "+self.fichierMapInput
784 print traceback.print_exc()
786 #-------------------#
787 def runZCRACKS(self):
788 #-------------------#
789 if not(self.jdc.isvalid()):
790 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
792 if self.modified or self.fichier==None :
794 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
795 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
796 self.writeFile( self.fichierZcracksInput, txt = texte)
798 self.fichierZcracksInput=self.fichier
800 #commande ="Zrun -zp "
802 textePython=(commande + self.fichierZcracksInput)
803 self._viewTextExecute( textePython,"run_zcracks",".sh")
805 print traceback.print_exc()
807 #-------------------#
808 def runCARMELCND(self):
809 #-------------------#
810 #if not(self.jdc.isvalid()):
811 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
813 if self.modified or self.fichier==None :
814 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
816 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
817 from PrepareRunCarmel import prepareRunCarmel
818 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
819 repMed=os.path.dirname(self.fichier)
820 repExeCarmel=self.generator.get_repExeCarmel()
821 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
822 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
823 f=open(nomFichier,'w')
826 commande="xterm -e sh "+nomFichier +"\n"
829 # self._viewTextExecute( textePython,"carmel_run",".sh")
830 #except Exception, e:
831 # print traceback.print_exc()
833 #-------------------#
834 def runCarmelCS(self):
835 #-------------------#
837 commande="runSession pilotyacsCS.py"
840 print traceback.print_exc()
842 #-----------------------------------------------------#
843 def determineNomFichier(self,path,extension):
844 #-----------------------------------------------------#
845 if DictExtensions.has_key(self.appli.code) :
846 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
847 extensions= self.trUtf8(chaine1+ "All Files (*)")
849 extensions= self.trUtf8("JDC (*.comm);;" "All Files (*)")
851 if self.appli.code == "MAP" :
852 extensions = extensions + ";; Run (*.input);;"
854 fn = QFileDialog.getSaveFileName( self,
855 tr("sauvegarde"), path,
857 QFileDialog.DontConfirmOverwrite)
858 if fn.isNull(): return (0, None)
859 ext = QFileInfo(fn).suffix()
860 if ext.isEmpty(): fn.append(extension)
862 if QFileInfo(fn).exists():
863 abort = QMessageBox.warning(self,
864 tr("Sauvegarde du Fichier"),
865 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
867 self.trUtf8("&Abandonner"))
868 if abort == 1 : return (0, "")
872 def saveRunMAP(self):
875 if not(self.jdc.isvalid()):
876 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
877 tr("Un JdC valide est necessaire pour creer un .input")
881 composant=self.jdc.etapes[0].nom.lower()[0:-5]
883 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
884 tr("Choix du composant obligatoire")
887 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
888 else : path=os.environ['HOME']
891 if self.fichier is not None and self.fichier != "" :
892 maBase=str(QFileInfo(self.fichier).baseName())+".input"
893 monPath=str(QFileInfo(self.fichier).absolutePath())
894 monNomFichier=os.path.join(monPath,maBase)
895 elif hasattr(self,'monNomFichierInput'):
896 monNomFichier=self.monNomFichierInput
899 monDialog=QFileDialog(self.appliEficas)
900 monDialog.setDirectory (path)
901 monDialog.setWindowTitle ("Save")
903 for c in monDialog.children():
904 if isinstance(c,QDialogButtonBox):
905 for b in c.children():
906 if isinstance(b,QPushButton):
908 if avant.toLatin1()=="&Open":
910 mesFiltres=QStringList()
911 mesFiltres << "input Map (*.input)" << "All Files (*)"
912 monDialog.setNameFilters(mesFiltres)
913 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
914 BOk=monDialog.exec_()
916 fn=str(monDialog.selectedFiles()[0].toLatin1())
917 if fn == "" or fn == None : return
918 if not fn.endswith(".input"):
920 self.monNomFichierInput=fn
922 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
923 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
924 texte=self.get_text_JDC("MAP")
925 self.writeFile( self.fichierMapInput, txt = texte)
927 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
928 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
929 (output, err) = p.communicate()
932 #-----------------------------------------#
933 def cherche_Groupes(self):
934 #-----------------------------------------#
935 listeMA,listeNO=self.get_text_JDC("GroupMA")
936 return listeMA,listeNO
938 #-----------------------------------------#
939 def cherche_Dico(self):
940 #-----------------------------------------#
942 format = self.appliEficas.format_fichier
943 if generator.plugins.has_key(format):
944 # Le generateur existe on l'utilise
945 self.generator=generator.plugins[format]()
946 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
947 dicoCourant=self.generator.dico
952 #-----------------------------------------#
953 def handleAjoutGroup(self,listeGroup):
954 #-----------------------------------------#
957 from ajoutGroupe import handleAjoutGroupFiltre
959 handleAjoutGroupFiltre(self,listeGroup)
960 #print "apres handleAjoutGroupFiltre"
965 #-----------------------------------------#
966 def saveFile(self, path = None, saveas= 0):
967 #-----------------------------------------#
969 Public slot to save the text to a file.
971 @param path directory to save the file in (string or QString)
972 @return tuple of two values (boolean, string) giving a success indicator and
973 the name of the saved file
977 if not self.modified and not saveas:
978 return (0, None) # do nothing if text wasn't changed
981 if DictExtensions.has_key(self.appli.code) :
982 extension=DictExtensions[self.appli.code]
988 if self.fichier is None or saveas:
990 path=self.CONFIGURATION.savedir
991 bOK, fn=self.determineNomFichier(path,extension)
992 if bOK == 0 : return (0, None)
993 if fn == None : return (0, None)
994 if fn.isNull(): return (0, None)
996 ulfile = os.path.abspath(unicode(fn))
997 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
998 fn = unicode(QDir.convertSeparators(fn))
1001 if not (self.writeFile(fn)): return (0, None)
1003 self.modified = False
1004 if self.fileInfo is None or saveas:
1005 self.fileInfo = QFileInfo(self.fichier)
1006 self.fileInfo.setCaching(0)
1007 self.lastModified = self.fileInfo.lastModified()
1008 if newName is not None:
1009 self.appliEficas.addToRecentList(newName)
1010 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1011 self.tree.racine.update_node_label()
1013 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1014 self.generator.writeDefault(fn)
1017 self.appliEficas.addJdcInSalome( self.fichier)
1019 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1020 self.appliEficas.setWindowTitle(nouveauTitre)
1022 return (1, self.fichier)
1024 #----------------------------------------------#
1025 def saveFileAs(self, path = None,fileName=None):
1026 #----------------------------------------------#
1028 Public slot to save a file with a new name.
1030 @param path directory to save the file in (string or QString)
1031 @return tuple of two values (boolean, string) giving a success indicator and
1032 the name of the saved file
1034 if fileName != None :
1035 self.fichier = fileName
1036 return self.saveFile()
1037 return self.saveFile(path,1)
1041 #---------------------------------------------#
1042 def get_file(self,unite=None,fic_origine = ''):
1043 #---------------------------------------------#
1051 titre = tr("Choix unite %d ", unite)
1052 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1053 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1054 labeltexte = tr('Fichier pour unite ') + repr( unite)
1056 titre = tr("Choix d'un fichier de poursuite")
1057 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1058 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1060 QMessageBox.information( self, titre,QString.fromUtf8(texte))
1061 fn = QFileDialog.getOpenFileName(self.appliEficas,
1063 self.appliEficas.CONFIGURATION.savedir)
1066 # ce retour est impose par le get_file d'I_JDC
1069 ulfile = os.path.abspath(unicode(fn))
1070 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1072 # On utilise le convertisseur defini par format_fichier
1073 source=self.get_source(ulfile)
1075 # On a reussia convertir le fichier self.ulfile
1078 # Une erreur a ete rencontree
1080 return ulfile, jdcText
1082 #-------------------------------#
1083 def updateJdc(self, itemApres,texte):
1084 #--------------------------------#
1086 etape=monItem.item.object
1088 CONTEXT.set_current_step(etape)
1089 etape.build_includeInclude(texte)
1090 self.tree.racine.build_children()
1095 #-------------------------------------#
1096 def ajoutVersionCataDsJDC(self,txt):
1097 #-------------------------------------#
1098 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1099 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1100 texte=txt+ligneVersion
1103 #-------------------------------------#
1104 def verifieVersionCataDuJDC(self,text):
1105 #-------------------------------------#
1107 indexDeb=text.find("#VERSION_CATALOGUE:")
1108 indexFin=text.find(":FIN VERSION_CATALOGUE")
1110 self.versionCataDuJDC="sans"
1113 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1114 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1116 self.versionCata="sans"
1117 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1119 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1120 return memeVersion,textJDC
1122 #-------------------------------#
1123 def traduitCatalogue(self,texte):
1124 #-------------------------------#
1125 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1126 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1128 traducteur=__import__(nomTraducteur)
1129 monTraducteur=traducteur.MonTraducteur(texte)
1130 nouveauTexte=monTraducteur.traduit()
1136 #------------------------------#
1137 def verifieCHECKSUM(self,text):
1138 #------------------------------#
1139 indexDeb=text.find("#CHECKSUM:")
1142 indexFin=text.find(":FIN CHECKSUM")
1143 checkAvant=text[indexDeb:indexFin+13]
1144 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1145 checksum=self.get_checksum(textJDC)
1146 pareil=(checkAvant==checksum)
1147 return pareil, textJDC
1149 #---------------------------#
1150 def get_checksum(self,texte):
1151 #---------------------------#
1152 newtexte=texte.replace('"','\\"')
1153 commande='echo "'+newtexte+'"|md5sum'
1154 a=os.popen(commande)
1157 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1161 #---------------------------#
1162 def _newZCRACKS(self):
1163 #---------------------------#
1164 texte="MAILLAGES();REMESHING();"
1167 #---------------------------#
1168 def _newJDCCND(self):
1169 #---------------------------#
1170 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1172 #if self.salome == 0 :
1173 QMessageBox.information( self,
1175 tr("Veuillez selectionner un fichier Med"))
1176 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1177 caption='Fichier Med',
1179 self.fichierMED=str(QSfichier.toLatin1())
1180 from acquiertGroupes import getGroupes
1181 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1182 if erreur != "" : print "a traiter"
1183 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1189 for groupe in self.listeGroupes :
1190 if groupe[0:8]=='CURRENT_':
1191 texteSources +=groupe[8:]+"=SOURCE("
1192 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1193 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1194 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1195 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1196 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1197 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1198 self.newTexteCND=texte
1203 #---------------------------#
1204 def BoutonFileSelected(self):
1205 #---------------------------#
1207 QSfichier=self.openfile.selectedFiles()[0]
1208 self.fichierMED=str(QSfichier.toLatin1())
1209 from acquiertGroupes import getGroupes
1210 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1211 if erreur != "" : print "a traiter"
1213 #-----------------------------
1214 def BoutonSalomePressed(self):
1215 #----------------------------
1216 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1217 self.fichierMED="A_partir_de_SMESH"
1218 self.nomMaillage="A_partir_de_SMESH"
1219 self.openfile.close()
1222 if __name__ == "__main__":
1224 name='prefs_'+prefs.code
1225 prefsCode=__import__(name)
1228 if hasattr(prefsCode,'encoding'):
1229 # Hack pour changer le codage par defaut des strings
1232 sys.setdefaultencoding(prefs.encoding)
1233 del sys.setdefaultencoding
1238 app = QApplication(sys.argv)
1239 mw = JDCEditor(None,'azAster.comm')
1240 app.setMainWidget(mw)
1241 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1244 res = app.exec_loop()