1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2007-2013 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 import types,sys,os, re
24 from determine import monEnvQT5
26 from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
27 from PyQt5.QtGui import QPalette
28 from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
30 from PyQt4.QtGui import *
31 from PyQt4.QtCore import *
34 from datetime import date
35 from Extensions.i18n import tr
40 import convert, generator
41 from Editeur import session
42 from Editeur import comploader
43 from Editeur import Objecttreeitem
44 from desBaseWidget import Ui_baseWidget
45 from monViewTexte import ViewText
46 from monWidgetCreeParam import MonWidgetCreeParam
50 DictExtensions= {"MAP" : ".map"}
55 class JDCEditor(Ui_baseWidget,QWidget):
56 # ----------------------------------------- #
61 def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
62 #----------------------------------------------------------------------------------------------------------#
64 QWidget.__init__(self,None)
68 self.widgetOptionnel=None
69 self.fenetreCentraleAffichee=None
70 self.dejaDansPlieTout=False
71 self.afficheCommandesPliees = True
72 self.listeDesListesOuvertes=set()
73 self.appliEficas = appli
74 self.appli = appli #---- attendu par IHM
76 self.fichier = fichier
79 self.QWParent = QWParent
80 self.couleur = Qt.black
83 self.salome = self.appliEficas.salome
86 print "dans JDC pas d appli ????????"
88 # ces attributs sont mis a jour par definitCode appelee par newEditor
89 self.code = self.appliEficas.CONFIGURATION.code
91 #self.afficheListesPliees=False
92 self.afficheListesPliees=True
93 if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
94 if self.code == 'PSEN_N1' : self.afficheListesPliees = False
96 self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
97 self.affiche=self.appliEficas.CONFIGURATION.affiche
98 #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
99 if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
100 if self.code in ['MAP',] :
101 self.widgetTree.close()
103 self.appliEficas.resize(1440,self.appliEficas.height())
105 self.appliEficas.resize(1800,self.appliEficas.height())
107 self.version_code = session.d_env.cata
109 if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
110 self.readercata = readercata.READERCATA( self, self.appliEficas )
111 self.appliEficas.readercata=self.readercata
112 self.appliEficas.code=self.code
114 self.readercata=self.appliEficas.readercata
115 if self.readercata.fic_cata == None : return #Sortie Salome
116 self.titre=self.readercata.titre
117 self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
118 self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
120 self.format = self.appliEficas.format_fichier
123 self.splitterSizes = [320,1320,320]
124 self.oldSizeWidgetOptionnel = 320
125 self.liste_simp_reel=[]
128 nameConf='configuration_'+self.code
129 configuration=__import__(nameConf)
130 self.CONFIGURATION = self.appliEficas.CONFIGURATION
131 self.CONFIGStyle = self.appliEficas.CONFIGStyle
134 self.CONFIGURATION.generator_module
135 _module = __import__(self.CONFIGURATION.generator_module)
136 info = _module.entryPoint()
137 generator.plugins.addEntryPoint(info)
142 self.CONFIGURATION.convert_module
143 print self.CONFIGURATION.convert_module
144 _module = __import__(self.CONFIGURATION.convert_module)
145 info = _module.entryPoint()
146 convert.plugins.addEntryPoint(info)
151 if hasattr(self.appliEficas,"statusBar"):
152 self.sb = self.appliEficas.statusBar()
155 self.lastModified = 0
157 self.modified = False
158 self.isReadOnly = False
159 self.node_selected = []
162 if self.code in ['Adao','MAP'] : self.afficheApresInsert=True
163 else : self.afficheApresInsert=False
164 if self.code in ['TELEMAC',] : self.enteteQTree='premier'
165 else : self.enteteQTree='complet'
166 if self.code in ['Adao','TELEMAC'] : self.affichePlie=True
167 else : self.affichePlie=False
169 self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
171 #------- construction du jdc --------------
176 if self.fichier is not None: # fichier jdc fourni
177 self.fileInfo = QFileInfo(self.fichier)
178 self.fileInfo.setCaching(0)
182 self.jdc = self.readFile(self.fichier)
185 print "mauvaise lecture"
188 if self.jdc is not None and units is not None:
189 self.jdc.recorded_units=units
190 self.jdc.old_recorded_units=units
192 if not self.jdc: # nouveau jdc
194 self.jdc = self._newJDC(units=units)
196 self.jdc = self._newJDCInclude(units=units)
200 self.jdc.appli = self
201 self.jdc.lang = self.appli.langue
202 self.jdc.aReafficher=False
206 txt_exception = self.jdc.cr.get_mess_exception()
209 QApplication.restoreOverrideCursor()
210 self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
211 if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
213 comploader.charger_composants("QT")
214 jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
215 if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
216 self.viewJdcRapport()
220 if jdc_item and self.appliEficas.ssIhm==False:
221 self.tree = browser.JDCTree( jdc_item, self )
222 self.appliEficas.construitMenu()
225 self.splitterSizes = [320,1320,320]
226 self.splitter.setSizes(self.splitterSizes)
227 self.saveSplitterSizes()
230 #-------------------# Pour execution avec output et error dans le bash
232 #-------------------#
233 if self.modified or self.fichier==None : self.saveFile()
235 #lancement avec le .bat
236 path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
237 WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
239 p = subprocess.Popen(['python',WrapperFilePath])
240 (out,err)=p.communicate()
244 #-------------------# Pour execution avec output et error dans le bash
245 def runPSEN_N1(self):
246 #-------------------#
247 #cmd = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_N1','run.py'))
248 #cmd = "from run import runPSEN_N1; dico="+str(dico)
250 #textePython=("python "+ cmd + " "+ str(dico))
252 #self._viewTextExecute( textePython,"psen_run",".sh")
253 if generator.plugins.has_key('dicoImbrique'):
254 self.generator=generator.plugins['dicoImbrique']()
255 jdc_formate=self.generator.gener(self.jdc)
256 dico=self.generator.Dico
257 from variablesPSENN1 import PSEN_N1_Variables
258 mesVariables= PSEN_N1_Variables()
260 mesVariables.setValues(dico)
261 mesVariables.imprime()
263 from eficas_go import getJdcParameters
264 from run import runPSEN_N1
265 res,txt_exception=runPSEN_N1(dico)
266 if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
267 else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
271 #--------------------------------#
272 def _newJDC( self ,units = None):
273 #--------------------------------#
275 Initialise un nouveau JDC vierge
278 CONTEXT.unset_current_step()
281 if self.code == "CARMELCND" : texte=self._newJDCCND()
282 if self.code == "ZCRACKS" : texte=self._newZCRACKS()
283 if self.code == "TELEMAC" : texte=self._newTELEMAC()
284 if self.code == "PSEN" : texte = self._newPSEN()
285 if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
286 # texte=self.newTexteCND
288 jdc=self.readercata.cata[0].JdC( procedure =texte,
290 cata=self.readercata.cata,
291 cata_ord_dico=self.readercata.cata_ordonne_dico,
292 rep_mat=self.CONFIGURATION.rep_mat
294 jdc.lang = self.appli.langue
295 if units is not None:
296 jdc.recorded_units=units
297 jdc.old_recorded_units=units
298 ## PNPN est ce que la ligne suivante est bien utile ?
299 if texte == "" :jdc.analyse()
302 #--------------------------------#
303 def _newJDCInclude( self ,units = None):
304 #--------------------------------#
306 Initialise un nouveau JDC vierge
308 import Extensions.jdc_include
309 JdC_aux=Extensions.jdc_include.JdC_include
310 CONTEXT.unset_current_step()
312 jaux=self.readercata.cata[0].JdC( procedure="",
314 cata=self.readercata.cata,
315 cata_ord_dico=self.readercata.cata_ordonne_dico,
316 rep_mat=self.CONFIGURATION.rep_mat,
320 J=JdC_aux( procedure="",
322 cata=self.readercata.cata,
323 cata_ord_dico=self.readercata.cata_ordonne_dico,
325 rep_mat=self.CONFIGURATION.rep_mat,
328 if units is not None:
329 J.recorded_units=units
330 J.old_recorded_units=units
334 #-------------------------------#
335 def readFile(self, fn):
336 #--------------------------------#
338 Public slot to read the text from a file.
339 @param fn filename to read from (string or QString)
343 # ------------------------------------------------------------------------------------
345 # ------------------------------------------------------------------------------------
347 jdcName=os.path.basename(fn)
348 # Il faut convertir le contenu du fichier en fonction du format
349 if convert.plugins.has_key( self.appliEficas.format_fichier_in ):
350 # Le convertisseur existe on l'utilise
352 p=convert.plugins[self.appliEficas.format_fichier_in]()
354 if p.text=="" : self.nouveau=1
355 pareil,texteNew=self.verifieCHECKSUM(p.text)
357 if pareil == False and (self.appliEficas.ssIhm == False) :
358 QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
360 memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
361 if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
363 text=p.convert('exec',self.appliEficas)
364 if not p.cr.estvide():
365 self.affiche_infos("Erreur a la conversion",Qt.red)
367 self.affiche_infos("Type de fichier non reconnu",Qt.red)
368 if self.appliEficas.ssIhm == False:
369 QMessageBox.critical( self, tr("Type de fichier non reconnu"),
370 tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
373 CONTEXT.unset_current_step()
374 jdc=self.readercata.cata[0].JdC(procedure=text,
376 cata=self.readercata.cata,
377 cata_ord_dico=self.readercata.cata_ordonne_dico,
379 rep_mat=self.CONFIGURATION.rep_mat
381 # ----------------------------------------------------
383 # ----------------------------------------------------
384 self.modified = False
386 # qApp.restoreOverrideCursor()
387 if self.fileInfo!= None :
388 self.lastModified = self.fileInfo.lastModified()
390 self.lastModified = 1
391 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
392 self.appliEficas.setWindowTitle(nouveauTitre)
396 #-----------------------#
397 def get_source(self,file):
398 #-----------------------#
400 # Il faut convertir le contenu du fichier en fonction du format
401 if convert.plugins.has_key(self.format):
402 # Le convertisseur existe on l'utilise
403 p=convert.plugins[self.format]()
405 text=p.convert('execnoparseur')
406 if not p.cr.estvide():
407 self.affiche_infos("Erreur a la conversion",Qt.red)
410 # Il n'existe pas c'est une erreur
411 self.affiche_infos("Type de fichier non reconnu",Qt.red)
412 QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
415 #-----------------------------------------------------------------------#
416 def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
417 #--------------------------------------------------------------------#
418 w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
422 #----------------------------------------------#
423 def __generateTempFilename(self, prefix, suffix):
424 #----------------------------------------------#
426 (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
432 #----------------------------------------------#
433 def _viewTextExecute(self, txt, prefix, suffix):
434 #----------------------------------------------#
435 self.w = ViewText( self.QWParent )
436 self.w.setWindowTitle( "execution" )
437 self.monExe=QProcess(self.w)
438 pid=self.monExe.pid()
439 nomFichier = self.__generateTempFilename(prefix, suffix = ".sh")
440 f=open(nomFichier,'w')
444 self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
445 self.monExe.readyReadStandardError.connect( self.readFromStdErr)
447 self.connect(self.monExe, SIGNAL("readyReadStandardOutput()"), self.readFromStdOutQT4 )
448 self.connect(self.monExe, SIGNAL("readyReadStandardError()"), self.readFromStdErrQT4 )
449 exe='sh ' + nomFichier
450 self.monExe.start(exe)
451 self.monExe.closeWriteChannel()
454 commande="rm "+ nomFichier
459 def readFromStdErr(self):
460 a=self.monExe.readAllStandardError()
461 self.w.view.append(str(a.data(),len(a)))
463 def readFromStdErr(self) :
464 a=self.monExe.readAllStandardOutput()
465 self.w.view.append(str(a.data(),len(a)))
467 def readFromStdErrQT4(self):
468 a=self.monExe.readAllStandardError()
469 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
471 def readFromStdOutQT4(self) :
472 a=self.monExe.readAllStandardOutput()
473 self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
477 #-----------------------#
478 def gestionParam(self):
479 #-----------------------#
480 w = MonWidgetCreeParam( self)
483 #-----------------------#
484 def viewJdcSource(self):
485 #-----------------------#
486 f=open(self.fichier,'r')
489 self._viewText(texteSource, "JDC_SOURCE")
491 #-----------------------#
493 #-----------------------#
494 strSource = str( self.get_text_JDC(self.format) )
495 self._viewText(strSource, "JDC_RESULTAT")
497 #-----------------------#
498 def viewJdcRapport(self):
499 #-----------------------#
500 strRapport = unicode( self.jdc.report() )
501 # on ajoute les regles
503 self._viewText(strRapport, "JDC_RAPPORT")
505 #-----------------------#
506 def viewJdcRegles(self):
507 #-----------------------#
508 if self.tree :self.tree.AppelleBuildLBRegles()
515 Public method called by the viewmanager to finally get rid of us.
521 #----------------------------------------------#
522 def affiche_infos(self,message,couleur=Qt.black):
523 #----------------------------------------------#
525 mapalette=self.sb.palette()
526 mapalette.setColor( QPalette.WindowText, couleur )
527 self.sb.setPalette( mapalette );
528 self.sb.showMessage(message,4000)
531 #------------------------------#
532 def affiche_alerte(self,titre,message):
533 #------------------------------#
534 # appele par I_MACRO_ETAPE
535 QMessageBox.information( self, titre, message)
537 #-----------------------------------#
538 def affiche_commentaire(self,message):
539 #-----------------------------------#
540 self.labelCommentaire.setText(message)
541 QTimer.singleShot(6000, self.rendInvisible)
543 #----------------------#
544 def rendInvisible(self):
545 #----------------------#
546 self.labelCommentaire.setText("")
548 #-------------------#
549 def init_modif(self):
550 #-------------------#
552 Met l'attribut modified a 'o' : utilise par Eficas pour savoir
553 si un JDC doit etre sauvegarde avant destruction ou non
557 #---------------------------------------#
558 def chercheNoeudSelectionne(self,copie=1):
559 #---------------------------------------#
561 appele par Cut et Copy pour positionner self.node_selected
563 self.node_selected=[]
564 if len(self.tree.selectedItems()) == 0 : return
565 self.node_selected=self.tree.selectedItems()
568 #---------------------#
569 def handleSupprimer(self):
570 #---------------------#
571 self.chercheNoeudSelectionne()
572 if len(self.node_selected) == 0 : return
573 self.QWParent.noeud_a_editer = []
574 if self.node_selected[0]==self.tree.racine: return
575 if len(self.node_selected) == 1 : self.node_selected[0].delete()
576 else : self.node_selected[0].deleteMultiple(self.node_selected)
578 #---------------------#
579 def handleRechercher(self):
580 #---------------------#
581 from monRecherche import DRecherche
582 monRechercheDialg=DRecherche(parent=self,fl=0)
583 monRechercheDialg.show()
585 #---------------------#
586 def handleDeplier(self):
587 #---------------------#
588 if self.tree == None : return
589 #self.tree.collapseAll()
592 self.tree.expandItem(self.tree.topLevelItem(0))
594 if self.fenetreCentraleAffichee != None :
595 if hasattr(self.fenetreCentraleAffichee.node,'plieToutEtReaffiche'):
596 self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
599 self.tree.expandItem(self.tree.topLevelItem(0))
601 if self.fenetreCentraleAffichee != None :
602 if hasattr(self.fenetreCentraleAffichee.node,'deplieToutEtReaffiche'):
603 self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
605 #---------------------#
606 def handleEditCut(self):
607 #---------------------#
609 Stocke dans Eficas.noeud_a_editer le noeud a couper
611 #print "handleEditCut"
612 self.chercheNoeudSelectionne()
613 self.QWParent.edit="couper"
614 self.QWParent.noeud_a_editer = self.node_selected
616 #-----------------------#
617 def handleEditCopy(self):
618 #-----------------------#
620 Stocke dans Eficas.noeud_a_editer le noeud a copier
622 self.chercheNoeudSelectionne()
623 if len(self.node_selected) == 0 : return
624 if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
625 else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
626 self.QWParent.edit="copier"
627 self.QWParent.noeud_a_editer = self.node_selected
629 #------------------------#
630 def handleEditPaste(self):
631 #------------------------#
633 Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
634 Ne permet que la copie d'objets de type Commande ou MCF
636 self.chercheNoeudSelectionne()
637 if (not(hasattr(self.QWParent,'noeud_a_editer'))) or len(self.QWParent.noeud_a_editer)==0:
638 QMessageBox.information( self,
639 tr("Copie impossible"),
640 tr("Veuillez selectionner un objet a copier"))
642 if len(self.node_selected) != 1 :
643 QMessageBox.information( self,
644 tr("Copie impossible"),
645 tr("Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"))
648 if len(self.QWParent.noeud_a_editer)!=1:
649 self.handleEditPasteMultiple()
652 noeudOuColler=self.node_selected[0]
654 if noeudOuColler == self.tree.racine:
658 #indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
659 indexNoeudOuColler=self.getTreeIndex(noeudOuColler)
662 noeudACopier=self.QWParent.noeud_a_editer[0]
663 #indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
664 indexNoeudACopier=self.getTreeIndex(noeudACopier)
666 QMessageBox.information( self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe"))
669 if (self.QWParent.edit != "couper"):
671 if noeudOuColler == self.tree.racine :
672 child=noeudOuColler.doPastePremier(noeudACopier)
674 child=noeudACopier.doPaste(noeudOuColler,pos)
675 if child==None or child==0:
676 QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
678 self.affiche_infos("Copie refusee",Qt.red)
679 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
681 nom=noeudACopier.item.sd.nom
682 child.item.nomme_sd(nom)
689 traceback.print_exc()
690 QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
692 self.affiche_infos("Copie refusee",Qt.red)
695 # il faut declarer le JDCDisplay_courant modifie
696 # suppression eventuelle du noeud selectionne
697 # si possible on renomme l objet comme le noeud couper
699 if (self.QWParent.edit == "couper"):
701 if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
702 QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
706 # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
707 indexNoeudACopier=self.getTreeIndex(noeudACopier)
708 noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
709 noeudACopier.treeParent.build_children()
714 self.QWParent.noeud_a_editer=[]
716 # on rend la copie a nouveau possible en liberant le flag edit
717 self.QWParent.edit="copier"
718 noeudACopier.select()
720 #----------------------------------#
721 def handleDeplaceMultiple(self):
722 #----------------------------------#
725 #----------------------------------#
726 def handleEditPasteMultiple(self):
727 #----------------------------------#
729 # On ne garde que les niveaux "Etape"
730 # On insere dans l'ordre du JDC
731 listeNoeudsACouper=[]
735 from InterfaceQT4 import compojdc
736 noeudOuColler=self.node_selected[0]
737 if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
738 QMessageBox.information( self,
739 tr("Copie impossible a cet endroit",),
740 tr("Veuillez selectionner une commande, un parametre, un commentaire ou une macro"))
742 indexNoeudOuColler=noeudOuColler.treeParent.children.index(noeudOuColler)
744 for noeud in self.QWParent.noeud_a_editer :
745 if not (isinstance(noeud.treeParent, compojdc.Node)): continue
746 indexInTree=noeud.treeParent.children.index(noeud)
748 for index in listeIndex:
749 if index < indexInTree : indice = indice +1
750 listeIndex.insert(indice, indexInTree)
751 listeNoeudsACouper.insert(indice, noeud)
753 noeudJdc=noeudOuColler.treeParent
755 # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
757 for index in listeIndex:
759 if indexNoeudOuColler < index:
760 indexTravail=indexTravail+dejaCrees
761 noeudOuColler=noeudJdc.children[indexNoeudOuColler]
762 noeud=noeudJdc.children[indexTravail]
763 child=noeud.doPaste(noeudOuColler)
764 listeChild.append(child)
765 dejaCrees=dejaCrees+1
767 self.QWParent.noeud_a_editer = []
768 for i in range(len(listeIndex)):
769 noeud=noeudJdc.children[indexNoeudOuColler+1+i]
770 self.QWParent.noeud_a_editer.append(noeud)
773 if self.QWParent.edit !="couper" : return
775 for index in listeIndex:
777 if indexNoeudOuColler < index:
778 indexTravail=indexTravail+(len(listeIndex))
779 noeud=noeudJdc.children[indexTravail]
781 listeItem.append(noeud.item)
782 listeASupprimer.append(noeud)
784 for i in range(len(listeChild)):
785 self.tree.item.suppitem(listeItem[i])
786 listeChild[i].item.update(listeItem[i])
788 self.QWParent.noeud_a_editer = []
791 #---------------------#
792 def getFileName(self):
793 #---------------------#
796 #---------------------------#
797 def get_file_variable(self) :
798 #---------------------------#
799 titre = tr("Choix d'un fichier XML")
800 texte = tr("Le fichier contient une commande MODEL\n")
801 texte = texte+tr('Donnez le nom du fichier XML qui contient la description des variables')
802 QMessageBox.information( self, titre,tr(texte))
804 fichier = QFileDialog.getOpenFileName(self.appliEficas,
805 tr('Ouvrir Fichier'),
806 self.appliEficas.CONFIGURATION.savedir,
807 tr('Wrapper Files (*.xml);;''All Files (*)'))
810 #--------------------------------------------------#
811 def writeFile(self, fn, txt = None,formatLigne="beautifie"):
812 #--------------------------------------------------#
814 Public slot to write the text to a file.
816 @param fn filename to write to string
817 @return flag indicating success
823 txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
825 if len(txt) >= len(eol):
826 if txt[-len(eol):] != eol:
830 txt=self.ajoutVersionCataDsJDC(txt)
831 checksum=self.get_checksum(txt)
839 QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
840 tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
843 #-----------------------------------------------------------#
844 def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
845 #-----------------------------------------------------------#
846 if self.code == "MAP" and not(generator.plugins.has_key(format)): format = "MAP"
847 if generator.plugins.has_key(format):
849 # Le generateur existe on l'utilise
850 self.generator=generator.plugins[format]()
852 jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION)
853 if pourRun : jdc_formate=self.generator.textePourRun
855 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
856 if not self.generator.cr.estvide():
857 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
858 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
863 # Il n'existe pas c'est une erreur
864 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
865 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
872 fonction="run"+self.code
874 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
879 fonction="saveRun"+self.code
880 if fonction in JDCEditor.__dict__.keys(): apply(JDCEditor.__dict__[fonction],(self,))
886 if not(self.jdc.isvalid()):
887 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
889 if len(self.jdc.etapes) != 1 :
890 QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
892 if self.modified or self.fichier==None :
893 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
894 texte=self.get_text_JDC("MAP")
895 self.writeFile( self.fichierMapInput, txt = texte)
897 self.fichierMapInput=self.fichier
898 composant=self.jdc.etapes[0].nom.lower()[0:-5]
901 # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
902 # then instantiate corresponding class and call getUseSalome() method
904 from mapengine.spec import factory
905 mapComponent = factory.new(composant)[0]
908 if mapComponent.getUseSalome():
909 command += " -r sappli"
910 textePython=(command + " run -n "+composant +" -i "+self.fichierMapInput)
913 self._viewTextExecute( textePython,"map_run",".sh")
915 # commande="rm "+self.fichierMapInput
916 # os.system(commande)
920 print traceback.print_exc()
922 #-------------------#
923 def runZCRACKS(self):
924 #-------------------#
925 if not(self.jdc.isvalid()):
926 QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
928 if self.modified or self.fichier==None :
930 self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
931 texte=self.get_text_JDC("ZCRACKS",pourRun=1)
932 self.writeFile( self.fichierZcracksInput, txt = texte)
934 self.fichierZcracksInput=self.fichier
936 #commande ="Zrun -zp "
938 textePython=(commande + self.fichierZcracksInput)
939 self._viewTextExecute( textePython,"run_zcracks",".sh")
941 print traceback.print_exc()
943 #-------------------#
944 def runCARMELCND(self):
945 #-------------------#
946 #if not(self.jdc.isvalid()):
947 # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
949 if self.modified or self.fichier==None :
950 QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
952 if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
953 from PrepareRunCarmel import prepareRunCarmel
954 fichierGenerique=os.path.basename(self.fichier).split(".")[0]
955 repMed=os.path.dirname(self.fichier)
956 repExeCarmel=self.generator.get_repExeCarmel()
957 textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
958 nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
959 f=open(nomFichier,'w')
962 commande="xterm -e sh "+nomFichier +"\n"
965 # self._viewTextExecute( textePython,"carmel_run",".sh")
966 #except Exception, e:
967 # print traceback.print_exc()
969 #-------------------#
970 def runCarmelCS(self):
971 #-------------------#
973 commande="runSession pilotyacsCS.py"
976 print traceback.print_exc()
978 #-----------------------------------------------------#
979 def determineNomFichier(self,path,extension):
980 #-----------------------------------------------------#
981 if DictExtensions.has_key(self.appli.code) :
982 chaine1="JDC (*"+DictExtensions[self.appli.code]+");;"
983 extensions= tr(chaine1+ "All Files (*)")
985 extensions= tr("JDC (*.comm);;" "All Files (*)")
987 if self.appli.code == "MAP" :
988 extensions = extensions + ";; Run (*.input);;"
990 fn = QFileDialog.getSaveFileName( self,
991 tr("sauvegarde"), path,
993 QFileDialog.DontConfirmOverwrite)
994 if fn == None : return (0, None)
995 if monEnvQT5 : fn=fn[0]
996 if fn=='': return (0, None)
998 ext = QFileInfo(fn).suffix()
999 if ext == '': fn+=extension
1001 if QFileInfo(fn).exists():
1003 msgBox = QMessageBox(self)
1004 msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
1005 msgBox.setText(tr("Le fichier <b>%s</b> existe deja.", unicode(fn)))
1006 msgBox.addButton(tr("&Ecraser"),0)
1007 msgBox.addButton(tr("&Abandonner"),1)
1008 abort=msgBox.exec_()
1010 abort = QMessageBox.warning(self,
1011 tr("Sauvegarde du Fichier"),
1012 tr("Le fichier <b>%s</b> existe deja.",str(fn)),
1015 if abort == 1 : return (0, "")
1019 def saveRunMAP(self):
1022 if not(self.jdc.isvalid()):
1023 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1024 tr("Un JdC valide est necessaire pour creer un .input")
1028 composant=self.jdc.etapes[0].nom.lower()[0:-5]
1030 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1031 tr("Choix du composant obligatoire")
1034 if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
1038 if self.fichier is not None and self.fichier != "" :
1039 maBase=str(QFileInfo(self.fichier).baseName())+".input"
1040 monPath=str(QFileInfo(self.fichier).absolutePath())
1041 monNomFichier=os.path.join(monPath,maBase)
1042 elif hasattr(self,'monNomFichierInput'):
1043 monNomFichier=self.monNomFichierInput
1046 monDialog=QFileDialog(self.appliEficas)
1047 monDialog.setDirectory (path)
1048 monDialog.setWindowTitle ("Save")
1050 for c in monDialog.children():
1051 if isinstance(c,QDialogButtonBox):
1052 for b in c.children():
1053 if isinstance(b,QPushButton):
1055 if (not monEnvQT5) and avant.toLatin1()=="&Open": b.setText("Save")
1056 if monEnvQT5 and avant=="&Open": b.setText("Save")
1058 mesFiltres= "input Map (*.input);;All Files (*)"
1060 mesFiltres=QStringList()
1061 mesFiltres << "input Map (*.input)" << "All Files (*)"
1062 monDialog.setNameFilters(mesFiltres)
1063 if monNomFichier!="" : monDialog.selectFile(monNomFichier)
1064 BOk=monDialog.exec_()
1066 if monEnvQT5 : fn=str(monDialog.selectedFiles()[0])
1067 else : fn=str(monDialog.selectedFiles()[0].toLatin1())
1068 if fn == "" or fn == None : return
1069 if not fn.endswith(".input"):
1071 self.monNomFichierInput=fn
1073 if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
1074 self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
1075 texte=self.get_text_JDC("MAP")
1076 self.writeFile( self.fichierMapInput, txt = texte)
1078 cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
1079 p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1080 (output, err) = p.communicate()
1084 def saveRunPSEN(self):
1089 if not(self.jdc.isvalid()):
1090 QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
1091 tr("Un JdC valide est necessaire pour creer un .input")
1095 print generator.plugins.has_key(self.format)
1096 if generator.plugins.has_key(self.format):
1097 # Le generateur existe on l'utilise
1098 self.generator=generator.plugins[self.format]()
1100 self.generator.gener(self.jdc)
1101 self.generator.writeDefault('')
1102 except ValueError,e:
1103 QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
1104 if not self.generator.cr.estvide():
1105 self.affiche_infos(tr("Erreur a la generation"),Qt.red)
1106 QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
1109 # Il n'existe pas c'est une erreur
1110 self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
1111 QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
1118 #-----------------------------------------#
1119 def cherche_Groupes(self):
1120 #-----------------------------------------#
1121 listeMA,listeNO=self.get_text_JDC("GroupMA")
1122 return listeMA,listeNO
1124 #-----------------------------------------#
1125 def cherche_Dico(self):
1126 #-----------------------------------------#
1128 format = self.appliEficas.format_fichier
1129 if generator.plugins.has_key(format):
1130 # Le generateur existe on l'utilise
1131 self.generator=generator.plugins[format]()
1132 jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
1133 dicoCourant=self.generator.dico
1138 #-----------------------------------------#
1139 def handleAjoutGroup(self,listeGroup):
1140 #-----------------------------------------#
1143 from ajoutGroupe import handleAjoutGroupFiltre
1145 handleAjoutGroupFiltre(self,listeGroup)
1146 #print "apres handleAjoutGroupFiltre"
1151 #-----------------------------------------------------------------#
1152 def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
1153 #-----------------------------------------------------------------#
1155 Public slot to save the text to a file.
1157 @param path directory to save the file in (string or QString)
1158 @return tuple of two values (boolean, string) giving a success indicator and
1159 the name of the saved file
1163 if not self.modified and not saveas:
1164 return (0, None) # do nothing if text wasn't changed
1167 if DictExtensions.has_key(self.appli.code) :
1168 extension=DictExtensions[self.appli.code]
1174 if self.fichier is None or saveas:
1175 if path is None: path=self.CONFIGURATION.savedir
1176 bOK, fn=self.determineNomFichier(path,extension)
1177 if bOK == 0 : return (0, None)
1178 if fn == None : return (0, None)
1179 if fn== '' : return (0, None)
1181 ulfile = os.path.abspath(unicode(fn))
1182 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1183 fn = unicode(QDir.toNativeSeparators(fn))
1187 if not (self.writeFile(fn,formatLigne=formatLigne)): return (0, None)
1189 self.modified = False
1190 if self.fileInfo is None or saveas:
1191 self.fileInfo = QFileInfo(self.fichier)
1192 self.fileInfo.setCaching(0)
1193 self.lastModified = self.fileInfo.lastModified()
1194 if newName is not None:
1195 self.appliEficas.addToRecentList(newName)
1196 self.tree.racine.item.getObject().nom=os.path.basename(newName)
1197 self.tree.racine.update_node_label()
1199 if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
1200 self.generator.writeDefault(fn)
1201 if self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
1202 self.generator.writeDefault(fn)
1205 self.appliEficas.addJdcInSalome( self.fichier)
1207 nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
1208 self.appliEficas.setWindowTitle(nouveauTitre)
1210 return (1, self.fichier)
1213 #----------------------------------------------#
1214 def sauveLigneFile(self):
1215 #----------------------------------------------#
1217 return self.saveFile(formatLigne="Ligne")
1220 #----------------------------------------------#
1221 def saveFileAs(self, path = None,fileName=None):
1222 #----------------------------------------------#
1224 Public slot to save a file with a new name.
1226 @param path directory to save the file in (string or QString)
1227 @return tuple of two values (boolean, string) giving a success indicator and
1228 the name of the saved file
1230 if fileName != None :
1231 self.fichier = fileName
1232 return self.saveFile()
1233 return self.saveFile(path,1,"beautifie")
1237 #---------------------------------------------#
1238 def get_file(self,unite=None,fic_origine = ''):
1239 #---------------------------------------------#
1247 titre = tr("Choix unite %d ", unite)
1248 texte = tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine)) +"\n"
1249 texte = texte+ tr("Donnez le nom du fichier correspondant a l unite logique ") + repr(unite)
1250 labeltexte = tr('Fichier pour unite ') + repr( unite)
1252 titre = tr("Choix d'un fichier de poursuite")
1253 texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
1254 texte = texte+tr('Donnez le nom du fichier dont vous \n voulez faire une poursuite')
1256 QMessageBox.information( self, titre,texte)
1257 fn = QFileDialog.getOpenFileName(self.appliEficas,
1259 self.appliEficas.CONFIGURATION.savedir)
1261 # ce retour est impose par le get_file d'I_JDC
1262 if fn== '' : return None," "
1263 if not fn : return (0, " ")
1264 if monEnvQT5 : fn=fn[0]
1266 ulfile = os.path.abspath(unicode(fn))
1267 self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
1269 # On utilise le convertisseur defini par format_fichier
1270 source=self.get_source(ulfile)
1272 # On a reussia convertir le fichier self.ulfile
1275 # Une erreur a ete rencontree
1277 return ulfile, jdcText
1279 #-------------------------------#
1280 def updateJdc(self, itemApres,texte):
1281 #--------------------------------#
1283 etape=monItem.item.object
1285 CONTEXT.set_current_step(etape)
1286 etape.build_includeInclude(texte)
1287 self.tree.racine.build_children()
1289 #-------------------------------------#
1290 def deleteMC(self,etape,MCFils):
1291 #-------------------------------------#
1292 print "je passe dans deleteMC"
1293 monMC=etape.get_child(MCFils,restreint="oui")
1294 if monMC != None : print etape.suppentite(monMC)
1297 #-------------------------------------#
1298 def ajoutMC(self,etape,MCFils,valeurs):
1299 #-------------------------------------#
1300 print "je passe dans ajoutMC"
1301 monMC=etape.get_child(MCFils,restreint="oui")
1302 if monMC== None : monMC= etape.addentite(MCFils)
1303 monMC.valeur=valeurs
1305 monMC.state='changed'
1306 #print monMC.isvalid()
1308 #-------------------------------------#
1309 def changeIntoMC(self,etape,MCFils,valeurs):
1310 #-------------------------------------#
1311 print "je passe dans changeIntoMC"
1312 monMC=etape.get_child(MCFils,restreint="oui")
1313 if monMC== None : monMC= etape.addentite(MCFils)
1314 monMC.definition.into=valeurs
1316 #-------------------------------------#
1317 def changeIntoDefMC(self,etape,listeMC,valeurs):
1318 #-------------------------------------#
1319 definitionEtape=getattr(self.jdc.cata[0],etape)
1320 ouChercher=definitionEtape
1321 if len(listeMC) > 1 :
1322 for mc in listeMC[0:-1]:
1323 mcfact=ouChercher.entites[mc]
1326 mcAccas=ouChercher.entites[listeMC[-1]]
1327 mcAccas.into=valeurs
1329 #-----------------------------------------#
1330 def ajoutDefinitionMC(self,etape,nomDuMC,typ,**args):
1331 #-----------------------------------------#
1332 definitionEtape=getattr(self.jdc.cata[0],etape)
1333 from Accas import A_SIMP
1334 Nouveau=A_SIMP.SIMP(typ,**args)
1335 Nouveau.pere=definitionEtape
1338 definitionEtape.entites[nomDuMC]=Nouveau
1339 definitionEtape.ordre_mc.append(nomDuMC)
1341 #----------------------------------------------------#
1342 def changeIntoMCandSet(self,etape,MCFils,into,valeurs):
1343 #----------------------------------------------------#
1344 monMC=etape.get_child(MCFils,restreint="oui")
1345 if monMC== None : monMC= etape.addentite(MCFils)
1346 monMC.definition.into=into
1347 monMC.valeur=valeurs
1349 monMC.state='changed'
1352 #-------------------------------------#
1353 def ajoutVersionCataDsJDC(self,txt):
1354 #-------------------------------------#
1355 if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
1356 ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
1357 texte=txt+ligneVersion
1360 #-------------------------------------#
1361 def verifieVersionCataDuJDC(self,text):
1362 #-------------------------------------#
1364 indexDeb=text.find("#VERSION_CATALOGUE:")
1365 indexFin=text.find(":FIN VERSION_CATALOGUE")
1367 self.versionCataDuJDC="sans"
1370 self.versionCataDuJDC=text[indexDeb+19:indexFin]
1371 textJDC=text[0:indexDeb]+text[indexFin+23:-1]
1373 self.versionCata="sans"
1374 if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
1376 if self.versionCata==self.versionCataDuJDC : memeVersion=True
1377 return memeVersion,textJDC
1379 #-------------------------------#
1380 def traduitCatalogue(self,texte):
1381 #-------------------------------#
1382 nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
1383 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
1385 traducteur=__import__(nomTraducteur)
1386 monTraducteur=traducteur.MonTraducteur(texte)
1387 nouveauTexte=monTraducteur.traduit()
1393 #------------------------------#
1394 def verifieCHECKSUM(self,text):
1395 #------------------------------#
1396 indexDeb=text.find("#CHECKSUM:")
1399 indexFin=text.find(":FIN CHECKSUM")
1400 checkAvant=text[indexDeb:indexFin+13]
1401 textJDC=text[0:indexDeb]+text[indexFin+13:-1]
1402 checksum=self.get_checksum(textJDC)
1403 pareil=(checkAvant==checksum)
1404 return pareil, textJDC
1406 #---------------------------#
1407 def get_checksum(self,texte):
1408 #---------------------------#
1409 newtexte=texte.replace('"','\\"')
1410 commande='echo "'+newtexte+'"|md5sum'
1411 a=os.popen(commande)
1414 ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
1418 #---------------------------#
1419 def _newTELEMAC(self):
1420 #---------------------------#
1421 #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
1425 #---------------------------#
1427 #---------------------------#
1428 texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
1432 #---------------------------#
1433 def _newPSEN_N1(self):
1434 #---------------------------#
1435 #texte="CASE_SELECTION() ; CONTINGENCY_OPTIONS() ; OUTPUT_OPTIONS() ; "
1439 #---------------------------#
1441 #---------------------------#
1442 def _newZCRACKS(self):
1443 #---------------------------#
1444 texte="MAILLAGES();REMESHING();"
1447 #---------------------------#
1448 def _newJDCCND(self):
1449 #---------------------------#
1450 extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
1452 #if self.salome == 0 :
1453 QMessageBox.information( self,
1455 tr("Veuillez selectionner un fichier Med"))
1456 QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
1457 caption='Fichier Med',
1459 if monEnvQT5 : QSfichier=QSfichier[0]
1460 self.fichierMED=QSfichier
1461 from acquiertGroupes import getGroupes
1462 erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
1463 if erreur != "" : print "a traiter"
1464 texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
1470 for groupe in self.listeGroupes :
1471 if groupe[0:8]=='CURRENT_':
1472 texteSources +=groupe[8:]+"=SOURCE("
1473 texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
1474 if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
1475 if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
1476 if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
1477 if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
1478 texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
1479 self.newTexteCND=texte
1484 #---------------------------#
1485 def BoutonFileSelected(self):
1486 #---------------------------#
1488 QSfichier=self.openfile.selectedFiles()[0]
1489 self.fichierMED=str(QSfichier)
1490 from acquiertGroupes import getGroupes
1491 erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
1492 if erreur != "" : print "a traiter"
1494 #-----------------------------
1495 def BoutonSalomePressed(self):
1496 #----------------------------
1497 Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
1498 self.fichierMED="A_partir_de_SMESH"
1499 self.nomMaillage="A_partir_de_SMESH"
1500 self.openfile.close()
1502 #-------------------------------------
1503 def saveSplitterSizes(self,event=None):
1504 #------------------------------------
1505 if self.inhibeSplitter : return
1506 if not hasattr(self,'splitter') : return
1507 if self.splitterSizes[2] != 0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
1508 #print self.splitterSizes
1509 #print self.splitter.sizes()
1510 # PNPNPNPN parfoir self.splitter.sizes() a une longueur de 4...
1511 nbAGarder=len(self.splitter.sizes())
1512 if nbAGarder > 3 : nbAGarder=3
1513 for i in range(nbAGarder):
1514 self.splitterSizes[i] = self.splitter.sizes()[i]
1515 self.splitter.widget(i).resizeEvent=self.saveSplitterSizes
1516 #print self.splitter.sizes()
1519 #-----------------------------------------
1520 def restoreSplitterSizes(self,nbWigdet=3):
1521 #----------------------------------------
1522 self.inhibeSplitter = 1
1524 if not(hasattr(self,'splitter')) : return
1525 newSizes=self.splitterSizes[:nbWigdet]
1526 self.splitter.setSizes(newSizes)
1527 self.inhibeSplitter = 0
1529 #------------------------
1530 def fermeOptionnel(self):
1531 #------------------------
1532 if self.widgetOptionnel == None : return
1534 self.inhibeSplitter=1
1535 self.splitterSizes[1] = self.splitterSizes[1] + self.splitterSizes[2]
1536 if self.splitterSizes[2]!=0 : self.oldSizeWidgetOptionnel = self.splitterSizes[2]
1537 self.splitterSizes[2]=0
1539 self.widgetOptionnel.setParent(None)
1540 self.widgetOptionnel.close()
1541 self.widgetOptionnel.deleteLater()
1542 self.widgetOptionnel=None
1543 self.inhibeSplitter=0
1544 self.restoreSplitterSizes(2)
1546 #------------------------
1547 def ajoutOptionnel(self):
1548 #------------------------
1549 #print "ajoutOptionnel"
1550 #print self.splitterSizes
1551 self.splitterSizes[2] = self.oldSizeWidgetOptionnel
1552 self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
1553 self.inhibeSplitter=0
1554 self.restoreSplitterSizes(3)
1557 #-----------------------------
1558 def getTreeIndex(self,noeud):
1559 #----------------------------
1561 if noeud in noeud.treeParent.children :
1562 indexNoeud=noeud.treeParent.children.index(noeud)
1564 if hasattr(noeud,'vraiParent') :
1566 noeudVraiParent = noeud.vraiParent
1567 while noeudVraiParent != noeud.treeParent and hasattr(noeudVraiParent,'vraiParent') :
1568 noeudVrai = noeudVraiParent
1569 noeudVraiParent = noeudVraiParent.vraiParent
1571 if noeudVraiParent == noeud.treeParent :
1572 indexNoeud=noeud.treeParent.children.index(noeudVrai)
1578 if __name__ == "__main__":
1580 name='prefs_'+prefs.code
1581 prefsCode=__import__(name)
1584 if hasattr(prefsCode,'encoding'):
1585 # Hack pour changer le codage par defaut des strings
1588 sys.setdefaultencoding(prefs.encoding)
1589 del sys.setdefaultencoding
1594 app = QApplication(sys.argv)
1595 mw = JDCEditor(None,'azAster.comm')
1596 app.setMainWidget(mw)
1597 app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
1600 res = app.exec_loop()