elif self.object.isValid():
return "ast-green-square"
else:
- valid=self.valid_child()
- valid=valid * self.valid_regles("non")
+ valid=self.validChild()
+ valid=valid * self.validRegles("non")
if self.reste_val != {}:
valid=0
if valid==0 :
from InterfaceQT4 import readercataXML as readercata
else :
from InterfaceQT4 import readercata
- self.readercata = readercata.READERCATA( self, self.appliEficas )
+ self.readercata = readercata.ReaderCata( self, self.appliEficas )
self.appliEficas.readercata=self.readercata
self.readercata.dumpToXml()
self.appliEficas.code=self.code
from . import readercata
if not hasattr ( Eficas, 'readercata'):
- monreadercata = readercata.READERCATA( parent, Eficas )
+ monreadercata = readercata.ReaderCata( parent, Eficas )
Eficas.readercata=monreadercata
from .editor import JDCEditor
from . import readercata
if not hasattr ( Eficas, 'readercata'):
- monreadercata = readercata.READERCATA( parent, Eficas )
+ monreadercata = readercata.ReaderCata( parent, Eficas )
Eficas.readercata=monreadercata
from .editor import JDCEditor
if firstNode==None : firstNode=nouveau
if nouveau == None or nouveau == 0 :
self.editor.afficheInfos(tr('insertion impossible a cet endroit pour '+nom),Qt.red)
- self.reaffiche(firstNode)
- if firstNode!=None and firstNode !=0 and firstNode.item!=None :
- firstNode.select()
+ try :
+ self.reaffiche(firstNode)
+ if firstNode!=None and firstNode !=0 and firstNode.item!=None : firstNode.select()
+ except :
+ pass
def setPlie(self):
# Import des panels
-class monRBButtonCustom(QCheckBox):
+class MonRBButtonCustom(QCheckBox):
def __init__(self,texte,monOptionnel,parent=None,couleur=None):
QCheckBox.__init__(self,tr(texte),parent)
monAide = ""
self.monOptionnel.parentMC.editor.afficheCommentaire(monAide)
-class monPBButtonCustom(QWidget,Ui_customPB):
+class MonPBButtonCustom(QWidget,Ui_customPB):
def __init__(self,texte,monOptionnel,parent=None,couleur=None):
QWidget.__init__(self)
couleur=None
if mot in liste_rouge : couleur=Qt.red
if self.parentQt.parentQt.maConfiguration.simpleClic == False :
- cb = monRBButtonCustom(mot,self,couleur=couleur)
+ cb = MonRBButtonCustom(mot,self,couleur=couleur)
cb.clicked.connect(cb.ajoutAideMC)
else :
- cb = monPBButtonCustom(mot,self,couleur=couleur)
+ cb = MonPBButtonCustom(mot,self,couleur=couleur)
self.MCOptionnelLayout.insertWidget(0,cb)
self.dicoCb[cb]=mot
from PyQt5.QtWidgets import QMessageBox, QApplication, QDialog
+#-------------------------------
+class ReaderCataCommun(object):
+#-------------------------------
-
-class READERCATA(object):
-
- def __init__(self,QWParent, appliEficas):
- self.QWParent=QWParent
- self.appliEficas=self.QWParent.appliEficas
- self.VERSION_EFICAS=self.appliEficas.VERSION_EFICAS
- self.demandeCatalogue=False
- self.code=self.appliEficas.code
- self.ssCode=self.appliEficas.ssCode
- self.appliEficas.format_fichier='python'
- self.versionCode=self.appliEficas.versionCode
- self.fic_cata=None
- self.openCata()
- self.traiteIcones()
- self.cataitem=None
- self.creeDicoInverse()
- if self.code=="TELEMAC": self.creeDicoCasToCata()
-
-
- def openCata(self):
- """
- Ouvre le catalogue standard du code courant, cad le catalogue present
- dans le repertoire Cata
+ def askChoixCatalogue(self, cata_choice_list):
+ # ____________________________________________
"""
+ Ouvre une fenetre de selection du catalogue dans le cas où plusieurs
+ ont ete definis dans Accas/editeur.ini
+ """
+ code = getattr(self.appliEficas.maConfiguration, "code", None)
+ if code != None :
+ title=tr("Choix d une version du code ")+str(code)
+ else :
+ title=tr("Choix d une version ")
+
+ widgetChoix = MonChoixCata(self.appliEficas, [cata.user_name for cata in cata_choice_list], title)
+ ret=widgetChoix.exec_()
+
+
+ lab=str(self.VERSION_EFICAS)+" "
+ lab+=tr(" pour ")
+ lab+=str(self.code)
+ lab+=tr(" avec le catalogue ")
+ if ret == QDialog.Accepted:
+ cata = cata_choice_list[widgetChoix.CBChoixCata.currentIndex()]
+ self.fic_cata = cata.cata_file_path
+ self.versionCode = cata.identifier
+ self.appliEficas.format_fichier = cata.file_format
+ self.appliEficas.format_fichier_in = cata.file_format_in
+ lab+=self.versionCode
+ self.appliEficas.setWindowTitle(lab)
+ #qApp.mainWidget().setCaption(lab)
+ widgetChoix.close()
+ else:
+ widgetChoix.close()
+ raise EficasException()
+
+ def choisitCata(self):
+ # ____________________
liste_cata_possibles=[]
self.Commandes_Ordre_Catalogue=[]
all_cata_list = []
for catalogue in self.appliEficas.maConfiguration.catalogues:
- if isinstance(catalogue, CatalogDescription):
- all_cata_list.append(catalogue)
- elif isinstance(catalogue, tuple):
- all_cata_list.append(CatalogDescription.create_from_tuple(catalogue))
- else:
- print(("Catalog description cannot be interpreted: ", catalogue))
+ if isinstance(catalogue, CatalogDescription): all_cata_list.append(catalogue)
+ elif isinstance(catalogue, tuple) : all_cata_list.append(CatalogDescription.create_from_tuple(catalogue))
+ else: print(("Catalog description cannot be interpreted: ", catalogue))
# This filter is only useful for codes that have subcodes (like MAP).
# Otherwise, the "code" attribute of the catalog description can (should) be None.
- if self.ssCode is None:
- liste_cata_possibles = all_cata_list
+ if self.ssCode is None: liste_cata_possibles = all_cata_list
else:
for catalogue in all_cata_list:
- if catalogue.code == self.code and catalogue.file_format == self.ssCode:
- liste_cata_possibles.append(catalogue)
+ if catalogue.code == self.code and catalogue.file_format == self.ssCode: liste_cata_possibles.append(catalogue)
if len(liste_cata_possibles)==0:
QMessageBox.critical(self.QWParent, tr("Import du catalogue"),
tr("Pas de catalogue defini pour le code ") + self.code)
self.appliEficas.close()
- if self.appliEficas.salome == 0 :
- sys.exit(1)
+ if self.appliEficas.salome == 0 : sys.exit(1)
return
cata_choice_list = []
for cata in liste_cata_possibles:
if cata.selectable:
- if cata.default:
- cata_choice_list.insert(0, cata)
- else :
- cata_choice_list.append(cata)
+ if cata.default : cata_choice_list.insert(0, cata)
+ else : cata_choice_list.append(cata)
+
if len(cata_choice_list) == 0:
QMessageBox.critical(self.QWParent, tr("Import du catalogue"),
tr("Aucun catalogue trouve"))
self.appliEficas.close()
- if self.appliEficas.salome == 0 :
- sys.exit(1)
+ if self.appliEficas.salome == 0 : sys.exit(1)
+
elif len(cata_choice_list) == 1:
self.fic_cata = cata_choice_list[0].cata_file_path
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:
# plusieurs catalogues sont disponibles : il faut demander a l'utilisateur
# lequel il veut utiliser ...
return
+#------------------------------------
+class ReaderCata (ReaderCataCommun):
+#------------------------------------
+
+ def __init__(self,QWParent, appliEficas):
+ # ______________________________________
+
+ self.QWParent=QWParent
+ self.appliEficas=self.QWParent.appliEficas
+ self.VERSION_EFICAS=self.appliEficas.VERSION_EFICAS
+ self.demandeCatalogue=False
+ self.code=self.appliEficas.code
+ self.ssCode=self.appliEficas.ssCode
+ self.appliEficas.format_fichier='python'
+ self.versionCode=self.appliEficas.versionCode
+ self.fic_cata=None
+ self.openCata()
+ self.traiteIcones()
+ self.cataitem=None
+ self.creeDicoInverse()
+ if self.code=="TELEMAC": self.creeDicoCasToCata()
+
+
+
+ def openCata(self):
+ """
+ Ouvre le catalogue standard du code courant, cad le catalogue present
+ dans le repertoire Cata
+ """
# import du catalogue
+ self.choisitCata()
self.cata = self.importCata(self.fic_cata)
if not self.cata :
QMessageBox.critical( self.QWParent, tr("Import du catalogue"),tr("Impossible d'importer le catalogue ")+ self.fic_cata)
rep_cata = os.path.dirname(self.fic_cata)
self.Commandes_Ordre_Catalogue = analyse_catalogue_initial.analyseCatalogue(self.fic_cata)
#print self.Commandes_Ordre_Catalogue
-
- def askChoixCatalogue(self, cata_choice_list):
- """
- Ouvre une fenetre de selection du catalogue dans le cas où plusieurs
- ont ete definis dans Accas/editeur.ini
- """
- code = getattr(self.appliEficas.maConfiguration, "code", None)
- if code != None :
- title=tr("Choix d une version du code ")+str(code)
- else :
- title=tr("Choix d une version ")
-
- widgetChoix = MonChoixCata(self.appliEficas, [cata.user_name for cata in cata_choice_list], title)
- ret=widgetChoix.exec_()
-
-
- lab=str(self.VERSION_EFICAS)+" "
- lab+=tr(" pour ")
- lab+=str(self.code)
- lab+=tr(" avec le catalogue ")
- if ret == QDialog.Accepted:
- cata = cata_choice_list[widgetChoix.CBChoixCata.currentIndex()]
- self.fic_cata = cata.cata_file_path
- self.versionCode = cata.identifier
- self.appliEficas.format_fichier = cata.file_format
- self.appliEficas.format_fichier_in = cata.file_format_in
- lab+=self.versionCode
- self.appliEficas.setWindowTitle(lab)
- #qApp.mainWidget().setCaption(lab)
- widgetChoix.close()
- else:
- widgetChoix.close()
- raise EficasException()
def traiteIcones(self):
if self.appliEficas.maConfiguration.ficIcones==None : return
import uiinfo
from Efi2Xsd import readerEfficas
-class READERCATA:
+from readercata import ReaderCataCommun
+
+class ReaderCata (ReaderCataCommun):
def __init__(self,QWParent, appliEficas):
self.QWParent=QWParent
#self.fic_cata = 'Cata_MED_FAM.xml'
#xml = open('/home/A96028/QT5GitEficasTravail/eficas/Med/Cata_MED_FAM.xml').read()
- self.fic_cata = 'cata_test1.xml'
- xml = open('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_test1.xml').read()
+ #xml = open('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_test1.xml').read()
+ self.choisitCata()
+ xml=open(self.fic_cata).read()
SchemaMed = readerEfficas.efficas.CreateFromDocument(xml)
SchemaMed.exploreCata()
- #self.cata=(SchemaMed,)
self.cata=SchemaMed
- #uiinfo.traite_UIinfo(self.cata[0])
uiinfo.traite_UIinfo(self.cata)
self.Commandes_Ordre_Catalogue=[]
- #self.cata_ordonne_dico,self.appliEficas.liste_simp_reel=autre_analyse_cata.analyseCatalogue(self.cata[0])
self.cata_ordonne_dico,self.appliEficas.liste_simp_reel=autre_analyse_cata.analyseCatalogue(self.cata)
self.liste_groupes=None
('TELEMAC','pn',os.path.join(repIni,'telemac2d_V6_cata.py'),'TELEMAC','TELEMAC'),
#('2222D','cas',os.path.join(repIni,'telemac2d_V6_cata.py'),'TELEMAC','TELEMAC'),
#('TELEMAC','cas',os.path.join(repIni,'Telemac_Cata.py'),'python','TELEMAC3'),
- #('YOHAN','cas',os.path.join(repIni,'Cata.py'),'TELEMAC','TELEMAC'),
+ ('YOANN','cas',os.path.join(repIni,'Cata.py'),'TELEMAC','TELEMAC'),
#('TELEMAC','comm',os.path.join(repIni,'Telemac_Cata.py'),'TELEMAC2','python'),
)
mode_nouv_commande="figee"
affiche = "ordre"
-translatorFichier = os.path.join(repIni,'labelCataToIhm')
+translatorFichier_pn = os.path.join(repIni,'labelCataToIhm')
+#translatorFichier_cas = os.path.join(repIni,'labelCataToIhm')
+#translatorFichier = os.path.join(repIni,'labelCataToIhm')
closeFrameRecherche=True
differencieSiDefaut = True
'TIDES',
'COUPLING',
'INTERNAL')
+
+enum = 'Telemac.enum_Telemac2d_auto'
"""
"""
- def valid_child(self):
+ def validChild(self):
""" Cette methode teste la validite des mots cles de l'etape """
for child in self.mc_liste:
if not child.isValid():
return 0
return 1
- def valid_regles(self, cr):
+ def validRegles(self, cr):
""" Cette methode teste la validite des regles de l'etape """
text_erreurs, test_regles = self.verifRegles()
if not test_regles:
return 0
return 1
- def valid_sdnom(self, cr):
+ def validSdnom(self, cr):
""" Cette methode teste la validite du nom du concept produit par l'etape """
valid = 1
if self.sd.nom != None:
if self.state == 'unchanged':
return self.valid
else:
- valid = self.valid_child()
- valid = valid * self.valid_regles(cr)
+ valid = self.validChild()
+ valid = valid * self.validRegles(cr)
if self.reste_val != {}:
if cr == 'oui':
self.cr.fatal(("Concept is not defined"))
valid = 0
else:
- valid = valid * self.valid_sdnom(cr)
+ valid = valid * self.validSdnom(cr)
if valid:
valid = self.updateSdprod(cr)
self.cr.fatal("Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s" % c.nom)
valid = 0
- valid = valid * self.valid_child()
- valid = valid * self.valid_regles(cr)
+ valid = valid * self.validChild()
+ valid = valid * self.validRegles(cr)
if self.reste_val != {}:
if cr == 'oui':
return valid
if self.sd != None:
- valid = valid * self.valid_sdnom(cr)
+ valid = valid * self.validSdnom(cr)
if self.definition.reentrant == 'n' and self.reuse:
# Il ne peut y avoir de concept reutilise avec une MACRO non
if self.state == 'unchanged':
return self.valid
else:
- valid = self.valid_child()
- valid = valid * self.valid_regles(cr)
+ valid = self.validChild()
+ valid = valid * self.validRegles(cr)
if self.reste_val != {}:
if cr == 'oui':
self.cr.fatal(
import re
from Extensions.i18n import tr
+#import traceback
+#traceback.print_stack()
-from .convert_python import Pythonparser
-import six
+from convert.convert_python import Pythonparser
from six.moves import range
try:
basestring
#Si le code n est pas Telemac
-try :
- from enum_Telemac2d_auto import TelemacdicoEn
-except :
- pass
+#try :
+# from enum_Telemac2d_auto import self.TelemacdicoEn
+#except :
+# pass
from Extensions import localisation
a file with a different or inexistent definition of variables.
"""
+
+
def convert(self, outformat, appli=None):
from Accas import A_BLOC, A_FACT, A_SIMP
- self.dicoCasToCata=appli.readercata.dicoCasToCata
- self.dicoInverse=appli.readercata.dicoInverse
- self.dicoMC=appli.readercata.dicoMC
- self.Ordre_Des_Commandes=appli.readercata.Ordre_Des_Commandes
+ self.dicoCasToCata = appli.readercata.dicoCasToCata
+ self.dicoInverse = appli.readercata.dicoInverse
+ self.dicoMC = appli.readercata.dicoMC
+ self.Ordre_Des_Commandes = appli.readercata.Ordre_Des_Commandes
+ self.TelemacdicoEn = appli.readercata.TelemacdicoEn
+ self.DicoEnumCasFrToEnumCasEn = appli.readercata.DicoEnumCasFrToEnumCasEn
+
if appli.langue=='fr' :
- from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
- for k in DicoEnumCasFrToEnumCasEn :
- TelemacdicoEn[k]=DicoEnumCasFrToEnumCasEn[k]
+ #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
+ for k in self.DicoEnumCasFrToEnumCasEn :
+ self.TelemacdicoEn[k]=self.DicoEnumCasFrToEnumCasEn[k]
text=""
self.dictSimp={}
try : valeur=eval(valeur,{})
except : pass
- if nom in TelemacdicoEn:
+ if nom in self.TelemacdicoEn:
try :
- valeur=TelemacdicoEn[nom][valeur]
+ valeur=self.TelemacdicoEn[nom][valeur]
self.textePy += nom + "= '" + str(valeur) +"',"
return
except : pass
# Attention : on attend une liste mais on a une seule valeur!
try : oldValeur=eval(oldValeur,{})
except : pass
- if nom in TelemacdicoEn :
- v=TelemacdicoEn[nom][oldValeur]
+ if nom in self.TelemacdicoEn :
+ v=self.TelemacdicoEn[nom][oldValeur]
self.textePy += nom + "= ('" + str(v) +"',),"
else :
self.textePy += nom + "= (" + str(oldValeur) +",),"
for v in valeur :
try : v=eval(v,{})
except : pass
- if nom in TelemacdicoEn:
- try : v=TelemacdicoEn[nom][v]
+ if nom in self.TelemacdicoEn:
+ try : v=self.TelemacdicoEn[nom][v]
except : pass
newVal.append(v)
self.textePy += nom + "=" + str(newVal) +","
#----------------------------------------------------------------------------------------
def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"):
- self.statut=statut
- self.langue=appli.langue
- self.DicoEnumCasEnInverse={}
- from enum_Telemac2d_auto import TelemacdicoEn
- for motClef in TelemacdicoEn:
+ self.statut = statut
+ self.langue = appli.langue
+ self.TelemacdicoEn = appli.readercata.TelemacdicoEn
+ self.DicoEnumCasEnInverse = {}
+ #from enum_Telemac2d_auto import self.TelemacdicoEn
+ for motClef in self.TelemacdicoEn:
d={}
- for valTelemac in TelemacdicoEn[motClef]:
- valEficas= TelemacdicoEn[motClef][valTelemac]
- d[valEficas]=valTelemac
+ for valTelemac in self.TelemacdicoEn[motClef]:
+ valEficas = self.TelemacdicoEn[motClef][valTelemac]
+ d[valEficas] =valTelemac
self.DicoEnumCasEnInverse[motClef]=d
if self.langue == 'fr' :
- from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
- for motClef in DicoEnumCasFrToEnumCasEn:
+ #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn
+ self.DicoEnumCasFrToEnumCasEn = appli.readercata.DicoEnumCasFrToEnumCasEn
+ for motClef in self.DicoEnumCasFrToEnumCasEn:
d={}
- for valTelemac in DicoEnumCasFrToEnumCasEn[motClef]:
- valEficas= DicoEnumCasFrToEnumCasEn[motClef][valTelemac]
- d[valEficas]=valTelemac
+ for valTelemac in self.DicoEnumCasFrToEnumCasEn[motClef]:
+ valEficas = self.DicoEnumCasFrToEnumCasEn[motClef][valTelemac]
+ d[valEficas] = valTelemac
self.DicoEnumCasEnInverse[motClef]=d
self.initDico()
# Pour Simplifier les verifs d ecriture
