parser.add_option(u"-c","--cata", action="store", type="string",dest="cata",
help=tr("version de catalogue a utiliser"))
+ parser.add_option(u"-v","--version_cata", action="store", type="string",dest="version_cata",
+ help=tr("version de catalogue a utiliser"))
+
+
parser.add_option(u"-k","--kode", action="store", type="string",dest="code",
help=tr("nom du code a utiliser"))
self.text_converted=0
self.text_error=""
if self.nom != "INCLUDE_MATERIAU":
- if self.parent.appli.ihm == "QT" :
- format=self.parent.appli.appliEficas.format_fichier
- else :
- format=self.jdc.appli.format_fichier.get()
+ format=self.parent.appli.appliEficas.format_fichier
#on force a python pour Carmel
if format=="CARMEL3D" : format="python"
if format in convert.plugins :
return self.treeParent.appendChild(name,pos=index,plier=plier)
def verifiePosition(self,name,pos,aLaRacine=False):
- if name not in self.editor.Classement_Commandes_Ds_Arbre : return True
- indexName=self.editor.Classement_Commandes_Ds_Arbre.index(name)
+ if name not in self.editor.readercata.Classement_Commandes_Ds_Arbre : return True
+ indexName=self.editor.readercata.Classement_Commandes_Ds_Arbre.index(name)
etapes=self.item.getJdc().etapes
if etapes == [] : return True
if pos=="after" : indexOu = indexOu+1
for e in etapes[:indexOu] :
nom=e.nom
- if nom not in self.editor.Classement_Commandes_Ds_Arbre : continue
- indexEtape=self.editor.Classement_Commandes_Ds_Arbre.index(nom)
+ if nom not in self.editor.readercata.Classement_Commandes_Ds_Arbre : continue
+ indexEtape=self.editor.readercata.Classement_Commandes_Ds_Arbre.index(nom)
if indexEtape > indexName :
comment=tr('le mot clef ')+name+tr(' doit etre insere avant ')+nom
QMessageBox.information( None,tr('insertion impossible'),comment, )
return False
for e in etapes[indexOu:] :
nom=e.nom
- if nom not in self.editor.Classement_Commandes_Ds_Arbre : continue
- indexEtape=self.editor.Classement_Commandes_Ds_Arbre.index(nom)
+ if nom not in self.editor.readercata.Classement_Commandes_Ds_Arbre : continue
+ indexEtape=self.editor.readercata.Classement_Commandes_Ds_Arbre.index(nom)
if indexEtape < indexName :
comment=tr('le mot clef ')+name+tr(' doit etre insere apres ')+nom
QMessageBox.information( None,tr('insertion impossible'),comment, )
#Particularite des schemas MAP
if hasattr(self,'make_ssCode'): self.make_ssCode(self.ssCode)
- if self.appli: self.parent=appli.top
- else: self.parent=None
+ #if self.appli: self.parent=appli.top
+ #else: self.parent=None
if not os.path.isdir(self.savedir) :
if sys.platform[0:5]=="linux" :
self.boutonDsMenuBar=False
self.ficIcones=None
self.repIcones=None
- self.differencieSiDefaut=True
+ self.differencieSiDefaut=False
import types,sys,os, re
import subprocess
import traceback
-
import six
-from six.moves import range
+
+
from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
-from PyQt5.QtGui import QPalette
-from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
-import time
-import pdb
-from datetime import date
-from Extensions.i18n import tr
+from PyQt5.QtGui import QPalette
+from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
import traceback
# Modules Eficas
-
import convert, generator
+from Extensions.i18n import tr
+
from Editeur import session
from Editeur import comploader
from Editeur import Objecttreeitem
-from desBaseWidget import Ui_baseWidget
+from InterfaceQT4 import browser
+from InterfaceQT4 import readercata
+
+from desBaseWidget import Ui_baseWidget
from InterfaceQT4.monViewTexte import ViewText
from monWidgetCreeParam import MonWidgetCreeParam
-from . import browser
-from . import readercata
DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
debug = False
+from InterfaceQT4.editorSsIhm import JDCEditorSsIhm
-class JDCEditor(Ui_baseWidget,QWidget):
+class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
# ----------------------------------------- #
"""
Editeur de jdc
"""
- #def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 , vm=None):
- def __init__ (self,appli,fichier = None, jdc = None, QWParent=None, units = None, include=0 ):
- #--------------------------------------------------------------------------------------------#
+# ----------------------------------------
+# Methodes faisant appel a ssIhm
+# ----------------------------------------
+
+ def __init__ (self,appli,fichier = None, jdc=None, QWParent=None, units = None, include=0):
+ #------------------------------------------------------------------------------------------
+
QWidget.__init__(self,None)
self.setupUi(self)
self.dejaDansPlieTout=False
self.afficheCommandesPliees = True
self.listeDesListesOuvertes=set()
+ self.afficheListesPliees=True
+ if appli!=None and hasattr(appli,"statusBar"): self.sb = appli.statusBar()
+ else : self.sb = None
+ self.QWParent=QWParent
- self.appliEficas = appli
- self.appli = appli #---- attendu par IHM
- #self.vm = vm
- self.fichier = fichier
- self.jdc = jdc
- self.first = True
- self.QWParent = QWParent
- self.couleur = Qt.black
- self.nodeEnCours=None
-
- if appli != None :
- self.salome = self.appliEficas.salome
- else :
- self.salome=0
- print ("dans JDC pas d appli ????????")
+ JDCEditorSsIhm. __init__ (self,appli,fichier, jdc,units,include)
- # ces attributs sont mis a jour par definitCode appelee par newEditor
- self.code = self.appliEficas.maConfiguration.code
- self.maConfiguration = self.appliEficas.maConfiguration
- self.initSplitterSizes()
+ # Particularites IHM : met la fenetre a jour
- #self.afficheListesPliees=False
- self.afficheListesPliees=True
+ self.initSplitterSizes()
if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
if self.code == 'PSEN_N1' : self.afficheListesPliees = False
- self.closeAutreCommande=self.appliEficas.maConfiguration.closeAutreCommande
- self.closeFrameRechercheCommande = self.appliEficas.maConfiguration.closeFrameRechercheCommande
- self.closeArbre=self.appliEficas.maConfiguration.closeArbre
- self.affiche=self.appliEficas.maConfiguration.affiche
- self.afficheOptionnelVide=self.appliEficas.maConfiguration.afficheOptionnelVide
- self.nombreDeBoutonParLigne = self.appliEficas.maConfiguration.nombreDeBoutonParLigne
- self.dicoImages = self.appliEficas.maConfiguration.dicoImages
- self.simpleClic = self.appliEficas.maConfiguration.simpleClic
- self.boutonDsMenuBar = self.appliEficas.maConfiguration.boutonDsMenuBar
-
- #if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
- if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
- if self.code in ['MAP',]:
- self.widgetTree.close()
- self.widgetTree=None
- if self.closeArbre: self.fermeArbre()
-
- self.version_code = session.d_env.cata
-
+ #self.affiche=self.appliEficas.maConfiguration.affiche
- if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
- self.readercata = readercata.READERCATA( self, self.appliEficas )
- self.appliEficas.readercata=self.readercata
- self.appliEficas.code=self.code
- if self.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
- else :
- self.readercata=self.appliEficas.readercata
+ if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
+ #if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
+ if self.code in ['MAP',]: self.fermeArbre()
+ # self.widgetTree.close()
+ # self.widgetTree=None
- if self.readercata.fic_cata == None : return #Sortie Salome
- self.titre=self.readercata.titre
- self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
- self.Classement_Commandes_Ds_Arbre=self.readercata.Classement_Commandes_Ds_Arbre
+ if self.maConfiguration.closeArbre: self.fermeArbre()
+ if self.maConfiguration.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
+ self.version_code = session.d_env.cata
+
self.format = self.appliEficas.format_fichier
- self.dict_reels={}
- self.liste_simp_reel=[]
- self.ihm="QT"
- self.dicoNouveauxMC={}
- self.dicoNouveauxFact={}
-
- nameConf='configuration_'+self.code
- configuration=__import__(nameConf)
- self.maConfiguration = self.appliEficas.maConfiguration
-
- try:
- self.maConfiguration.generator_module
- _module = __import__(self.maConfiguration.generator_module)
- info = _module.entryPoint()
- generator.plugins.addEntryPoint(info)
- except:
- pass
-
- try:
- self.maConfiguration.convert_module
- #print self.maConfiguration.convert_module
- _module = __import__(self.maConfiguration.convert_module)
- info = _module.entryPoint()
- convert.plugins.addEntryPoint(info)
- except :
- pass
-
- self.sb = None
- if hasattr(self.appliEficas,"statusBar"):
- self.sb = self.appliEficas.statusBar()
-
- self.fileInfo = None
- self.lastModified = 0
-
- self.modified = False
- self.isReadOnly = False
self.node_selected = []
self.deplier = True
self.message=''
if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
- else : self.afficheApresInsert=False
- if self.code in ['TELEMAC',] : self.enteteQTree='premier'
- else : self.enteteQTree='complet'
+ else : self.afficheApresInsert=False
+ if self.code in ['TELEMAC',] : self.enteteQTree='premier'
+ else : self.enteteQTree='complet'
if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
- else : self.affichePlie=False
+ else : self.affichePlie=False
self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
- #------- construction du jdc --------------
-
- jdc_item = None
-
- self.nouveau=0
- if self.fichier is not None: # fichier jdc fourni
- self.fileInfo = QFileInfo(self.fichier)
- self.fileInfo.setCaching(0)
- if jdc==None :
- print ('attention chgt try en if')
- try :
- #if 1 :
- self.jdc = self.readFile(self.fichier)
- if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
- except :
- print ("mauvaise lecture")
- else :
- self.jdc=jdc
- if self.jdc is not None and units is not None:
- self.jdc.recorded_units=units
- self.jdc.old_recorded_units=units
- else:
- if not self.jdc: # nouveau jdc
- if not include :
- self.jdc = self._newJDC(units=units)
- else :
- self.jdc = self._newJDCInclude(units=units)
- self.nouveau=1
- #import cProfile, pstats, StringIO
- #pr = cProfile.Profile()
- #pr.enable()
-
- if self.jdc:
- self.jdc.appli = self # a resorber
- self.jdc.editor = self
- self.jdc.lang = self.appli.langue
- self.jdc.aReafficher=False
- txt_exception = None
- if not jdc:
- self.jdc.analyse()
- txt_exception = self.jdc.cr.getMessException()
- if txt_exception:
- self.jdc = None
- QApplication.restoreOverrideCursor()
- self.afficheInfos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
- if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
- else:
- comploader.chargerComposants("QT")
- jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
- if (not self.jdc.isValid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
- self.viewJdcRapport()
-
- #pr.disable()
- #s = StringIO.StringIO()
- #sortby = 'cumulative'
- #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- #ps.print_stats()
- #print (s.getValue())
-
- if jdc_item and self.appliEficas.ssIhm==False :
- self.tree = browser.JDCTree( jdc_item, self )
+ if self.jdc_item and self.appliEficas.ssIhm==False :
+ self.tree = browser.JDCTree( self.jdc_item, self )
self.appliEficas.construitMenu()
-
- #############
self.adjustSize()
- #-------------------# Pour execution avec output et error dans le bash
- def runPSEN(self):
- #-------------------#
-
- #if self.modified or self.fichier==None : self.saveFile()
- self.saveFile()
-
- #lancement avec le .bat
- path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
- WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
- import subprocess
- p = subprocess.Popen(['python',WrapperFilePath])
- (out,err)=p.communicate()
- print (out)
- print (err)
-
- #-------------------# Pour execution avec output et error dans le bash
- def runPSEN_N1(self):
- #-------------------#
-
-
- self.saveFile()
- path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
- sys.path.append(path1)
-
- if not(self.jdc.isValid()):
- QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
- if 'dicoImbrique' in generator.plugins:
- self.generator=generator.plugins['dicoImbrique']()
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.generator.Dico
-
- ###to delete
- #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
- fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
- f = open( str(fileDico), 'w')
- f.write("Dico =" + str(dico) )
- f.close()
- ###
-
-
- print ('in runPSEN_N1', dico)
- print (dico)
- from Run import run
- run(dico)
- #res,txt_exception=run(dico)
- #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
- #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
-
- #-------------------# Pour execution avec output et error dans le bash
- def process_N1(self):
- #-------------------#
-
- path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
- sys.path.append(path1)
-
-
- if 'dicoImbrique' in generator.plugins:
- self.generator=generator.plugins['dicoImbrique']()
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.getDico() #generator.Dico
-
-
- for k in dico['CONTINGENCY_PROCESSING']:
- #print (k)
- if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
- newK=k.replace('__',' ')
- l="'"+str(newK)+"'"
- dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
- del dico['CONTINGENCY_PROCESSING'][k]
-
- ###to delete
- fileDico = os.path.join(path1, 'dicoN1_process.py')
- f = open( str(fileDico), 'w')
- f.write("Dico =" + str(dico) )
- f.close()
- ###
- return dico
-
- #return self.getDico()
-
- #-------------------# Pour execution avec output et error dans le bash
- def process_VP(self):
- #-------------------#
- if 'dicoImbrique' in generator.plugins:
- self.generator=generator.plugins['dicoImbrique']()
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.getDico() #generator.Dico
- return dico
-
-
- #--------------------------------#
- def ajoutCommentaire(self):
- #--------------------------------#
- if self.tree.selectedItems()==[] :
- QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
- return
- noeudAvantCommentaire=self.tree.selectedItems()[0]
- if noeudAvantCommentaire ==self.tree.racine :
- self.tree.racine.appendChild("COMMENTAIRE",pos=0)
- return
- noeudAvantCommentaire.addComment(True)
-
-
-
- #--------------------------------#
- def _newJDC( self ,units = None):
- #--------------------------------#
- """
- Initialise un nouveau JDC vierge
- """
- self.modified=1
- CONTEXT.unsetCurrentStep()
-
- texte=""
- if self.code == "CARMELCND" : texte=self._newJDCCND()
- if self.code == "ZCRACKS" : texte=self._newZCRACKS()
- if self.code == "TELEMAC" : texte=self._newTELEMAC()
- if self.code == "PSEN" : texte = self._newPSEN()
- if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
-
- if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
-
- #if self.code == "CF" : texte = self._new_CF()
- # texte=self.newTexteCND
-
- jdc=self.readercata.cata[0].JdC( procedure =texte,
- appli=self,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.maConfiguration.rep_mat
- )
- jdc.lang = self.appli.langue
- if units is not None:
- jdc.recorded_units=units
- jdc.old_recorded_units=units
- ## PNPN est ce que la ligne suivante est bien utile ?
- if texte == "" :jdc.analyse()
- return jdc
-
- #--------------------------------#
- def _newJDCInclude( self ,units = None):
- #--------------------------------#
- """
- Initialise un nouveau JDC vierge
- """
- import Extensions.jdc_include
- JdC_aux=Extensions.jdc_include.JdC_include
- CONTEXT.unsetCurrentStep()
-
- jaux=self.readercata.cata[0].JdC( procedure="",
- appli=self,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.maConfiguration.rep_mat,
- )
- jaux.analyse()
-
- J=JdC_aux( procedure="",
- appli=self,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- jdc_pere=jaux,
- rep_mat=self.maConfiguration.rep_mat,
- )
- J.analyse()
- if units is not None:
- J.recorded_units=units
- J.old_recorded_units=units
- return J
-
-
#-------------------------------#
def readFile(self, fn):
#--------------------------------#
Public slot to read the text from a file.
@param fn filename to read from (string or QString)
"""
- fn = six.text_type(fn)
- # ------------------------------------------------------------------------------------
- # charge le JDC
- # ------------------------------------------------------------------------------------
-
- jdcName=os.path.basename(fn)
- # Il faut convertir le contenu du fichier en fonction du format
- if self.appliEficas.format_fichier_in in convert.plugins:
- # Le convertisseur existe on l'utilise
- #appli = self
- p=convert.plugins[self.appliEficas.format_fichier_in]()
-
-
- p.readfile(fn)
-
- if p.text=="" : self.nouveau=1
- pareil,texteNew=self.verifieChecksum(p.text)
- #if texteNew == ""
- if pareil == False and (self.appliEficas.ssIhm == False) :
- QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
- p.text=texteNew
- memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
- if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
- p.text=texteNew
-
- #import cProfile, pstats, StringIO
- #pr = cProfile.Profile()
- #pr.enable()
-
- text=p.convert('exec',self.appliEficas)
-
- if not p.cr.estvide():
- self.afficheInfos("Erreur a la conversion",Qt.red)
- else :
- self.afficheInfos("Type de fichier non reconnu",Qt.red)
- if self.appliEficas.ssIhm == False:
- QMessageBox.critical( self, tr("Type de fichier non reconnu"),
- tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
- return None
-
- CONTEXT.unsetCurrentStep()
- jdc=self.readercata.cata[0].JdC(procedure=text,
- appli=self,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- nom=jdcName,
- rep_mat=self.maConfiguration.rep_mat
- )
- # ----------------------------------------------------
- # charge le JDC fin
- # ----------------------------------------------------
- self.modified = False
+ jdc=JDCEditorSsIhm.readFile(self, fn)
+ # Particularites IHM : met le titre de la fenetre a jour
# qApp.restoreOverrideCursor()
- if self.fileInfo!= None :
- self.lastModified = self.fileInfo.lastModified()
- else :
- self.lastModified = 1
+ if self.fileInfo!= None : self.lastModified = self.fileInfo.lastModified()
nouveauTitre=self.titre+" "+os.path.basename(self.fichier)
self.appliEficas.setWindowTitle(nouveauTitre)
return jdc
-
- #-----------------------#
- def getSource(self,file):
- #-----------------------#
-
- # Il faut convertir le contenu du fichier en fonction du format
- if self.format in convert.plugins :
- # Le convertisseur existe on l'utilise
- p=convert.plugins[self.format]()
- p.readfile(file)
- text=p.convert('execnoparseur')
- if not p.cr.estvide():
- self.afficheInfos("Erreur a la conversion",Qt.red)
- return text
- else:
- # Il n'existe pas c'est une erreur
- self.afficheInfos("Type de fichier non reconnu",Qt.red)
- QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
- return None
+# ---------------------------------------------
+# Methodes Inchangees
+# ---------------------------------------------
+# _newJDC
+# _newJDCInclude
+# __generateTempFilename
+# getSource
+# generDico
+# viewJdcSource
+# viewJdcPy
+# viewJdcRapport
+# getFileName
+# initModif
+# writeFile
+# getTextJDC
+# verifieChecksum
+# getChecksum
+# getDico
+# chercheGroupes
+# chercheDico
+# saveFileLegerAs
+
+# ---------------------------------------------
+# Methodes Surchargees
+# ---------------------------------------------
#-----------------------------------------------------------------------#
def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
#--------------------------------------------------------------------#
w = ViewText( self.QWParent,self ,caption,txt,largeur,hauteur)
w.show()
- #
- #----------------------------------------------#
- def __generateTempFilename(self, prefix, suffix):
- #----------------------------------------------#
- import tempfile
- (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
- os.close(fd)
- return filename
- #
+ #--------------------------------#
+ def informe(self,titre,txt,critique=True):
+ #--------------------------------#
+ if critique :
+ self.affiche_infos(tr(txt),Qt.red)
+ QMessageBox.critical( self, tr(titre), tr(txt))
+ else :
+ QMessageBox.warning( self, tr(titre),tr(txt))
+
+ #--------------------------------#
+ def ajoutCommentaire(self):
+ #--------------------------------#
+ if self.tree.selectedItems()==[] :
+ QMessageBox.warning( self, tr("Pas de noeud selectionne"),tr("Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"))
+ return
+ noeudAvantCommentaire=self.tree.selectedItems()[0]
+ if noeudAvantCommentaire ==self.tree.racine :
+ self.tree.racine.appendChild("COMMENTAIRE",pos=0)
+ return
+ noeudAvantCommentaire.addComment(True)
#----------------------------------------------#
a=self.monExe.readAllStandardOutput()
self.w.view.append(str(a.data()))
- def readFromStdErrQT4(self):
- a=self.monExe.readAllStandardError()
- self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
-
- def readFromStdOutQT4(self) :
- a=self.monExe.readAllStandardOutput()
- self.w.view.append(QString.fromUtf8(a.data(),len(a))) ;
- #-----------------------#
- def generDico(self):
- #-----------------------#
- if 'dico' in generator.plugins:
- self.generator=generator.plugins['dico']()
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.generator.Dico
- return dico
-
#-----------------------#
def gestionParam(self):
#-----------------------#
w = MonWidgetCreeParam( self)
w.show()
- #-----------------------#
- def viewJdcSource(self):
- #-----------------------#
- if self.fichier == None : return
- f=open(self.fichier,'r')
- texteSource=f.read()
- f.close()
- self._viewText(texteSource, "JDC_SOURCE")
-
- #-----------------------#
- def viewJdcPy(self):
- #-----------------------#
- strSource = str( self.getTextJDC(self.format) )
- self._viewText(strSource, "JDC_RESULTAT")
-
- #-----------------------#
- def viewJdcRapport(self):
- #-----------------------#
- strRapport = six.text_type( self.jdc.report() )
- # on ajoute les regles
-
- self._viewText(strRapport, "JDC_RAPPORT")
-
- #-----------------------#
- def viewJdcRegles(self):
- #-----------------------#
- if self.tree :self.tree.appellebuildLBRegles()
-
#----------------#
def closeIt(self):
"""
Public method called by the viewmanager to finally get rid of us.
"""
- if self.jdc:
- self.jdc.supprime()
+ if self.jdc: self.jdc.supprime()
self.close()
#----------------------------------------------#
def afficheInfos(self,message,couleur=Qt.black):
#----------------------------------------------#
+ if couleur=='red' : couleur = Qt.red
if self.sb:
mapalette=self.sb.palette()
mapalette.setColor( QPalette.WindowText, couleur )
#----------------------#
self.labelCommentaire.setText("")
- #-------------------#
- def initModif(self):
- #-------------------#
- """
- Met l'attribut modified a 'o' : utilise par Eficas pour savoir
- si un JDC doit etre sauvegarde avant destruction ou non
- """
- self.modified = True
-
#---------------------------------------#
def chercheNoeudSelectionne(self,copie=1):
#---------------------------------------#
nouveau.affichePanneau()
- #---------------------#
- def getFileName(self):
- #---------------------#
- return self.fichier
-
#---------------------------#
def getFileVariable(self) :
#---------------------------#
tr('Wrapper Files (*.xml);;''All Files (*)'))
return fichier
- #--------------------------------------------------#
- def writeFile(self, fn, txt = None,formatLigne="beautifie"):
- #--------------------------------------------------#
- """
- Public slot to write the text to a file.
-
- @param fn filename to write to string
- @return flag indicating success
- """
-
- fn = six.text_type(fn)
-
- if txt == None :
- txt = self.getTextJDC(self.format,formatLigne=formatLigne)
- eol = '\n'
- if len(txt) >= len(eol):
- if txt[-len(eol):] != eol:
- txt += eol
- else:
- txt += eol
- txt=self.ajoutVersionCataDsJDC(txt)
- if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
- else : checksum=''
- txt=txt+checksum
- if self.code=="TELEMAC" : return 1
- try:
- f = open(fn, 'w')
- f.write(txt)
- f.close()
- return 1
- except IOError as why:
- if (self.appliEficas.ssIhm == False):
- QMessageBox.critical(self, tr('Sauvegarde du Fichier'),
- tr('Le fichier')+str(fn) + tr('n a pas pu etre sauvegarde : ') + str(why))
- else :
- print (why)
- return 0
-
- #-----------------------------------------------------------#
- def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
- #-----------------------------------------------------------#
- if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
- if format in generator.plugins:
-
- # Le generateur existe on l'utilise
- self.generator=generator.plugins[format]()
- try :
- jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
- if pourRun : jdc_formate=self.generator.textePourRun
- if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
- except ValueError as e:
- QMessageBox.critical(self, tr("Erreur a la generation"),str(e))
- return
-
- if not self.generator.cr.estvide():
- self.afficheInfos(tr("Erreur a la generation"),Qt.red)
- QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
- return ""
- else:
- return jdc_formate
- else:
- # Il n'existe pas c'est une erreur
- self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
- QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
- return ""
-
- #----------------------#
- def getDico(self):
- #---------------------#
- if 'dicoImbrique' in generator.plugins:
- self.generator=generator.plugins['dicoImbrique']()
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.generator.Dico
- return dico
- else :
- self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
- QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
- return ""
-
-
#------------#
def run(self):
#------------#
fonction="saveRun"+self.code
if fonction in JDCEditor.__dict__: JDCEditor.__dict__[fonction](self,)
+
+# ---------------------------------------------
+# Methodes Non Crees dans ssIHM
+# ---------------------------------------------
+
#---------------#
def runMAP(self):
#---------------#
self.saveFile()
- #-----------------------------------------#
- def chercheGroupes(self):
- #-----------------------------------------#
- listeMA,listeNO=self.getTextJDC("GroupMA")
- return listeMA,listeNO
-
- #-----------------------------------------#
- def chercheDico(self):
- #-----------------------------------------#
- dicoCourant={}
- format = self.appliEficas.format_fichier
- if format in generator.plugins:
- # Le generateur existe on l'utilise
- self.generator=generator.plugins[format]()
- jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
- dicoCourant=self.generator.dico
- return dicoCourant
-
-
#-----------------------------------------#
def handleAjoutGroup(self,listeGroup):
#else :
pass
- #-----------------------------------------------------------------#
- def saveFileLegerAs(self, fileName = None) :
- #-----------------------------------------------------------------#
- if fileName != None :
- self.fichier = fileName
- return self.saveFileLeger()
- return self.saveFileLeger()
#-----------------------------------------------------------------#
def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
return texte
- #------------------------------#
- def verifieChecksum(self,text):
- #------------------------------#
- indexDeb=text.find("#CHECKSUM:")
- if indexDeb < 0 :
- return 1, text
- indexFin=text.find(":FIN CHECKSUM")
- checkAvant=text[indexDeb:indexFin+13]
- textJDC=text[0:indexDeb]+text[indexFin+13:-1]
- if self.code != 'PSEN' and self.code != 'PSEN_N1':
- checksum=self.getChecksum(textJDC)
- pareil=(checkAvant==checksum)
- else :
- pareil=1
- #if self.code=='PSEN'
- return pareil, textJDC
-
- #---------------------------#
- def getChecksum(self,texte):
- #---------------------------#
- newtexte=texte.replace('"','\\"')
- commande='echo "'+newtexte+'"|md5sum'
- a=os.popen(commande)
- checksum=a.read()
- a.close()
- ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
- return ligne
-
-
- #---------------------------#
- def _new_CF(self):
- #---------------------------#
- texte="CONDUITE_FORCEE();"
- return texte
-
-
- #---------------------------#
- def _newTELEMAC(self):
- #---------------------------#
- #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
- texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
- #texte="TRACERS();"
- return texte
-
- #---------------------------#
- def _newPSEN(self):
- #---------------------------#
- texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
- #texte=""
- return texte
-
- #---------------------------#
- def _newPSEN_N1(self):
- #---------------------------#
- texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
- #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
- return texte
-
- #---------------------------#
-
- #---------------------------#
- def _newZCRACKS(self):
- #---------------------------#
- texte="MAILLAGES();REMESHING();"
- return texte
-
- #---------------------------#
- def _newJDCCND(self):
- #---------------------------#
- extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
-
- #if self.salome == 0 :
- QMessageBox.information( self,
- tr("Fichier Med"),
- tr("Veuillez selectionner un fichier Med"))
- QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
- caption='Fichier Med',
- filter=extensions)
- QSfichier=QSfichier[0]
- self.fichierMED=QSfichier
- from acquiertGroupes import getGroupes
- erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
- if erreur != "" : print ("a traiter")
- texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
- texteSources=""
- texteCond=""
- texteNoCond=""
- texteVcut=""
- texteZs=""
- for groupe in self.listeGroupes :
- if groupe[0:8]=='CURRENT_':
- texteSources +=groupe[8:]+"=SOURCE("
- texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
- if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
- if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
- if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
- if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
- texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
- self.newTexteCND=texte
- self.modified=1
- return texte
-
-
- #---------------------------#
- #def boutonFileSelected(self):
- #---------------------------#
-
- # QSfichier=self.openfile.selectedFiles()[0]
- # self.fichierMED=str(QSfichier)
- # from acquiertGroupes import getGroupes
- # erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
- # if erreur != "" : print ("a traiter")
-
- #-----------------------------
- #def boutonSalomePressed(self):
- #----------------------------
- # Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
- # self.fichierMED="A_partir_de_SMESH"
- # self.nomMaillage="A_partir_de_SMESH"
- # self.openfile.close()
-
#-----------------------------------------
def initSplitterSizes(self, nbWidget=3):
#-----------------------------------------
#print ("je passe ds initSplitterSizes", nbWidget)
- if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes3=[1,1550,150]
- elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
+ if self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes3=[1,1550,150]
+ #elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
else : self.splitterSizes3=[150,1000,300]
- if self.code in [ 'Adao', 'ADAO', ] : self.splitterSizes2=[5,1500]
+ if self.code in [ 'Adao', 'ADAO','MAP' ] : self.splitterSizes2=[5,1500]
else : self.splitterSizes2=[300,1000]
-
#-----------------------------------------
def restoreSplitterSizes(self,nbWidget=3):
#----------------------------------------
pass
return indexNoeud
+ #-------------------# Pour execution avec output et error dans le bash
+ def runPSEN(self):
+ #-------------------#
+
+ #if self.modified or self.fichier==None : self.saveFile()
+ self.saveFile()
+
+ #lancement avec le .bat
+ path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','PSEN_Eficas','PSEN'))
+ WrapperFilePath = os.path.join(path1, 'PSSEWrapper.py')
+ import subprocess
+ p = subprocess.Popen(['python',WrapperFilePath])
+ (out,err)=p.communicate()
+ print (out)
+ print (err)
+
+ #-------------------# Pour execution avec output et error dans le bash
+ def runPSEN_N1(self):
+ #-------------------#
+
+
+ self.saveFile()
+ path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
+ sys.path.append(path1)
+
+ if not(self.jdc.isValid()):
+ QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
+ if 'dicoImbrique' in generator.plugins:
+ self.generator=generator.plugins['dicoImbrique']()
+ jdc_formate=self.generator.gener(self.jdc)
+ dico=self.generator.Dico
+
+ ###to delete
+ #fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+ fileDico = os.path.join(path1, 'dicoN1.py') #r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+ f = open( str(fileDico), 'w')
+ f.write("Dico =" + str(dico) )
+ f.close()
+ ###
+
+
+ print ('in runPSEN_N1', dico)
+ print (dico)
+ from Run import run
+ run(dico)
+ #res,txt_exception=run(dico)
+ #if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
+ #else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
+
+ #-------------------# Pour execution avec output et error dans le bash
+ def process_N1(self):
+ #-------------------#
+
+ path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
+ sys.path.append(path1)
+
+
+ if 'dicoImbrique' in generator.plugins:
+ self.generator=generator.plugins['dicoImbrique']()
+ jdc_formate=self.generator.gener(self.jdc)
+ dico=self.getDico() #generator.Dico
+
+
+ for k in dico['CONTINGENCY_PROCESSING']:
+ #print (k)
+ if k[0:19] == 'Component_List_For_' or k[0:21] =='Contingency_List_For_' :
+ newK=k.replace('__',' ')
+ l="'"+str(newK)+"'"
+ dico['CONTINGENCY_PROCESSING'][l]=dico['CONTINGENCY_PROCESSING'][k]
+ del dico['CONTINGENCY_PROCESSING'][k]
+
+ ###to delete
+ fileDico = os.path.join(path1, 'dicoN1_process.py')
+ f = open( str(fileDico), 'w')
+ f.write("Dico =" + str(dico) )
+ f.close()
+ ###
+ return dico
+
+ #return self.getDico()
+
+ #-------------------# Pour execution avec output et error dans le bash
+ def process_VP(self):
+ #-------------------#
+ if 'dicoImbrique' in generator.plugins:
+ self.generator=generator.plugins['dicoImbrique']()
+ jdc_formate=self.generator.gener(self.jdc)
+ dico=self.getDico() #generator.Dico
+ return dico
+
if __name__ == "__main__":
print ('in main')
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import types,sys,os, re
+import subprocess
+import traceback
+
+import six
+from six.moves import range
+
+import traceback
+
+# Modules Eficas
+
+import convert, generator
+from Editeur import session
+from Editeur import comploader
+from Editeur import Objecttreeitem
+from InterfaceQT4 import readercata
+
+DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
+debug = False
+
+
+
+class JDCEditorSsIhm :
+# ------------------- #
+ """
+ Editeur de jdc
+ """
+
+# ---------------------------------------------
+# Methodes Communes ou appelees depuis avec Ihm
+# ---------------------------------------------
+
+ def __init__ (self,appli,fichier = None, jdc = None, units = None, include=0 ):
+ #------------------------------------------------------------------------------#
+ # paticularisee avec Ihm
+
+ if debug : print ('dans le init de JDCEditorSsIhm')
+ self.appliEficas = appli
+ self.appli = appli
+ self.fichier = fichier
+ self.jdc = jdc
+ self.first = True
+ self.jdc_item = None
+ self.dicoNouveauxMC={}
+ self.dicoNouveauxFact={}
+ self.dict_reels={}
+ self.liste_simp_reel=[]
+
+
+ if appli != None : self.salome = self.appliEficas.salome
+ else : self.salome=0
+
+ # ces attributs sont mis a jour par definitCode appelee par newEditor
+ self.code = self.appliEficas.maConfiguration.code
+ self.maConfiguration = self.appliEficas.maConfiguration
+
+ self.version_code = session.d_env.cata
+
+
+ if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.multi==True:
+ self.readercata = readercata.READERCATA( self, self.appliEficas )
+ self.appliEficas.readercata=self.readercata
+ self.appliEficas.code=self.code
+ else :
+ self.readercata=self.appliEficas.readercata
+ if self.readercata.fic_cata == None : return #Sortie Salome
+ self.titre=self.readercata.titre
+
+ self.format = self.appliEficas.format_fichier
+
+ self.dict_reels={}
+ self.liste_simp_reel=[]
+ self.dicoNouveauxMC={}
+ self.dicoNouveauxFact={}
+
+
+ try:
+ self.maConfiguration.generator_module
+ _module = __import__(self.maConfiguration.generator_module)
+ info = _module.entryPoint()
+ generator.plugins.addEntryPoint(info)
+ except:
+ pass
+
+ try:
+ self.maConfiguration.convert_module
+ #print self.maConfiguration.convert_module
+ _module = __import__(self.maConfiguration.convert_module)
+ info = _module.entryPoint()
+ convert.plugins.addEntryPoint(info)
+ except :
+ pass
+
+ self.fileInfo = None
+ self.lastModified = 0
+
+ self.modified = False
+ self.isReadOnly = False
+
+ #------- construction du jdc --------------
+
+
+ self.nouveau=0
+ if self.fichier is not None: # fichier jdc fourni
+ if jdc==None :
+ print ('PNPN : chgt try en if')
+ #try :
+ if 1 :
+ self.jdc = self.readFile(self.fichier)
+ #except :
+ # print ("mauvaise lecture")
+ if self.salome :
+ try :
+ self.appliEficas.addJdcInSalome( self.fichier)
+ except :
+ print ("mauvais enregistrement dans Salome")
+ else :
+ self.jdc=jdc
+
+ if self.jdc is not None and units is not None:
+ self.jdc.recorded_units=units
+ self.jdc.old_recorded_units=units
+
+ else:
+ if not self.jdc: # nouveau jdc
+ if not include :
+ self.jdc = self._newJDC(units=units)
+ else :
+ self.jdc = self._newJDCInclude(units=units)
+ self.nouveau=1
+
+ if self.jdc:
+ self.jdc.appli = self # a resorber
+ self.jdc.editor = self
+ self.jdc.lang = self.appli.langue
+ self.jdc.aReafficher=False
+ txt_exception = None
+ if not jdc:
+ self.jdc.analyse()
+ txt_exception = self.jdc.cr.getMessException()
+ if txt_exception :
+ self.jdc = None
+ self.informe('pb chargement jdc',txt_exception)
+ else:
+ comploader.chargerComposants()
+ self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
+
+ #-------------------------------#
+ def readFile(self, fn):
+ #--------------------------------#
+ """
+ Public slot to read the text from a file.
+ @param fn filename to read from (string or QString)
+ """
+
+ # charge un JDC
+ # paticularisee avec Ihm
+
+ fn = six.text_type(fn)
+ jdcName=os.path.basename(fn)
+
+ # Il faut convertir le contenu du fichier en fonction du format
+ if self.appliEficas.format_fichier_in in convert.plugins:
+ # Le convertisseur existe on l'utilise
+
+ p=convert.plugins[self.appliEficas.format_fichier_in]()
+ p.readfile(fn)
+
+ if p.text=="" : self.nouveau=1
+ print ('PNPN --> CIST a faire')
+
+ pareil,texteNew=self.verifieChecksum(p.text)
+ if not pareil :
+ self.informe(tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"),False)
+
+ p.text=texteNew
+ memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
+ if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
+ p.text=texteNew
+
+ text=p.convert('exec',self.appliEficas)
+
+ if not p.cr.estvide(): self.afficheInfos("Erreur a la conversion",'red')
+ else :
+ self.afficheInfos("Type de fichier non reconnu",'red')
+ self.informe( "Type de fichier non reconnu",
+ "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
+ return None
+
+ CONTEXT.unsetCurrentStep()
+ jdc=self.readercata.cata[0].JdC(procedure=text,
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ nom=jdcName,
+ rep_mat=self.maConfiguration.rep_mat
+ )
+ self.modified = False
+ return jdc
+
+
+ #--------------------------------#
+ def _newJDC( self ,units = None):
+ #--------------------------------#
+ """
+ Initialise un nouveau JDC vierge
+ """
+ self.modified=1
+ CONTEXT.unsetCurrentStep()
+
+ texte=""
+ if self.code == "CARMELCND" : texte=self._newJDCCND()
+ if self.code == "ZCRACKS" : texte=self._newZCRACKS()
+ if self.code == "TELEMAC" : texte=self._newTELEMAC()
+ if self.code == "PSEN" : texte = self._newPSEN()
+ if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
+
+ if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
+
+
+ jdc=self.readercata.cata[0].JdC( procedure =texte,
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ rep_mat=self.maConfiguration.rep_mat
+ )
+ jdc.lang = self.appli.langue
+ if units is not None:
+ jdc.recorded_units=units
+ jdc.old_recorded_units=units
+ ## PNPN est ce que la ligne suivante est bien utile ?
+ if texte == "" :jdc.analyse()
+ return jdc
+
+ #--------------------------------#
+ def _newJDCInclude( self ,units = None):
+ #--------------------------------#
+ """
+ Initialise un nouveau JDC vierge
+ """
+ import Extensions.jdc_include
+ JdC_aux=Extensions.jdc_include.JdC_include
+ CONTEXT.unsetCurrentStep()
+
+ jaux=self.readercata.cata[0].JdC( procedure="",
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ rep_mat=self.maConfiguration.rep_mat,
+ )
+ jaux.analyse()
+
+ J=JdC_aux( procedure="",
+ appli=self,
+ cata=self.readercata.cata,
+ cata_ord_dico=self.readercata.cata_ordonne_dico,
+ jdc_pere=jaux,
+ rep_mat=self.maConfiguration.rep_mat,
+ )
+ J.analyse()
+ if units is not None:
+ J.recorded_units=units
+ J.old_recorded_units=units
+ return J
+
+
+
+ #-----------------------#
+ def getSource(self,file):
+ #-----------------------#
+
+ # Il faut convertir le contenu du fichier en fonction du format
+ if self.format in convert.plugins :
+ # Le convertisseur existe on l'utilise
+ p=convert.plugins[self.format]()
+ p.readfile(file)
+ text=p.convert('execnoparseur')
+ if not p.cr.estvide():
+ self.afficheInfos("Erreur a la conversion",'red')
+ return text
+ else:
+ # Il n'existe pas c'est une erreur
+ self.afficheInfos("Type de fichier non reconnu",'red')
+ self.informe( "Type de fichier non reconnu",
+ "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.format_fichier_in)
+ return None
+
+ #----------------------------------------------#
+ def __generateTempFilename(self, prefix, suffix):
+ #----------------------------------------------#
+ import tempfile
+ (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
+ os.close(fd)
+ return filename
+
+ #-----------------------#
+ def generDico(self):
+ #-----------------------#
+ if 'dico' in generator.plugins:
+ self.generator=generator.plugins['dico']()
+ jdc_formate=self.generator.gener(self.jdc)
+ dico=self.generator.Dico
+ return dico
+
+ #-----------------------#
+ def viewJdcSource(self):
+ #-----------------------#
+ if self.fichier == None : return
+ f=open(self.fichier,'r')
+ texteSource=f.read()
+ f.close()
+ self._viewText(texteSource, "JDC_SOURCE")
+
+ #-----------------------#
+ def viewJdcPy(self):
+ #-----------------------#
+ strSource = str( self.getTextJDC(self.format) )
+ self._viewText(strSource, "JDC_RESULTAT")
+
+ #-----------------------#
+ def viewJdcRapport(self):
+ #-----------------------#
+ # on ajoute les regles
+ strRapport = six.text_type( self.jdc.report() )
+ self._viewText(strRapport, "JDC_RAPPORT")
+
+ #---------------------#
+ def getFileName(self):
+ #---------------------#
+ return self.fichier
+
+ #-------------------#
+ def initModif(self):
+ #-------------------#
+ """
+ Met l'attribut modified a 'o' : utilise par Eficas pour savoir
+ si un JDC doit etre sauvegarde avant destruction ou non
+ """
+ self.modified = True
+
+
+ #--------------------------------------------------#
+ def writeFile(self, fn, txt = None,formatLigne="beautifie"):
+ #--------------------------------------------------#
+ """
+ Public slot to write the text to a file.
+
+ @param fn filename to write to string
+ @return flag indicating success
+ """
+
+ fn = six.text_type(fn)
+
+ if txt == None :
+ txt = self.getTextJDC(self.format,formatLigne=formatLigne)
+ eol = '\n'
+ if len(txt) >= len(eol):
+ if txt[-len(eol):] != eol:
+ txt += eol
+ else:
+ txt += eol
+ txt=self.ajoutVersionCataDsJDC(txt)
+ if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
+ else : checksum=''
+ txt=txt+checksum
+ if self.code=="TELEMAC" : return 1
+ try:
+ f = open(fn, 'w')
+ f.write(txt)
+ f.close()
+ return 1
+ except IOError as why:
+ self.afficheInfos('Sauvegarde du Fichier', 'Le fichier'+str(fn) + 'n a pas pu etre sauvegarde :' + str(why))
+ return 0
+
+ #-----------------------------------------------------------#
+ def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
+ #-----------------------------------------------------------#
+ if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
+ if format in generator.plugins:
+
+ # Le generateur existe on l'utilise
+ self.generator=generator.plugins[format]()
+ try :
+ jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
+ if pourRun : jdc_formate=self.generator.textePourRun
+ if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
+ except ValueError as e:
+ self.afficheInfos( "Erreur a la generation",str(e),'red')
+ return
+
+ if not self.generator.cr.estvide():
+ self.afficheInfos("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
+ return ""
+ else:
+ return jdc_formate
+ else:
+ # Il n'existe pas c'est une erreur
+ self.afficheInfos("Format inconnu", self.format + " non reconnu" )
+ return ""
+
+ #------------------------------#
+ def verifieChecksum(self,text):
+ #------------------------------#
+ # Attention : souci sous Windows
+ #
+ indexDeb=text.find("#CHECKSUM:")
+ if indexDeb < 0 : return 1, text
+ indexFin=text.find(":FIN CHECKSUM")
+ checkAvant=text[indexDeb:indexFin+13]
+ textJDC=text[0:indexDeb]+text[indexFin+13:-1]
+ if self.code != 'PSEN' and self.code != 'PSEN_N1':
+ checksum=self.getChecksum(textJDC)
+ pareil=(checkAvant==checksum)
+ else :
+ pareil=1
+ return pareil, textJDC
+
+ #---------------------------#
+ def getChecksum(self,texte):
+ #---------------------------#
+ newtexte=texte.replace('"','\\"')
+ commande='echo "'+newtexte+'"|md5sum'
+ a=os.popen(commande)
+ checksum=a.read()
+ a.close()
+ ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
+ return ligne
+
+ #----------------------#
+ def getDico(self):
+ #---------------------#
+ if 'dicoImbrique' in generator.plugins:
+ self.generator=generator.plugins['dicoImbrique']()
+ jdc_formate=self.generator.gener(self.jdc)
+ dico=self.generator.Dico
+ return dico
+ else :
+ self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
+ return ""
+
+ #-----------------------------------------#
+ def chercheGroupes(self):
+ #-----------------------------------------#
+ listeMA,listeNO=self.getTextJDC("GroupMA")
+ return listeMA,listeNO
+
+ #-----------------------------------------#
+ def chercheDico(self):
+ #-----------------------------------------#
+ dicoCourant={}
+ format = self.appliEficas.format_fichier
+ if format in generator.plugins:
+ # Le generateur existe on l'utilise
+ self.generator=generator.plugins[format]()
+ jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
+ dicoCourant=self.generator.dico
+ return dicoCourant
+
+ #-----------------------------------------------------------------#
+ def saveFileLegerAs(self, fileName = None) :
+ #-----------------------------------------------------------------#
+ if fileName != None :
+ self.fichier = fileName
+ return self.saveFileLeger()
+ return self.saveFileLeger()
+
+ #-----------------------------------------------------------------#
+ def saveFileLeger(self, fichier, formatLigne="beautifie"):
+ #-----------------------------------------------------------------#
+ fn = fichier
+ self.generator=generator.plugins[self.format]()
+ if hasattr(self.generator, "writeLeger"):
+ self.generator.writeLeger(fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
+
+
+# ---------------------------------------------
+# Methodes Surchargees par avecIhm
+# ---------------------------------------------
+
+ #--------------------------------#
+ def ajoutCommentaire(self):
+ #--------------------------------#
+ print ('pas programme sans Ihm')
+ print ('prevenir la maintenance du besoin')
+
+
+ #--------------------------------------#
+ def informe(self,titre,txt,critique=True):
+ #--------------------------------------#
+ # methode differenre avec et sans ihm
+ if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+ print (titre)
+ print (txt)
+ if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+
+ #--------------------------------------#
+ def afficheInfos(self,txt,couleur=None):
+ #--------------------------------------#
+ # methode differenre avec et sans ihm
+ print (txt)
+
+ #-----------------------------------------------------------------------#
+ def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
+ #--------------------------------------------------------------------#
+ print ('_____________________________')
+ print (txt)
+ print ('_____________________________')
+
+
+ #-----------------------------------------------------------------#
+ def saveFile(self, fichier, formatLigne="beautifie"):
+ #-----------------------------------------------------------------#
+ """
+ Public slot to save the text to a file.
+
+ @param path directory to save the file in (string or QString)
+ @return tuple of two values (boolean, string) giving a success indicator and
+ the name of the saved file
+ """
+
+
+ if not (self.writeFile(fichier,formatLigne=formatLigne)): return (0, None)
+ self.fichierOut = fichier
+
+ if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
+ self.generator.writeDefault(fichier)
+ elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
+ self.generator.writeDefault(fichier)
+
+ self.modified = 0
+
+ return (1, self.fichier)
+#
+
+ #----------------------------------------------#
+ def sauveLigneFile(self):
+ #----------------------------------------------#
+ self.modified=1
+ return self.saveFile(formatLigne="Ligne")
+
+
+ #-----------------------------------#
+ def updateJdc(self, itemApres,texte):
+ #------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ monItem=itemApres
+ etape=monItem.item.object
+ CONTEXT.setCurrentStep(etape)
+ etape.buildIncludeInclude(texte)
+ self.tree.racine.buildChildren()
+
+ #-----------------------------------#
+ def updateJdcEtape(self, itemApres,texte):
+ #------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ monItem=itemApres
+ etape=monItem.item.object
+ CONTEXT.set_current_step(etape)
+ try :
+ ok=etape.build_includeEtape(texte)
+ except :
+ ok=0
+ if not ok :
+ QMessageBox.information( self,
+ tr("Import texte"),
+ tr("Impossible d importer le texte"))
+ self.tree.racine.build_children()
+ return ok
+
+
+
+ #-------------------------------------#
+ def deleteEtape(self,etape):
+ #-------------------------------------#
+ # dans le JDC
+ self.jdc.suppentite(etape)
+
+ #-------------------------------------#
+ def deleteMC(self,etape,MCFils,listeAvant=()):
+ #-------------------------------------#
+ # dans le JDC
+ ouChercher=etape
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ if monMC != None : ouChercher.suppentite(monMC)
+ ouChercher.state='changed'
+ ouChercher.isvalid()
+
+ #-------------------------------------#
+ def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
+ #-------------------------------------#
+ # dans le JDC
+ ouChercher=etape
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ monMC=etape.get_child(ouChercher,restreint="oui")
+ if monMC== None : monMC= ouChercher.addentite(MCFils)
+ monMC.valeur=valeurs
+ monMC.val=valeurs
+ monMC.state='changed'
+ monMC.isvalid()
+
+ #----------------------------------------------#
+ def ajoutMCFact(self,etape,MCFils,listeAvant=()):
+ #----------------------------------------------#
+ # dans le JDC
+ print ('ajoutMCFact')
+ ouChercher=etape
+ print (ouChercher)
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ print (mot)
+ print (ouChercher)
+ monMC=etape.get_child(ouChercher,restreint="oui")
+ if monMC== None : monMC= ouChercher.addentite(MCFils)
+ monMC.isvalid()
+
+ #-------------------------------------------------#
+ def getValeur(self,nomEtape,MCFils,listeAvant=()):
+ #-------------------------------------------------#
+ # dans le JDC
+
+ ouChercher=None
+ for e in self.jdc.etapes:
+ if e.nom == nomEtape : ouChercher=e; break
+ if debug : print ('etape trouvee', ouChercher)
+ if ouChercher==None : return None
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ if debug : print (mot, ouChercher)
+ if ouChercher==None : return None
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ if debug : print ('monMC', monMC)
+ if monMC== None : return None
+ return monMC.valeur
+
+ #-----------------------------------------------------------#
+ def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
+ #--------------------------------------------------------#
+ # dans le JDC
+
+ ouChercher=None
+ for e in self.jdc.etapes:
+ if e.nom == nomEtape : ouChercher=e; break
+ if ouChercher==None : return None
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ #print (mot, ouChercher)
+ if ouChercher==None : return None
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ monMC.set_valeur(valeur)
+ monMC.isvalid()
+
+ #-----------------------------------------------------------#
+ def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
+ #-----------------------------------------------------------#
+ # dans le JDC
+ ouChercher=etape
+ if isinstance (etape, str):
+ ouChercher=None
+ for e in self.jdc.etapes:
+ if e.nom == etape : ouChercher=e; break
+ if ouChercher==None : return
+
+ for mot in listeAvant :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ if ouChercher==None : return
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ if monMC== None : monMC= ouChercher.addentite(MCFils)
+
+ monMC.definition.into=valeurs
+ from Noyau.N_VALIDATOR import IntoProtocol
+ monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
+ monMC.state='changed'
+ monMC.isvalid()
+
+ #-------------------------------------------------------------------#
+ def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
+ #-------------------------------------------------------------------#
+ # dans le JDC
+ for e in self.jdc.etapes:
+ if e.nom == nomEtape : ouChercher=e; break
+
+ for mot in listeAvant :
+ try :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ # Le mot clef n est pas la
+ except : return 0
+ try :
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ # Le mot clef n est pas la
+ except : return 0
+ if monMC == None : return 0
+
+ if hasattr(monMC.definition,'into') :
+ if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
+ else : maListeDeValeur=monMC.definition.into
+ else :
+ return 0
+
+ monMC.state='changed'
+ return 1
+
+ #-------------------------------------#
+ def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
+ #-------------------------------------#
+ # dans le MDD
+
+ #if isinstance (etape, str):
+ # for e in self.jdc.etapes:
+ # if e.nom == etape : etape=e; break
+ #if etape == None : return
+ definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+ ouChercher=definitionEtape
+ if len(listeMC) > 1 :
+
+ for mc in listeMC[0:-1]:
+ mcfact=ouChercher.entites[mc]
+ ouChercher=mcfact
+
+ mcAccas=ouChercher.entites[listeMC[-1]]
+ mcAccas.defaut=valeurs
+ return 1
+
+ #------------------------------------------------#
+ def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
+ #------------------------------------------------#
+ # dans le MDD
+ definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+ ouChercher=definitionEtape
+
+ if len(listeMC) > 1 :
+ for mc in listeMC[0:-1]:
+ mcfact=ouChercher.entites[mc]
+ ouChercher=mcfact
+ mcAccas=ouChercher.entites[listeMC[-1]]
+
+ if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
+ else : oldValeurs=None
+ if oldValeurs==valeurs : return 0
+
+ mcAccas.into=valeurs
+ from Noyau.N_VALIDATOR import IntoProtocol
+ mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
+ return 1
+
+ #-------------------------------------------------------------#
+ def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
+ #-------------------------------------------------------------#
+ # dans le MDD
+ #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
+ if isinstance (etape, str):
+ for e in self.jdc.etapes:
+ if e.nom == etape : etape=e; break
+ if etape == None : return
+ definitionEtape=getattr(self.jdc.cata[0],etape)
+ ouChercher=definitionEtape
+ for k in listeAvant :
+ ouChercher=ouChercher.entites[k]
+ MCADetruire=ouChercher.entites[nomDuMC]
+ ouChercher.ordre_mc.remove(nomDuMC)
+ print ('remove de ', nomDuMC)
+ del ouChercher.entites[nomDuMC]
+ del self.dicoNouveauxMC[nomDuMC]
+
+
+ #-------------------------------------------------------------#
+ def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
+ #-------------------------------------------------------------#
+ # dans le MDD
+ definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+ ouChercher=definitionEtape
+ for k in listeAvant :
+ ouChercher=ouChercher.entites[k]
+ from Accas import A_SIMP
+ Nouveau=A_SIMP.SIMP(typ,**args)
+ Nouveau.pere=ouChercher
+ Nouveau.nom=nomDuMC
+ #Nouveau.ordre_mc=[]
+ ouChercher.entites[nomDuMC]=Nouveau
+ ouChercher.ordre_mc.append(nomDuMC)
+ #print ('ajout de ', nomDuMC)
+ #traceback.print_stack()
+ # ajout CIST sauvegarde
+ if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
+ self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
+ #print self.dicoNouveauxMC
+
+ #---------------------------------------------------------------------#
+ def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
+ #---------------------------------------------------------------------#
+ # dans le MDD
+ print ('ajoutDefinitionMCFact', nomDuMC)
+ definitionEtape=getattr(self.jdc.cata[0],nomEtape)
+ ouChercher=definitionEtape
+ for k in listeAvant :
+ ouChercher=ouChercher.entites[k]
+ from Accas import A_SIMP
+ for mc in listeMC :
+ nomMC=mc[0]
+ typMC=mc[1]
+ argsMC=mc[2]
+ nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
+ nouveauMC.nom=nomMC
+ args[nomMC]=nouveauMC
+ from Accas import A_FACT
+ nouveauFact=A_FACT.FACT(**args)
+ nouveauFact.pere=ouChercher
+ nouveauFact.nom=nomDuMC
+ from Editeur.autre_analyse_cata import traite_entite
+ traite_entite(nouveauFact,[])
+ ouChercher.entites[nomDuMC]=nouveauFact
+ ouChercher.ordre_mc.append(nomDuMC)
+ self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
+ #print self.dicoNouveauxMC
+
+ #----------------------------------------------------#
+
+ #----------------------------------------------------#
+ def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
+ #----------------------------------------------------#
+ # dans le MDD et le JDC
+
+ self.changeIntoDefMC(etape,listeMC,into)
+
+ if isinstance (etape, str):
+ for e in self.jdc.etapes:
+ if e.nom == etape : etape=e; break
+ if etape == None : return
+
+ ouChercher = etape
+ for mot in listeMC[:-1] :
+ ouChercher=ouChercher.get_child(mot,restreint="oui")
+ if ouChercher==None : return
+ MCFils=listeMC[-1]
+ monMC=ouChercher.get_child(MCFils,restreint="oui")
+ if monMC== None : monMC= etape.addentite(MCFils)
+
+ monMC.definition.into=into
+ monMC.valeur=valeurs
+ monMC.val=valeurs
+ monMC.state='changed'
+ monMC.isvalid()
+
+ #-------------------------------------#
+ def ajoutVersionCataDsJDC(self,txt):
+ #-------------------------------------#
+ if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
+ ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata[0].VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
+ texte=txt+ligneVersion
+ return texte
+
+ #-------------------------------------#
+ def verifieVersionCataDuJDC(self,text):
+ #-------------------------------------#
+ memeVersion=False
+ indexDeb=text.find("#VERSION_CATALOGUE:")
+ indexFin=text.find(":FIN VERSION_CATALOGUE")
+ if indexDeb < 0 :
+ self.versionCataDuJDC="sans"
+ textJDC=text
+ else :
+ self.versionCataDuJDC=text[indexDeb+19:indexFin]
+ textJDC=text[0:indexDeb]+text[indexFin+23:-1]
+
+ self.versionCata="sans"
+ if hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata[0].VERSION_CATALOGUE
+
+ if self.versionCata==self.versionCataDuJDC : memeVersion=True
+ return memeVersion,textJDC
+
+ #-------------------------------#
+ def traduitCatalogue(self,texte):
+ #-------------------------------#
+ nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
+ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
+ try :
+ traducteur=__import__(nomTraducteur)
+ monTraducteur=traducteur.MonTraducteur(texte)
+ nouveauTexte=monTraducteur.traduit()
+ return nouveauTexte
+ except :
+ return texte
+
+
+# Methodes a resorber
+# il faut mettre a jour les catalogues avec
+# TEXTE_NEW_JDC
+#
+
+ #---------------------------#
+ def _new_CF(self):
+ #---------------------------#
+ texte="CONDUITE_FORCEE();"
+ return texte
+
+ #---------------------------#
+ def _newTELEMAC(self):
+ #---------------------------#
+ #texte="INITIALIZATION();BOUNDARY_CONDITIONS();GENERAL_PARAMETERS();PHYSICAL_PARAMETERS();NUMERICAL_PARAMETERS();"
+ texte="COMPUTATION_ENVIRONMENT();HYDRO();GENERAL_PARAMETERS();NUMERICAL_PARAMETERS()"
+ #texte="TRACERS();"
+ return texte
+
+ #---------------------------#
+ def _newPSEN(self):
+ #---------------------------#
+ texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
+ #texte=""
+ return texte
+
+ #---------------------------#
+ def _newPSEN_N1(self):
+ #---------------------------#
+ texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
+ #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
+ return texte
+
+ #---------------------------#
+ def _newZCRACKS(self):
+ #---------------------------#
+ texte="MAILLAGES();REMESHING();"
+ return texte
+
+
+ #---------------------------#
+ def _newJDCCND(self):
+ #---------------------------#
+ extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
+
+ #if self.salome == 0 :
+ QMessageBox.information( self,
+ tr("Fichier Med"),
+ tr("Veuillez selectionner un fichier Med"))
+ QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
+ caption='Fichier Med',
+ filter=extensions)
+ QSfichier=QSfichier[0]
+ self.fichierMED=QSfichier
+ from acquiertGroupes import getGroupes
+ erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
+ if erreur != "" : print ("a traiter")
+ texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
+ texteSources=""
+ texteCond=""
+ texteNoCond=""
+ texteVcut=""
+ texteZs=""
+ for groupe in self.listeGroupes :
+ if groupe[0:8]=='CURRENT_':
+ texteSources +=groupe[8:]+"=SOURCE("
+ texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
+ if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
+ if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
+ if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
+ if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
+ texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
+ self.newTexteCND=texte
+ self.modified=1
+ return texte
+
+
+if __name__ == "__main__":
+ print ('a faire')
if ihmQTDir not in sys.path : sys.path.append(ihmQTDir)
if editeurDir not in sys.path :sys.path.append(editeurDir)
+#def getEficasSsIhm(code='Adao',versionCode='V0'):
+# from .qtEficasSsIhm import AppliSsIhm
+# Eficas=AppliSsIhm(code=code,ssCode=None,salome=0)
+# return Eficas
+def getEficasSsIhm(code=None,fichier=None,ssCode=None,multi=False,langue='en',versionCode=None):
+ print (versionCode)
+ from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
+ Eficas=AppliSsIhm(code=code,salome=0,ssCode=ssCode,multi=multi,langue=langue,versionCode=versionCode)
+ from Editeur import session
+ options=session.parse(['ssIhm','-k',code,'-v',versionCode])
+ return Eficas
+
def lanceEficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
"""
parameters=getJdcParameters(texte,macro)
return parameters
-def getEficasSsIhm(code='Adao',versionCode='V0'):
- from .qtEficasSsIhm import AppliSsIhm
- app = QApplication(sys.argv)
- Eficas=Appli(code=code,ssCode=None,salome=0)
- return Eficas
+#def getEficasSsIhm(code='Adao',versionCode='V0'):
+# from .qtEficasSsIhm import AppliSsIhm
+# Eficas=AppliSsIhm(code=code,ssCode=None,salome=0)
+# return Eficas
def getJdcParameters(jdc,macro):
"""
self.item = jdc_item
self.node = node
self.editor = editor
+ self.simpleClic=self.editor.maConfiguration.simpleClic
self.jdc = self.item.object.getJdcRoot()
debutTitre=self.editor.titre
self.listeWidget=[]
else :
self.RBRegle.clicked.connect(self.afficheRegle)
- if self.editor.Ordre_Des_Commandes == None : self.RBOrdre.close()
+ if self.editor.readercata.Ordre_Des_Commandes == None : self.RBOrdre.close()
#self.editor.labelCommentaire.setText("")
self.boolAlpha=0
self.boolGroupe=0
self.boolOrdre=0
- if self.editor.affiche=="alpha" :
+ if self.editor.maConfiguration.affiche=="alpha" :
self.boolAlpha==1;
self.RBalpha.setChecked(True);
self.afficheAlpha()
- elif self.editor.affiche=="groupe" :
+ elif self.editor.maConfiguration.affiche=="groupe" :
self.boolGroupe==1;
self.RBGroupe.setChecked(True);
self.afficheGroupe()
- elif self.editor.affiche=="ordre" :
+ elif self.editor.maConfiguration.affiche=="ordre" :
self.boolOrdre==1;
self.RBOrdre.setChecked(True);
self.afficheOrdre()
- if self.editor.closeFrameRechercheCommande == True : self.frameAffichage.close()
+ if self.editor.maConfiguration.closeFrameRechercheCommande == True : self.frameAffichage.close()
if self.editor.widgetTree != None : self.editor.restoreSplitterSizes(2)
else: self.editor.restoreSplitterSizes(3)
return listeACreer
def ajouteRadioButtons(self):
- if self.editor.nombreDeBoutonParLigne != 0 :
+ if self.editor.maConfiguration.nombreDeBoutonParLigne != 0 :
self.ajoutePushButtons()
return
#print 'ds ajouteRadioButtons'
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
- #if self.editor.simpleClic : rbcmd.mouseReleaseEvent=self.insereNoeudApresClick
+ #if self.simpleClic : rbcmd.mouseReleaseEvent=self.insereNoeudApresClick
#else : rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
#self.buttonGroup.buttonClicked.connect(self.rbClique)
- if not(self.editor.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
- if self.editor.simpleClic :
+ if not(self.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
+ if self.simpleClic :
self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
else :
self.buttonGroup.buttonClicked.connect(self.rbClique)
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
- if not(self.editor.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
- if self.editor.simpleClic :
+ if not(self.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
+ if self.simpleClic :
self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
else :
self.buttonGroup.buttonClicked.connect(self.rbClique)
elif self.boolOrdre==1 :
listeFiltre=self.creeListeCommande(filtre)
liste=[]
- if self.editor.Ordre_Des_Commandes == None : Ordre_Des_Commandes=listeFiltre
- else : Ordre_Des_Commandes=self.editor.Ordre_Des_Commandes
+ if self.editor.readercata.Ordre_Des_Commandes == None : Ordre_Des_Commandes=listeFiltre
+ else : Ordre_Des_Commandes=self.editor.readercata.Ordre_Des_Commandes
for cmd in Ordre_Des_Commandes :
if cmd in listeFiltre :
liste.append(cmd)
rbcmd=(QRadioButton(tr(cmd)))
self.buttonGroup.addButton(rbcmd)
self.commandesLayout.addWidget(rbcmd)
- if not(self.editor.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
- if self.editor.simpleClic :
+ if not(self.simpleClic ): rbcmd.mouseDoubleClickEvent=self.insereNoeudApresClick
+ if self.simpleClic :
self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
else :
self.buttonGroup.buttonClicked.connect(self.rbClique)
liste=self.creeListeCommande(None)
listeFiltre=self.creeListeCommande(None)
liste=[]
- if self.editor.Ordre_Des_Commandes == None : Ordre_Des_Commandes=listeFiltre
- else : Ordre_Des_Commandes=self.editor.Ordre_Des_Commandes
+ if self.editor.readercata.Ordre_Des_Commandes == None : Ordre_Des_Commandes=listeFiltre
+ else : Ordre_Des_Commandes=self.editor.readercata.Ordre_Des_Commandes
for cmd in Ordre_Des_Commandes :
if cmd in listeFiltre :
liste.append(cmd)
for cmd in liste :
col=col+1
- if col == self.editor.nombreDeBoutonParLigne :
+ if col == self.editor.maConfiguration.nombreDeBoutonParLigne :
col=0
ligne=ligne+1
self.dicoCmd[tr(cmd)]=cmd
"border-width : 30 px;\n"
"border-color : beige;\n"
"text-align : center")
- if cmd in self.editor.dicoImages :
- fichier=self.editor.dicoImages[cmd]
+ print ('self.editor.maConfiguration.dicoImages', self.editor.maConfiguration.dicoImages)
+ if cmd in self.editor.maConfiguration.dicoImages :
+ fichier=self.editor.maConfiguration.dicoImages[cmd]
icon = QIcon()
icon.addPixmap(QPixmap(fichier), QIcon.Normal, QIcon.Off)
rbcmd.setIcon(icon)
from __future__ import absolute_import
from PyQt5.QtWidgets import QCheckBox, QWidget, QLabel, QPushButton
-from PyQt5.QtCore import Qt, QRect
+from PyQt5.QtCore import Qt, QRect
+from PyQt5.QtGui import QPalette
-from Extensions.i18n import tr
+from Extensions.i18n import tr
from desGroupeOptionnel import Ui_groupeOptionnel
-from desPBOptionnelMT import Ui_customPB
+from desPBOptionnelMT import Ui_customPB
# Import des panels
class monRBButtonCustom(QCheckBox):
- def __init__(self,texte,monOptionnel,parent=None):
+ def __init__(self,texte,monOptionnel,parent=None,couleur=None):
QCheckBox.__init__(self,tr(texte),parent)
self.mousePressed=True
self.monOptionnel=monOptionnel
self.setToolTip(tr("clicker: affichage aide, double-click: ajout"))
+ if couleur != None :
+ mapalette=self.palette()
+ mapalette.setColor( QPalette.WindowText, couleur )
+ self.setPalette( mapalette );
+ self.setText(tr(texte))
+
def mouseDoubleClickEvent(self, event):
#print "dans mouseDoubleClickEvent", self
class monPBButtonCustom(QWidget,Ui_customPB):
- def __init__(self,texte,monOptionnel,parent=None):
+ def __init__(self,texte,monOptionnel,parent=None,couleur=None):
QWidget.__init__(self)
self.setupUi(self)
+ if couleur != None :
+ mapalette=self.monPb.palette()
+ mapalette.setColor( QPalette.ButtonText, Qt.red )
+ self.monPb.setPalette( mapalette );
self.monPb.setText(texte)
self.monPb.clicked.connect(self.ajoutMC)
if liste != [] :
self.affiche(liste,liste_rouge)
self.afficheTitre()
- elif self.parentQt.parentQt.afficheOptionnelVide != False :
+ elif self.parentQt.parentQt.maConfiguration.afficheOptionnelVide != False :
self.afficheTitre()
self.MCOptionnelLayout.insertWidget(0,QLabel(tr('Pas de MC Optionnel')))
else :
self.dicoCb={}
liste.reverse()
for mot in liste :
- if mot in liste_rouge : print ('je dois afficher en rouge' , mot)
- if self.parentQt.parentQt.simpleClic == False :
- cb = monRBButtonCustom(mot,self)
+ #if mot in liste_rouge : print ('je dois afficher en rouge' , mot)
+ couleur=None
+ if mot in liste_rouge : couleur=Qt.red
+ print (mot,couleur)
+ if self.parentQt.parentQt.maConfiguration.simpleClic == False :
+ cb = monRBButtonCustom(mot,self,couleur=couleur)
cb.clicked.connect(cb.ajoutAideMC)
else :
- cb = monPBButtonCustom(mot,self)
+ cb = monPBButtonCustom(mot,self,couleur=couleur)
self.MCOptionnelLayout.insertWidget(0,cb)
self.dicoCb[cb]=mot
self.scrollAreaCommandesOptionnelles.horizontalScrollBar().setSliderPosition(0)
-
-
for nomEtape in self.appliEficas.readercata.cata_ordonne_dico:
toolButton = QToolButton(self.appliEficas.toolBarCommande)
icon = QIcon()
- if nomEtape in self.appliEficas.readercata.dicoIcones:
- fichier = self.appliEficas.readercata.dicoIcones[nomEtape]
+ if nomEtape in self.appliEficas.maConfiguration.dicoIcones:
+ fichier = self.appliEficas.maConfiguration.dicoIcones[nomEtape]
icon.addPixmap(QPixmap(fichier), QIcon.Normal, QIcon.Off)
toolButton.setIcon(icon)
else :
self.labelNomCommande.setText(tr(self.obj.nom))
- if self.editor.closeAutreCommande == True : self.closeAutreCommande()
+ if self.editor.maConfiguration.closeAutreCommande == True : self.closeAutreCommande()
else :
try :
self.bCatalogue.clicked.connect(self.afficheCatalogue)
if hasattr(self,'LENom'): self.LENom.returnPressed.connect(self.nomChange)
- if self.editor.code in ['Adao','ADAO'] and self.editor.closeFrameRechercheCommande==True :
+ if self.editor.code in ['Adao','ADAO'] and self.editor.maConfiguration.closeFrameRechercheCommande==True :
self.frameAffichage.close()
if self.editor.code in ['CARMELCND',] : self.closeAutreCommande()
# self.labelNomCommande.setText(tr(self.obj.nom))
#
#
-# if self.editor.closeAutreCommande == True : self.closeAutreCommande()
+# if self.editor.maConfiguration.closeAutreCommande == True : self.closeAutreCommande()
# else :
# try :
# self.bCatalogue.clicked.connect(self.afficheCatalogue)
del self.dicoMCWidgetOptionnel[k]
def titre(self,MC):
- if self.parentCommande.node.editor.code in ['Adao','ADAO'] and self.parentCommande.node.editor.closeFrameRechercheCommande==True :
+ if self.parentCommande.node.editor.code in ['Adao','ADAO'] and self.parentCommande.node.editor.maConfiguration.closeFrameRechercheCommande==True :
self.frameLabelCommande.close()
return
labeltext,fonte,couleur = self.parentCommande.node.item.getLabelText()
+#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
# Copyright (C) 2007-2017 EDF R&D
#
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt, QSize
-from Extensions.i18n import tr
-from Extensions.eficas_exception import EficasException
-from Extensions import param2
-
-from myMain import Ui_Eficas
-from .viewManager import MyTabview
-from .getVersion import getEficasVersion
from Editeur import session
+from myMain import Ui_Eficas
+from InterfaceQT4.viewManager import MyViewManager
+from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from Extensions import param2
-class Appli(Ui_Eficas,QMainWindow):
+class Appli(AppliSsIhm,Ui_Eficas,QMainWindow):
"""
Class implementing the main user interface.
"""
- def __init__(self,code=None,salome=1,parent=None,ssCode=None,multi=False,langue='fr',ssIhm=False):
+ def __init__(self,code=None,salome=1,parent=None,ssCode=None,multi=False,langue='fr',ssIhm=False,versionCode=None):
"""
Constructor
"""
+ if ssIhm == True :
+ print ('mauvaise utilisation de la classe Appli. Utiliser AppliSsIm SVP')
+ exit()
+
+ AppliSsIhm.__init__(self,code,salome,parent,ssCode,multi,langue,ssIhm=True,versionCode=None)
QMainWindow.__init__(self,parent)
Ui_Eficas.__init__(self)
-
-
- version=getEficasVersion()
- self.VERSION_EFICAS="Eficas QT5 Salome " + version
- self.salome=salome
- self.parentMainWindow=parent
- self.ihm="QT"
- self.ssIhm=ssIhm
- self.top = self #(pour maConfiguration)
- self.QWParent=None #(Pour lancement sans IHM)
- self.code=code
- self.indice=0
- self.first=1
- self.dict_reels={}
- self.recent = []
- self.ficRecents={}
- self.mesScripts={}
- self.listeAEnlever=[]
- self.ListePathCode=['Adao','ADAO','Carmel3D','Telemac','CF','MAP','ZCracks', 'SEP','SPECA','PSEN_Eficas','PSEN_N1']
- self.listeCode=['Adao','ADAO','Carmel3D','Telemac','CF','MAP','ZCracks', 'SEP','SPECA','PSEN_Eficas','PSEN_N1']
- self.repIcon=os.path.join( os.path.dirname(os.path.abspath(__file__)),'..','Editeur','icons')
-
-
- if self.salome:
- import Accas
- try :
- import eficasSalome
- Accas.SalomeEntry = eficasSalome.SalomeEntry
- except :
- print ('eficas hors salome')
-
+ self.ssIhm=False
self.multi=multi
- self.demande=multi # specifique PSEN
-
- if langue=='fr': self.langue=langue
- else : self.langue="ang"
+ self.demande=multi # voir PSEN
if self.multi == False :
self.definitCode(code,ssCode)
if code==None: return
else :
- OOOOOOOOOOO
+ print ('a programmer')
self.suiteTelemac=False
if hasattr (self, 'maConfiguration') :
if self.maConfiguration.force_langue :
- from .monChoixLangue import MonChoixLangue
+ from InterfaceQt4.monChoixLangue import MonChoixLangue
widgetLangue = MonChoixLangue(self)
ret=widgetLangue.exec_()
self.suiteTelemac=self.maConfiguration.suiteTelemac
from Extensions import localisation
app=QApplication
if hasattr (self, 'maConfiguration') : localisation.localise(None,self.langue,translatorFichier=self.maConfiguration.translatorFichier)
-
self.setupUi(self)
+
#if parent != None : self.parentCentralWidget = parent.centralWidget()
#else : self.parentCentralWidget = None
if hasattr (self, 'maConfiguration') and hasattr(self.maConfiguration,'taille') : self.taille=self.maConfiguration.taille
else : self.taille=1700
- if self.code in ['MAP',] : self.resize(1440,self.height())
- else : self.resize(self.taille,self.height())
+ #if self.code in ['MAP',] : self.resize(1440,self.height())
+ #else : self.resize(self.taille,self.height())
+ self.resize(self.taille,self.height())
icon = QIcon(self.repIcon+"/parametres.png")
eficas_root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- self.viewmanager = MyTabview(self)
+ self.viewmanager = MyViewManager(self)
self.recentMenu=QMenu(tr('&Recents'))
#self.menuFichier.insertMenu(self.actionOuvrir,self.recentMenu)
self.ssCode=ssCode
if self.code==None :
self.cleanPath()
- from .monChoixCode import MonChoixCode
+ from InterfaceQt4.monChoixCode import MonChoixCode
widgetChoix = MonChoixCode(self)
#ret=widgetChoix.exec_()
widgetChoix.show()
- import sys
if self.code == None:return # pour le cancel de la fenetre choix code
- name='prefs_'+self.code
- prefsCode=__import__(name)
-
- self.repIni=prefsCode.repIni
- if ssCode != None :
- self.format_fichier= ssCode #par defaut
- prefsCode.NAME_SCHEME=ssCode
- else :
- self.format_fichier="python" #par defaut
-
- nameConf='configuration_'+self.code
- configuration=__import__(nameConf)
- self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
-
- if hasattr (self,'maConfiguration') and self.maConfiguration.translatorFichier :
- from Extensions import localisation
- localisation.localise(None,self.langue,translatorFichier=self.maConfiguration.translatorFichier)
+ AppliSsIhm.definitCode(self,code,ssCode)
- print ('self.closeAutreCommande',self.maConfiguration.closeAutreCommande)
#PN --> pb d exception qui font planter salome
# plus supporte en python 3
#app=QApplication
import os, sys
import six
-from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
from Extensions import param2
-from InterfaceQT4.viewManagerSsIhm import MyTabviewSsIhm
-
from InterfaceQT4.getVersion import getEficasVersion
-
-from editorSsIhm import JDCEditorSsIhm
+from InterfaceQT4.viewManagerSsIhm import MyViewManagerSsIhm
+#from editorSsIhm import JDCEditorSsIhm
class AppliSsIhm:
"""
version=getEficasVersion()
self.VERSION_EFICAS="Eficas QT5 Salome " + version
- self.version_code=versionCode
+ self.versionCode=versionCode
self.salome=salome
self.ssIhm=True
print ('eficas hors salome')
self.multi=multi
- self.demande=multi # specifique PSEN
+ if self.multi :
+ print ('pas de multi sans ihm')
+ exit()
+
if langue=='fr': self.langue=langue
else : self.langue="ang"
if code==None: return
self.suiteTelemac=False
- self.viewmanager = MyTabviewSsIhm(self)
+ self.viewmanager=MyViewManagerSsIhm(self)
def definitCode(self,code,ssCode) :
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
- self.CONFIGURATION = configuration.make_config(self,prefsCode.repIni)
- self.CONFIGStyle = None
- if hasattr(configuration,'make_config_style'):
- self.CONFIGStyle = configuration.make_config_style(self,prefsCode.repIni)
-
-
-
- def fileNew(self):
- self.viewmanager.newEditor()
-
- def fileOpen(self,fichier):
- self.viewmanager.handleOpen(fichier)
-
- def fileSave(self):
- return self.viewmanager.saveCurrentEditor()
-
- def fileSaveAs(self,fichier):
- return self.viewmanager.saveAsCurrentEditor(fichier)
-
- def fileClose(self):
- self.viewmanager.handleClose()
+ self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
- def jdcRapport(self):
- return self.viewmanager.jdcRapport()
+ if hasattr (self,'maConfiguration') and self.maConfiguration.translatorFichier :
+ from Extensions import localisation
+ localisation.localise(None,self.langue,translatorFichier=self.maConfiguration.translatorFichier)
- def jdcText(self):
- return self.viewmanager.jdcText()
-
- def jdcDico(self):
- return self.viewmanager.jdcDico()
-
- def jdcDicoPython(self):
- return self.viewmanager.jdcDicoPython()
def getSource(self,file):
# appele par Editeur/session.py
- # a garder pour les poursuites
- # le format n est pas le meme que celui de la fonction jdcText
import convert
p=convert.plugins['python']()
p.readfile(file)
texte=p.convert('execnoparseur')
return texte
+
+ def initEditor(self,fichier = None,jdc = None, units = None,include=0):
+ if self.editor != None :
+ print ('un seul editeur par appli')
+ sys.Exit()
+ self.editor = JDCEditorSsIhm(self,fichier, jdc, self.myQtab,units=units,include=include)
+
+
+ def fileNew(self):
+ self.editor=initEditor(self)
+
+ def getEditor(self):
+ return self.editor
+
+ def fileOpen(self,fichier):
+ fichierIn = os.path.abspath(six.text_type(fichier))
+ try:
+ monEditor=self.viewmanager.handleOpen(fichierIn)
+ except EficasException as exc:
+ print ('poum')
+ monEditor=None
+ return monEditor
+
+ def fileSave(self):
+ if self.editor == None : return False
+ ok, newName = editor.saveFileAs()
+ print ('ok, newName ',ok, newName)
+
+ def fileSaveAs(self,fileName):
+ if self.editor == None : return False
+ ok = editor.saveFileAs()
+ print ('ok ',ok)
+
+#,self.fileSaveAs
+#,self.fileClose
+#,self.fileExit
+#,self.jdcRapport
+#,self.jdcRegles
+#,self.jdcFichierSource
+#,self.visuJdcPy
+
+
+
if __name__=='__main__':
# Modules Eficas
class READERCATA(object):
def __init__(self,QWParent, appliEficas):
+ print ('----------------------')
+ print ('dans init de readercata')
+ print ('----------------------')
self.QWParent=QWParent
self.appliEficas=self.QWParent.appliEficas
self.VERSION_EFICAS=self.appliEficas.VERSION_EFICAS
- self.code=self.QWParent.code
+ self.code=self.appliEficas.code
self.ssCode=self.appliEficas.ssCode
self.appliEficas.format_fichier='python'
- self.version_code=self.QWParent.version_code
- self.version_cata=None
+ self.versionCode=self.appliEficas.versionCode
self.fic_cata=None
self.openCata()
self.traiteIcones()
return
- if self.version_code is not None:
+ if self.versionCode is not None:
# La version a ete fixee
for cata in liste_cata_possibles:
- if self.version_code == cata.identifier:
+ if self.versionCode == cata.identifier:
self.fic_cata = cata.cata_file_path
self.appliEficas.format_fichier = cata.file_format
self.appliEficas.format_fichier_in = cata.file_format_in
sys.exit(1)
elif len(cata_choice_list) == 1:
self.fic_cata = cata_choice_list[0].cata_file_path
- self.version_code = cata_choice_list[0].identifier
+ self.versionCode = cata_choice_list[0].identifier
self.appliEficas.format_fichier = cata_choice_list[0].file_format
self.appliEficas.format_fichier_in = cata_choice_list[0].file_format_in
else:
if self.fic_cata == None :
if self.appliEficas.salome == 0 :
- print(("Pas de catalogue pour code %s, version %s" %(self.code,self.version_code)))
+ print(("Pas de catalogue pour code %s, version %s" %(self.code,self.versionCode)))
sys.exit(1)
else :
self.appliEficas.close()
self.cata=(self.cata,)
self.titre=self.VERSION_EFICAS+" "+tr( " avec le catalogue ") + os.path.basename(self.fic_cata)
- if self.appliEficas.top:
+ if self.appliEficas.ssIhm == False :
self.appliEficas.setWindowTitle(self.titre)
self.appliEficas.titre=self.titre
self.QWParent.titre=self.titre
if ret == QDialog.Accepted:
print (widgetChoix.CBChoixCata.currentIndex())
cata = cata_choice_list[widgetChoix.CBChoixCata.currentIndex()]
- self.version_cata = cata.identifier
self.fic_cata = cata.cata_file_path
- self.version_code = self.version_cata
+ self.versionCode = cata.identifier
self.appliEficas.format_fichier = cata.file_format
self.appliEficas.format_fichier_in = cata.file_format_in
- lab+=self.version_cata
+ lab+=self.versionCata
self.appliEficas.setWindowTitle(lab)
#qApp.mainWidget().setCaption(lab)
widgetChoix.close()
try:
ficIcones=self.appliEficas.maConfiguration.ficIcones
fichierIcones = __import__(ficIcones, globals(), locals(), [], -1)
- self.dicoIcones=fichierIcones.dicoDesIcones.dicoIcones
+ self.appliEficas.maConfiguration.dicoIcones=fichierIcones.dicoDesIcones.dicoIcones
+ self.appliEficas.maConfiguration.dicoImages=fichierIcones.dicoDesIcones.dicoIcones
except:
print ("Pas de fichier associe contenant des liens sur les icones ")
- self.dicoIcones={}
+ self.appliEficas.maConfiguration.dicoIcones={}
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2017 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-# permet de lancer EFICAS en n affichant rien
-try :
- from builtins import object
-except : pass
-
-class appliEficasSSIhm(object):
- def __init__ (self,code):
- self.VERSION_EFICAS="Sans Ihm"
- self.code=code
- self.ssCode=None
- self.salome=None
- self.top=None
- self.indice=0
- self.dict_reels={}
- self.listeAEnlever=[]
-
-
- name='prefs_'+self.code
- try :
- prefsCode=__import__(name)
- except :
- name='prefs_'+self.code.upper()
- self.code=self.code.upper()
- prefsCode=__import__(name)
-
-
- self.repIni=prefsCode.repIni
- self.format_fichier="python" #par defaut
-
- nameConf='configuration_'+self.code
- configuration=__import__(nameConf)
- self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
-
-class QWParentSSIhm(object):
- def __init__(self,code,version_code):
- self.ihm="QT"
- self.code=code
- self.version_code=version_code
- self.format_fichier="python" #par defaut
-
from PyQt5.QtCore import QFileInfo
DictExtensions= {"MAP" : ".map"}
-class MyTabview(object):
+class MyViewManager(object):
def __init__(self,appliEficas):
self.appliEficas=appliEficas
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import os
+from Extensions.i18n import tr
+import six
+from PyQt5.QtWidgets import QFileDialog, QMessageBox
+from PyQt5.QtCore import QFileInfo
+
+# --------------------------------
+class JdcSsIhmHandler(object):
+# --------------------------------
+# retourne a l utilisateur
+
+ def __init__(self,viewManager):
+# --------------------------------------
+ self.viewManagerSsIhm=viewManager
+
+ def viewJdcPy(self) :
+# ---------------------
+ self.viewManagerSsIhm.handleViewJdcPy(self)
+
+ def viewJdcSource(self) :
+# ---------------------
+ self.viewManagerSsIhm.handleViewJdcSource(self)
+
+ def getFileName(self):
+# ---------------------
+ self.viewManagerSsIhm.getFileName(self)
+
+
+
+
+
+#--------------------------------
+class MyViewManagerSsIhm(object):
+#--------------------------------
+# Symetrique de ViewManager mais pas d heritage entre les 2
+# dans le viewManager pas de souci pour savoir qui est le jdc sur lequel on travaille
+# ici en revanche.... c est moins sur
+
+# --------------------------------
+ def __init__(self,appliEficas):
+# --------------------------------
+ self.appliEficas=appliEficas
+ self.tabWidgets = []
+ self.mesIndexes = {}
+ self.dictEditors={}
+ self.untitledCount = 0
+ self.doubles = {}
+
+# ------------------------------------------------------
+ def handleOpen(self,fichier=None, units=None):
+# ------------------------------------------------------
+ result = None
+ if fichier is None:
+ print ('nom de fichier obligatoire')
+ return None
+
+ for handler in self.dictEditors :
+ editor=self.dictEditors[handler]
+ if self.samePath(fichier, editor.getFileName()):
+ print ('fichier deja ouvert . pas de nouvel editor')
+ return handler
+
+ monNewHandler = self.getNewEditor(fichier,units)
+ return monNewHandler
+
+# ----------------------------------------------------------------------
+ def getNewEditor(self,fichier = None,jdc = None, units = None,include=0):
+# ----------------------------------------------------------------------
+
+ from InterfaceQT4.editorSsIhm import JDCEditorSsIhm
+ editor = JDCEditorSsIhm(self.appliEficas,fichier,jdc, units=units,include=include)
+
+ if editor.jdc: # le fichier est bien un jdc
+ monHandler = JdcSsIhmHandler(self)
+ self.dictEditors[monHandler]=editor
+ return monHandler
+ else:
+ print ('impossible de construire le jdc')
+ return None
+
+# -----------------------------
+ def samePath(self,f1, f2):
+# ------------------------------
+ """
+ compare two paths.
+ """
+ if f1 is None or f2 is None: return 0
+ if os.path.normcase(os.path.normpath(f1)) == os.path.normcase(os.path.normpath(f2)) : return 1
+ return 0
+
+# ---------------------------------
+ def handleViewJdcPy(self,handler):
+# ---------------------------------
+ if not (handler in self.dictEditors) :
+ print ('editor non trouve')
+ return
+ self.dictEditors[handler].viewJdcPy()
+
+# ---------------------------------
+ def getFileName(self,handler):
+# ---------------------------------
+ if not (handler in self.dictEditors) :
+ print ('editor non trouve')
+ return
+ return self.dictEditors[handler].getFileName()
+
+
+# ---------------------------------------------
+ def handleViewJdcSource(self,handler):
+# ---------------------------------------------
+ print (handler)
+ if not (handler in self.dictEditors) :
+ print ('editor non trouve')
+ return
+ self.dictEditors[handler].viewJdcSource()
+
+
+# def handleClose(self,doitSauverRecent = 1,texte=tr('&Quitter')):
+# if doitSauverRecent : self.appliEficas.sauveRecents()
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# res=self.checkDirty(self.dict_editors[index],texte)
+# if res == 2 : return 2 # l utilisateur a annule
+# index=self.myQtab.currentIndex()
+# idx=index
+# while idx < len(self.dict_editors) -1 :
+# self.dict_editors[idx]=self.dict_editors[idx+1]
+# idx = idx + 1
+# del self.dict_editors[len (self.dict_editors) -1]
+# try :
+# del self.doubles[self.dict_editors[index]]
+# except :
+# pass
+# self.myQtab.removeTab(index)
+# return res
+#
+
+#
+# def handleCloseAll(self,texte=tr('Quitter')):
+# res=0
+# self.appliEficas.sauveRecents()
+# while len(self.dict_editors) > 0 :
+# self.myQtab.setCurrentIndex(0)
+# res=self.handleClose(0,texte)
+# if res==2 : return res # l utilsateur a annule
+# return res
+#
+#
+#
+# def newEditor(self,include=0):
+# if self.appliEficas.demande==True :
+# self.appliEficas.definitCode(None,None)
+# if self.appliEficas.code == None:return
+# maPage=self.getEditor(include=include)
+#
+
+#
+# def handleViewJdcRegles(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# self.dict_editors[index].viewJdcRegles()
+#
+# def handleGestionParam(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 :
+# QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees"))
+# return
+# self.dict_editors[index].gestionParam()
+#
+# def handleViewJdcRapport(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# self.dict_editors[index].viewJdcRapport()
+#
+#
+# def saveCurrentEditor(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# editor=self.dict_editors[index]
+# if editor in self.doubles :
+# QMessageBox.warning(
+# None,
+# tr("Fichier Duplique"),
+# tr("Le fichier ne sera pas sauvegarde."),)
+# return
+# ok, newName = editor.saveFile()
+# if ok :
+# fileName=os.path.basename(six.text_type(newName))
+# self.myQtab.setTabText(index,fileName)
+# return ok
+#
+# def saveLegerCurrentEditor(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# editor=self.dict_editors[index]
+# ok, newName = editor.saveFileLeger()
+# return ok
+#
+# def sauveLigneCurrentEditor(self):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# editor=self.dict_editors[index]
+# if editor in self.doubles :
+# QMessageBox.warning(
+# None,
+# tr("Fichier Duplique"),
+# tr("Le fichier ne sera pas sauvegarde."),)
+# return
+# ok, newName = editor.sauveLigneFile()
+# if ok :
+# fileName=os.path.basename(six.text_type(newName))
+# self.myQtab.setTabText(index,fileName)
+# return ok
+#
+#
+# def saveAsCurrentEditor(self):
+# index=self.myQtab.currentIndex()
+# editor=self.dict_editors[index]
+# oldName=editor.fichier
+# ok,newName = editor.saveFileAs()
+# if ok :
+# fileName=os.path.basename(six.text_type(newName))
+# self.myQtab.setTabText(index,fileName)
+# if editor in self.doubles :
+# if oldName != newName :
+# del self.doubles[editor]
+# return ok
+#
+# def displayJDC(self,jdc,fn=None):
+# """
+# Public slot to display a file in an editor.
+# @param fn name of file to be opened
+# # insert filename into list of recently opened files
+# """
+# titre=None
+# if fn != None : titre=fn.split("/")[-1]
+# editor = self.getEditor(fichier= fn, jdc = jdc ,include=1)
+# self.appliEficas.addToRecentList(editor.getFileName())
+#
+
+##PNPNPNPN --> a affiner
+# if fichier is None:
+# self.untitledCount += 1
+# self.myQtab.addTab(win, tr("Fichier non encore nomme ", self.untitledCount))
+# #self.myQtab.addTab(win, str(self.appliEficas.code))
+# else:
+# liste=fichier.split('/')
+# txt = liste[-1]
+# if not QFileInfo(fichier).isWritable():
+# txt = '%s (ro)' % txt
+# self.myQtab.addTab(win,txt )
+# self.myQtab.setCurrentWidget(win)
+# self.currentEditor=win
+# win.setFocus()
+#
+# def getOpenStartDir(self) :
+# #PN --> Les Preferences
+# try :
+# userDir=os.path.expanduser("~/Eficas_install/")
+# return userDir
+# except :
+# return ""
+#
+#
+# def checkDirty(self, editor,texte):
+# """
+# Private method to check dirty status and open a message window.
+#
+# @param editor editor window to check
+# @return flag indicating successful reset of the dirty flag (boolean)
+# """
+# res=1
+# if (editor.modified) and (editor in self.doubles) :
+# msgBox = QMessageBox(None)
+# msgBox.setWindowTitle(tr("Fichier Duplique"))
+# msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
+# msgBox.addButton(texte,0)
+# msgBox.addButton(tr("&Annuler"),1)
+# res=msgBox.exec_()
+# if res == 0 : return 1
+# return 2
+# if editor.modified:
+# fn = editor.getFileName()
+# if fn is None: fn = tr('Noname')
+# msgBox = QMessageBox(None)
+# msgBox.setWindowTitle(tr("Fichier Modifie"))
+# msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
+# msgBox.addButton(tr("&Sauvegarder"),1)
+# msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
+# msgBox.addButton(tr("&Annuler"),2)
+# res=msgBox.exec_()
+# if res == 2 : return res
+# if res == 0:
+# (ok, newName) = editor.saveFile()
+# if ok:
+# fileName=os.path.basename(six.text_type(newName))
+# index=self.myQtab.currentIndex()
+# self.myQtab.setTabText(index,fileName)
+# return ok
+# return res
+#
+# def handleAjoutGroup(self,listeGroup):
+# index=self.myQtab.currentIndex()
+# if index < 0 : return
+# editor=self.dict_editors[index]
+# editor.handleAjoutGroup(listeGroup)
assert j.isValid(),j.report()
- text1=app.get_text_JDC(j,'python')
+ text1=app.getTextJDC(j,'python')
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
f=open(file)
text2=f.read()
if mc.nom == "MAILLAGE":
valeur,validite=mc.evalValeur("MAIL")
test = mc.set_valeur(valeur)
- text1=app.get_text_JDC(j,'python')
+ text1=app.getTextJDC(j,'python')
f=open(file)
text2=f.read()
f.close()
co=j.etapes[1]
mcs=co.addEntite("INFO")
- cr=app.get_text_JDC(j,'python')
+ cr=app.getTextJDC(j,'python')
expected="""
DEBUT();
test,mess=co.nommeSd("MA2")
assert test == 1
- cr=app.get_text_JDC(j,'python')
+ cr=app.getTextJDC(j,'python')
expected="""
DEBUT();
assert j.isValid(),j.report()
- text1=app.get_text_JDC(j,'python')
+ text1=app.getTextJDC(j,'python')
file=os.path.join(prefs.INSTALLDIR,"Tests/testelem/az.comm")
f=open(file)
text2=f.read()
if co.nom in ("AFFE_MODELE","AFFE_MATERIAU") :
add_mcsimp(co,"MAILLAGE",'MAIL')
- text1=app.get_text_JDC(j,'python')
+ text1=app.getTextJDC(j,'python')
f=open(file)
text2=f.read()
f.close()
j=app.openJDC(file=file)
assert j.isValid(),j.report()
- text1=app.get_text_JDC(j,'python')
+ text1=app.getTextJDC(j,'python')
f=open(file)
text2=f.read()
f.close()
<rect>
<x>0</x>
<y>0</y>
- <width>739</width>
- <height>63</height>
+ <width>803</width>
+ <height>41</height>
</rect>
</property>
<property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+ <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
<item>
<widget class="MonLabelClic" name="label">
<property name="sizePolicy">
- <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
<rect>
<x>0</x>
<y>0</y>
- <width>949</width>
- <height>53</height>
+ <width>978</width>
+ <height>60</height>
</rect>
</property>
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
<property name="focusPolicy">
<enum>Qt::StrongFocus</enum>
</property>
<property name="topMargin">
<number>2</number>
</property>
+ <item>
+ <spacer name="verticalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>2</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
</layout>
</item>
</layout>
