class ETAPE(I_ETAPE.ETAPE,V_ETAPE.ETAPE,X_MCCOMPO,N_ETAPE.ETAPE):
def __init__(self,oper=None,reuse=None,args={}):
- #print ('ETAPE accas', oper.nom)
+ print ('------------- ETAPE accas', oper.nom, args)
N_ETAPE.ETAPE.__init__(self,oper,reuse,args)
V_ETAPE.ETAPE.__init__(self)
from Noyau import N_MCBLOC
from Validation import V_MCBLOC
from Ihm import I_MCBLOC
-from Efi2Xsd.MCAccasXsd import X_MCCOMPO
+from Efi2Xsd.MCAccasXsd import X_MCBLOC
-class MCBLOC(I_MCBLOC.MCBLOC,N_MCBLOC.MCBLOC,X_MCCOMPO,V_MCBLOC.MCBLOC):
- def __init__(self,val,definition,nom,parent):
- N_MCBLOC.MCBLOC.__init__(self,val,definition,nom,parent)
+class MCBLOC(I_MCBLOC.MCBLOC,N_MCBLOC.MCBLOC,X_MCBLOC,V_MCBLOC.MCBLOC):
+ def __init__(self,val,definition,nom,parent,dicoPyxbDeConstruction=None):
+ N_MCBLOC.MCBLOC.__init__(self,val,definition,nom,parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
V_MCBLOC.MCBLOC.__init__(self)
from Efi2Xsd.MCAccasXsd import X_MCFACT
class MCFACT(I_MCFACT.MCFACT,N_MCFACT.MCFACT,X_MCFACT,V_MCFACT.MCFACT):
- def __init__(self,val,definition,nom,parent):
- N_MCFACT.MCFACT.__init__(self,val,definition,nom,parent)
+ def __init__(self,val,definition,nom,parent,dicoPyxbDeConstruction=None):
+ N_MCFACT.MCFACT.__init__(self,val,definition,nom,parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
V_MCFACT.MCFACT.__init__(self)
from Efi2Xsd.MCAccasXsd import X_MCSIMP
class MCSIMP(I_MCSIMP.MCSIMP,N_MCSIMP.MCSIMP,X_MCSIMP,V_MCSIMP.MCSIMP):
- def __init__(self,val,definition,nom,parent):
- N_MCSIMP.MCSIMP.__init__(self,val,definition,nom,parent)
+ def __init__(self,val,definition,nom,parent,objPyxbDeConstruction=None):
+ #def __init__(self,val,definition,nom,parent,objPyxbDeConstruction) quand cela sera correct dans les update_etape. pour l instant on laisse le defaut a None : 9 Aout 18:
+ N_MCSIMP.MCSIMP.__init__(self,val,definition,nom,parent,objPyxbDeConstruction)
V_MCSIMP.MCSIMP.__init__(self)
from mapDesTypes import dictPourCast, dictNomsDesTypes
from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dictPourCast
from mapDesTypes import listeParamTjsSequence, listeParamSelonType
+from mapDesTypes import Tuple
from balises import *
# il faut traduire le min et le max
# il faut ajouter les regles
# il faut gerer les types tuple et fichier
+
+ if hasattr(self.type[0], 'label') and self.type[0].label == "Tuple" : return ('XXXXXXXX')
return dictNomsDesTypes[self.type[0]]
def traduitValMinValMax(self):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys,os
+import traceback
#import raw.efficas as efficas
import types
# self.valeur tient compte de la valeur par defaut
# utiliser getValeur ? expression numpy
if not self.cata.modeleMetier : return
- if CONTEXT.fromXML : return
#print ('X_MCSIMP buildObjPyxb', self.nom, self,self.valeur)
- self.monNomClasseModeleMetier='T_'+self.nom
- self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomClasseModeleMetier)
- #print (self.maClasseModeleMetier)
- print (self.valeur)
- print (type(self.valeur))
- if self.valeur != None : self.objPyxb=self.maClasseModeleMetier(self.valeur)
- elif self.definition.into != None and 'TXM' in self.definition.type : self.objPyxb = None
- else : self.objPyxb=self.maClasseModeleMetier()
+ #if self.nom == 'diameter' :
+ # traceback.print_stack()
+ # print ('****************************************************')
+ # print ('objPyxbDeConstruction', self.objPyxbDeConstruction)
+ #if self.objPyxbDeConstruction == None : print (self.nom, ' pas de pyxb')
+ if self.objPyxbDeConstruction != None :
+ self.objPyxb = self.objPyxbDeConstruction
+ self.objPyxbDeConstruction = None
+ else :
+ self.monNomClasseModeleMetier='T_'+self.nom
+ self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomClasseModeleMetier)
+ #print (self.maClasseModeleMetier)
+ #print (self.valeur)
+ #print (type(self.valeur))
+ if self.valeur != None : self.objPyxb=self.maClasseModeleMetier(self.valeur)
+ elif self.definition.into != None and 'TXM' in self.definition.type : self.objPyxb = None
+ else : self.objPyxb=self.maClasseModeleMetier();
self.filsPyxb=None
+ #print ('X_MCSIMP', self.nom, self.objPyxb)
#print ('fin X_MCSIMP', self.objPyxb, self.nom,self)
def setValeurObjPyxb(self,newVal):
- print ('dans setValeurObjPyxb')
+ #print ('dans setValeurObjPyxb')
if not self.cata.modeleMetier : return
try :
print (self.nom , ' a pour pere', self.perePyxb, self.perePyxb.nom)
else : nvlObj=self.maClasseModeleMetier()
self.val=newVal
indexOC=0
- print ('avant',self.nom, self.perePyxb.objPyxb.orderedContent())
+ #print ('avant',self.nom, self.perePyxb.objPyxb.orderedContent())
for i in self.perePyxb.objPyxb.orderedContent():
if id(i._Content__value) == id(self.objPyxb) : break
indexOC +=1
#print (monBinding)
def deletePyxbObject(self):
- print ('je passe par la', self, self.nom)
+ print ('je passe ds deletePyxbObject pour ', self, self.nom)
class X_MCCOMPO:
#
def buildObjPyxb(self,mc_list) :
if not self.cata.modeleMetier : return
- if CONTEXT.fromXML : return
- print ('_______________________________________')
- print ('X_MCCOMPO buildObjPyxb', self.nom, self, mc_list)
- self.monNomClasseModeleMetier='T_'+self.nom
- self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomClasseModeleMetier)
- listArg=[]
+ #print ('________________________________________________')
+ #print ('X_MCCOMPO buildObjPyxb', self.nom, self, mc_list)
+
+ self.listArg=[]
for objAccas in mc_list :
- # on remonte les mots-clefs des blocs
- #print (type (objAccas))
if objAccas.nature == 'MCBLOC' :
- # Attention --> mc_list et mc_liste
- for fils in objAccas.mc_liste:
- fils.perePyxb=self
- listArg.append(fils.objPyxb)
- print (fils.nom ,' a pour pere Pyxb', self, self.nom)
+ self.exploreBLOC(objAccas)
elif objAccas.nature == 'MCList' :
for fils in objAccas :
fils.perePyxb=self
- listArg.append(fils.objPyxb)
+ self.listArg.append(fils.objPyxb)
else :
- listArg.append(objAccas.objPyxb)
+ self.listArg.append(objAccas.objPyxb)
objAccas.perePyxb=self
#print (objAccas.nom ,' a pour pere Pyxb', self, self.nom)
- #print ( objAccas.nom, ' a pour perepyxb ' , objAccas.perePyxb.nom)
- self.objPyxb=self.maClasseModeleMetier(*listArg)
- print ('Fin ', self.nom, self.objPyxb)
- print ('_______________________________________')
+
+ self.monNomClasseModeleMetier='T_'+self.nom
+ self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomClasseModeleMetier)
+ if self.objPyxbDeConstruction != None :
+ self.objPyxb = self.objPyxbDeConstruction
+ self.objPyxbDeConstruction = None
+ #print ('je passe dans le if pour ', self.nom, self.objPyxb, self)
+ else :
+ self.objPyxb=self.maClasseModeleMetier(*self.listArg)
+ #print ('Fin __________ ', self.nom, self.objPyxb)
+ #print ('X_MCCOMPO', self.nom, self.objPyxb)
+ #print ('_______________________________________')
def deletePyxbObject(self):
print ('******************************************')
- print ('je passe par la', self, self.nom)
+ print ('je passe ds deletePyxbObject pour ', self, self.nom)
print (self.perePyxb)
print (dir(self))
print ('******************************************')
-
+ def exploreBLOC(self,objAccas):
+ laListeSsLesBlocs=[]
+ for fils in objAccas.mc_liste:
+ if fils.nature == 'MCBLOC' :
+ self.exploreBLOC(fils)
+ elif fils.nature == 'MCList' :
+ for objFils in fils :
+ fils.perePyxb=self
+ self.listArg.append(fils.objPyxb)
+ #print (fils.nom ,' a pour pere Pyxb', self, self.nom)
+ else :
+ self.listArg.append(fils.objPyxb)
+ fils.perePyxb=self
+ #print (fils.nom ,' a pour pere Pyxb', self, self.nom)
+
class X_MCBLOC (X_MCCOMPO):
# --------------------------
def buildObjPyxb(self,mc_list):
- if CONTEXT.fromXML : return
if not self.cata.modeleMetier : return
# mise a none ? le bloc n a pas d existence en pyxb
self.perePyxb=None
- print ('_______________________________________')
- print ('X_MCBLOC buildObjPyxb', self.nom, self, mc_list)
+ #print ('_______________________________________')
+ #print ('X_MCBLOC buildObjPyxb', self.nom, self, mc_list)
# on rattache ses fils au bloc mais leur pere sera ensuite le MCCOMPO qui contient le bloc
# Pas sur d en avoir besoin
self.filsPyxb=[]
self.objPyxb=None
for objAccas in mc_list :
self.filsPyxb.append(objAccas.objPyxb)
- print (self.filsPyxb)
- print ('Fin ', self.nom, self.objPyxb)
- print ('_______________________________________')
+ #print (self.filsPyxb)
+ #print ('Fin ', self.nom, self.objPyxb)
+ #print ('_______________________________________')
# --------------------------
def buildObjPyxb(self,mc_list):
- print ('_______________________________________')
- print ('X_MCLIST buildObjPyxb traite ds X_MCLIST', self.nom, self)
- print ('on ne fait rien')
- print ('_______________________________________')
+ #print ('__________________________________________________________________')
+ #print ('X_MCLIST buildObjPyxb traite ds X_MCLIST', self.nom, self)
+ #print ('on ne fait rien pour les MCLISTs, cela sera fait dans chaque MCFACT')
+ #print ('__________________________________________________________________')
pass
+ # detruire la methode suivante
#def build2ObjPyxb(self,mc_list):
- # if CONTEXT.fromXML : return
# print ('_______________________________________')
# print ('X_MCLIST buildObjPyxb traite ds X_MCLIST', self.nom, self)
# if not self.cata.modeleMetier : return
#print (type (objAccas))
#print (objAccas.nom, objAccas.objPyxb, type(objAccas.objPyxb))
#print ( type (objAccas.objPyxb) == list )
- if type (objAccas.objPyxb) == list :
+ #if type (objAccas.objPyxb) == list :
#print ('ds le if')
# for fils in objAccas.objPyxb :
# listArg.append(fils.objPyxb)
class X_MCFACT (X_MCCOMPO):
# -------------------------
-# on gere au niveau du MCLIST
+# on gere au niveau du MCCOMPO
pass
- #def build2ObjPyxb(self,mc_list):
- # print ('_______________________________________')
- # print ('X_MCFACT buildObjPyxb debut et fin', self.nom, self)
- # print ('_______________________________________')
-
class X_JDC (X_MCCOMPO):
# ---------------------
pyxb.GlobalValidationConfig._setContentInfluencesGeneration(pyxb.GlobalValidationConfig.ALWAYS)
pyxb.GlobalValidationConfig._setInvalidElementInContent(pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
pyxb.GlobalValidationConfig._setOrphanElementInContent(pyxb.GlobalValidationConfig.RAISE_EXCEPTION)
-
+ #print ('fin buildObjPyxb _______________________________________')
def enregistreEtapePyxb(self,etape):
# OK seulement si sequence (choice ? ...)
- print ('ds enregistreEtapePyxb', etape.nom)
if not self.cata.modeleMetier : return
- #if self.source== "xml" : return
+ print ('enregistreEtapePyxb' , etape)
self.objPyxb.append(etape.objPyxb)
etape.perePyxb = self
#self.toXml()
def toXml(self):
- #if not self.cata.modeleMetier : return
+ if not self.cata.modeleMetier : return
+ print ('***************',self.objPyxb,'***************',)
+ print ('***************',self.objPyxb.orderedContent(),'***************',)
print(self.objPyxb.toDOM().toprettyxml())
print(self.objPyxb.toxml())
+ return (self.objPyxb.toDOM().toprettyxml())
def analyseFromXML(self):
- print ("je suis la")
+ print ("je suis ds analyseFromXML -- > appel ds analyse de I_JDC.py")
if self.procedure == "" : return
- self.source='xml'
self.objPyxb=self.cata.modeleMetier.CreateFromDocument(self.procedure)
for objEtape in self.objPyxb.content():
- print ('analyse de ', objEtape)
objEtape.dictArgs= (self.pyxbToDict(objEtape))
objEtape.monNomClasseAccas=objEtape._ExpandedName.localName()
- print (objEtape.monNomClasseAccas, type(objEtape.monNomClasseAccas))
- print (objEtape._ExpandedName, type(objEtape._ExpandedName))
objEtape.monNomClasseAccas=objEtape.monNomClasseAccas[2:]
- #print (objEtape)
- #print (objEtape.monNomClasseAccas)
+ objEtape.dictPyxb['objEnPyxb']=objEtape
+ objEtape.dictArgs['dicoPyxbDeConstruction']=objEtape.dictPyxb
maClasseAccas=getattr(self.cata,objEtape.monNomClasseAccas)
+ objAccasEtape=maClasseAccas(**(objEtape.dictArgs))
+ # attention objAccasEtape = None normal (cf buildSd)
- print ( '________________')
+ print ( 'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh')
print (objEtape , type(objEtape))
- #print (dir(objEtape))
- print (objEtape.dictArgs)
- print ( '________________')
- objAccasEtape=maClasseAccas(**(objEtape.dictArgs))
- self.source='None'
+ print (objEtape.dictPyxb)
+ print (maClasseAccas)
+ print (objAccasEtape)
+
+ #print (objEtape.monNomClasseAccas, type(objEtape.monNomClasseAccas))
+ #print (objEtape._ExpandedName, type(objEtape._ExpandedName))
+ #print (objEtape.dictPyxb[u'experience'])
+ #print (objEtape.dictArgs)
+ #print (objEtape.dictPyxb)
+ print ( 'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh')
+ #exit()
+
def pyxbToDict(self,objAAnalyser):
- # la transformation de l objAAnalyser ne fonctionne pas pour tout
+ # la transformation de l objAAnalyser en type lu par eficas ne fonctionne pas pour tout
# faudrait - il travailler sur les types des objets ?
# c est a revoir -> fonction cast a prevoir ds les 2 sens
if objAAnalyser is None: return
+ #print ('debut pour ',objAAnalyser)
dictArgs = {}
if isinstance(objAAnalyser, pyxb.binding.basis.simpleTypeDefinition):
- if isinstance(objAAnalyser, pyxb.binding.basis.enumeration_mixin): return str(objAAnalyser)
- if isinstance(objAAnalyser, types.StringTypes): return str(objAAnalyser,)
- if isinstance(objAAnalyser, types.FloatType): return float(objAAnalyser,)
- if isinstance(objAAnalyser, (types.IntType, types.LongType)): return int(objAAnalyser,)
- if isinstance(objAAnalyser, (types.NoneType, types.BooleanType, types.FloatType, types.IntType, types.LongType)):
- return repr(objAAnalyser)
+ objAAnalyser.dictPyxb=objAAnalyser
+ #print (objAAnalyser.dictPyxb , type(objAAnalyser.dictPyxb))
+ if isinstance(objAAnalyser, pyxb.binding.basis.enumeration_mixin): return str(objAAnalyser)
+ if isinstance(objAAnalyser, types.StringTypes): return str(objAAnalyser)
+ if isinstance(objAAnalyser, types.FloatType): return float(objAAnalyser)
+ if isinstance(objAAnalyser, (types.IntType, types.LongType)): return int(objAAnalyser)
+ #if isinstance(objAAnalyser, (types.NoneType, types.BooleanType, types.FloatType, types.IntType, types.LongType)):
+ return repr(objAAnalyser)
+ # ou ? return objAAnalyser
#if isinstance(objAAnalyser, types.StringTypes): return pyxb.utils.utility.QuotedEscaped(objAAnalyser,)
#pour une enum getattr(value dans le type)
# return pythonLiteral(ReferenceFacet(facet=value, **kw))
- return objAAnalyser
+ objAAnalyser.dictPyxb = {}
for expandedName, elementDeclaration in objAAnalyser._ElementMap.items():
objPyxbName = expandedName.localName()
objPyxbValue = getattr(objAAnalyser, objPyxbName)
if objPyxbValue == None or objPyxbValue == [] : continue
if elementDeclaration.isPlural():
dictArgs[objPyxbName] = []
- for objPyxb in objPyxbValue : dictArgs[objPyxbName].append(self.pyxbToDict(objPyxb))
+ #objAAnalyser.dictPyxb[objPyxbName]={}
+ objAAnalyser.dictPyxb[objPyxbName]=[]
+ #objAAnalyser.dictPyxb['objEnPyxb']=objAAnalyser
+ for objPyxb in objPyxbValue :
+ #print ('-------------',objPyxb)
+ dictArgs[objPyxbName].append(self.pyxbToDict(objPyxb))
+ objPyxb.dictPyxb['objEnPyxb'] = objPyxb
+ objAAnalyser.dictPyxb[objPyxbName].append(objPyxb.dictPyxb)
else:
dictArgs[objPyxbName] = self.pyxbToDict(getattr(objAAnalyser, objPyxbName))
- print ("***********************************")
- print ('pyxbToDict ', objAAnalyser)
- print (dictArgs)
+ #print ('ajout ds dico de ', objAAnalyser , 'de', objPyxbName, objPyxbValue)
+ objAAnalyser.dictPyxb[objPyxbName] = objPyxbValue.dictPyxb
+ #print ('ajout ds dico de ', objPyxbValue.dictPyxb, 'de', objPyxbName)
+ objAAnalyser.dictPyxb['objEnPyxb']=objAAnalyser
+ #print ("***********************************")
+ #print ('pyxbToDict fin pour ********** ', objAAnalyser)
+ #print ('pyxbToDict ', objAAnalyser, objAAnalyser.dictPyxb)
+ #print ('pyxbToDict fin pour ********** ', objAAnalyser)
+ #print ("***********************************")
+ #print (dictArgs)
+ #print (dictPyxb)
#for i in dictArgs.keys(): print (i, " ", dictArgs[i], " ", type(dictArgs[i]))
- print ("***********************************")
+ #print ('fin pour ',objAAnalyser)
return dictArgs
comprises entre le premier DEBUT/POURSUITE et le premier FIN
et rendre actives les autres
"""
- if self.definition.code == 'ASTER' :
+ #if self.definition.code == 'ASTER' :
# Seulement pour ASTER :
# Avant DEBUT actif vaut 0
# Apres DEBUT et avant le 1er FIN actif vaut 1
# Apres le 1er FIN actif vaut -1
- actif=0
- else:
- actif=1
+ # actif=0
+ #actif=1
for etape in self.etapes:
- if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
- if actif == 1:
+ #if actif == 0 and etape.nom in ['DEBUT','POURSUITE']:actif=1
+ #if actif == 1:
etape.active()
- else:
- etape.inactive()
- if etape.nom == 'FIN':actif=-1
+ self.enregistreEtapePyxb(etape)
+ #else:
+ # etape.inactive()
+ #if etape.nom == 'FIN':actif=-1
def deplaceEntite(self,indexNoeudACopier,indexNoeudOuColler,pos):
"""
self.initModif()
index_etape=self.etapes.index(etape)
+ etape.deletePyxbObject()
self.etapes.remove(etape)
if etape.niveau is not self:
e.updateContext(context)
def analyse(self):
- self.compile()
- if not self.cr.estvide():return
- self.execCompile()
- self.activeEtapes()
+ if self.editor.format == 'xml' :
+ # il ne faut pas le faire quand le jeu de donnees est vide
+ self.setCurrentContext()
+ self.analyseFromXML()
+ #print ('stop demande'); exit()
+ #self.execCompileFromXML()
+ else :
+ self.compile()
+ self.execCompile()
+ if not self.cr.estvide():return
+ self.activeEtapes()
def registerParametre(self,param):
"""
# Erreurs dans l'INCLUDE. On garde la memoire du fichier
# mais on n'insere pas les concepts
# On retablit l'etape courante step
- print (j.cr)
- print ("valid ",j.isValid())
+ #print (j.cr)
+ #print ("valid ",j.isValid())
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
# L'INCLUDE n'est pas valide.
# on produit un rapport d'erreurs
cr=j.report()
- print ('cr', cr)
+ #print ('cr', cr)
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
for e in self.etapes:
e.niveau=self.niveau
e.parent=self.parent
+ e.state='change'
index=self.jdc.etapes.index(self)
self.jdc.etapes=self.jdc.etapes[:index+1]+self.etapes+self.jdc.etapes[index+1:]
"""
Cette methode sert a craer un contexte en interpratant un texte source Python.
"""
- print ("makeContexteInclude",fichier)
+ #print ("makeContexteInclude",fichier)
# on recupere le contexte d'un nouveau jdc dans lequel on interprete text
contexte = self.getContexteJdc(fichier,text)
if contexte == None :
# g_context est utilise pour avoir les concepts produits par la macro
# contexte_fichier_init est utilise pour avoir les concepts supprimes par la macro
self.contexte_fichier_init = contexte
- print ("fin makeContexteInclude",fichier)
+ #print ("fin makeContexteInclude",fichier)
def reevalueFichierInitObsolete(self):
"""Recalcule les concepts produits par le fichier enregistre"""
self.initModif()
self.mc_liste.remove(objet)
CONNECTOR.Emit(self,"supp",objet)
+ objet.deletePyxbObject()
objet.deleteMcGlobal()
objet.updateConditionBloc()
objet.supprime()
if len(objet) > 1 : return 0
else : return 1
+ def getMinMax(self):
+ """
+ Retourne les valeurs min et max admissibles pour la valeur de self
+ """
+ return self.definition.min,self.definition.max
+
+
def getLabelText(self):
"""
Retourne le label de self suivant qu'il s'agit d'un MCFACT
self.remove(obj)
CONNECTOR.Emit(self,"supp",obj)
self.updateConditionBloc()
+ obj.deletePyxbObject()
obj.supprime()
self.etape.modified()
self.finModif()
if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
self.monType=type_permis
return self.valideMatrice(cr=cr)
- if self.definition.siValide != None :
+ validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
+ if self.definition.siValide != None and validite:
self.definition.siValide(self)
- return Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
+ return validite
def getNomConcept(self):
p=self
self.withXSD=False
self.afficheIhm=True
self.closeParenthese=False
+ self.enleverActionStructures=False
+ self.enleverParametres=False
+ self.enleverSupprimer=False
+ self.ajoutExecution=False
+ self.utilParExtensions=False
+
# si possible on renomme l objet comme le noeud couper
if (self.QWParent.edit == "couper"):
- print ('je pass la')
+ #print ('je pass la')
if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
nodeOuAjouter=self.node_selected[0]
if nodeOuAjouter != self.tree.racine :
while nodeOuAjouter.treeParent != self.tree.racine:
- print (nodeOuAjouter)
+ #print (nodeOuAjouter)
nodeOuAjouter=nodeOuAjouter.treeParent
- print (nodeOuAjouter.parent == self.tree.racine)
+ #print (nodeOuAjouter.parent == self.tree.racine)
nouveau=nodeOuAjouter.appendBrother(nomEtape)
try :
self.node_selected[0].setSelected(False)
def ajoutMCFact(self,etape,MCFils,listeAvant=()):
#----------------------------------------------#
# dans le JDC
- print ('ajoutMCFact')
+ #print ('ajoutMCFact')
ouChercher=etape
- print (ouChercher)
+ #print (ouChercher)
for mot in listeAvant :
ouChercher=ouChercher.getChild(mot,restreint="oui")
- print (mot)
- print (ouChercher)
+ #print (mot)
+ #print (ouChercher)
monMC=etape.getChild(ouChercher,restreint="oui")
if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.isValid()
#-----------------------
def getEtapeCourante(self) :
#-----------------------
- print (self.tree.selectedItems())
+ #print (self.tree.selectedItems())
if len(self.tree.selectedItems()) != 1 : return None
etape=self.tree.selectedItems()[0].item.object.getEtape()
return etape
self.jdc.aReafficher=False
txt_exception = None
if not jdc:
+# si on est en XMML ne faut-il pas passer en Accas ?
self.jdc.analyse()
txt_exception = self.jdc.cr.getMessException()
if txt_exception :
CONTEXT.unsetCurrentStep()
- #jdc=self.readercata.cata[0].JdC(procedure=text,
+ #if elf.appliEficas.maConfiguration
jdc=self.readercata.cata.JdC(procedure=text,
appli=self,
cata=self.readercata.cata,
jdc.recorded_units=units
jdc.old_recorded_units=units
## PNPN est ce que la ligne suivante est bien utile ?
- if texte == "" :jdc.analyse()
+ # elle positionne le contexte
+ # est ce qu on ne doit pas changer le format en Accas si on vient d accas ?
+ if self.format == 'xml' : return jdc
+ if texte == "" :
+ jdc.editor=self
+ jdc.analyse()
return jdc
#--------------------------------#
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
from .monViewTexte import ViewText
try :
if sys.platform[0:5]=="linux" :
- cmd="xdg-open "+ str(fichier)
+ #cmd="xdg-open "+ str(fichier)
+ #changer pour marcher dans l'EDC
+ #cmd="gedit "+ str(fichier)
+ from os.path import splitext
+ fileName,extension = splitext(fichier)
+ if extension in self.parentQt.editor.appliEficas.maConfiguration.utilParExtensions:
+ cmd=self.parentQt.editor.appliEficas.maConfiguration.utilParExtensions[extension] + " " + str(fichier)
+ else: cmd="xdg-open "+ str(fichier)
os.system(cmd)
else :
os.startfile(str(fichier))
self.appliEficas.maConfiguration.savedir,
filters)
else:
- print(filters)
+ #print(filters)
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
self.appliEficas.maConfiguration.savedir,
def BFichierOuRepertoirePressed(self):
self.fileName=""
- print (0)
self.file_dialog=QFileDialog()
- print (1)
self.file_dialog.setFileMode(QFileDialog.Directory);
- print (2)
self.file_dialog.setFileMode(QFileDialog.Directory|QFileDialog.ExistingFiles)
- print (3)
self.file_dialog.setOption(QFileDialog.DontUseNativeDialog,True);
self.file_dialog.setWindowTitle('Choose File or Directory')
self.explore(self.file_dialog)
QWidget.__init__(self,None)
self.node=node
self.node.fenetre=self
- if self.node.item.nom == 'MASSES' : traceback.print_stack()
self.setupUi(self)
self.editor=editor
self.obj=obj
maDefinition = self.monOptionnel.parentMC.definition.entites[self.texte]
maLangue = self.monOptionnel.parentMC.jdc.lang
if hasattr(maDefinition,maLangue):
- monAide = getattr(maDefinition,self.monOptionnel.parentMC.jdc.lang)
+ self.monAide = getattr(maDefinition,self.monOptionnel.parentMC.jdc.lang)
else :
- monAide = ""
+ self.monAide = ""
except :
- monAide = ""
- self.monOptionnel.parentMC.editor.afficheCommentaire(monAide)
+ self.monAide = ""
+ self.monOptionnel.parentMC.editor.afficheCommentaire(self.monAide)
class MonPBButtonCustom(QWidget,Ui_customPB):
self.appliEficas = appliEficas
self.buttonGroup = QButtonGroup()
- for nomEtape in self.appliEficas.readercata.cata_ordonne_dico:
+
+ for etape in self.appliEficas.readercata.cata.JdC.commandes :
+ nomEtape = etape.nom
toolButton = QToolButton(self.appliEficas.toolBarCommande)
icon = QIcon()
if nomEtape in self.appliEficas.maConfiguration.dicoIcones:
self.GroupBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.parentQt.commandesLayout.insertWidget(insertIn,self)
self.doitAfficherOptionnel=False
+ min,max=obj.getMinMax()
+ if max < 2 and hasattr(self, 'RBPlus') : self.RBPlus.close()
+ if max > 1 and hasattr(self, 'RBPlus') : self.RBPlus.clicked.connect(self.ajouteMCParPB)
def enterEvent(self,event):
#print "enterEvent ", self.node.item.getLabelText()[0]
#print "delayAffiche, self.doitAfficherOptionnel = ", self.doitAfficherOptionnel
if self.doitAfficherOptionnel and self.editor.code != "CARMELCND" :self.afficheOptionnel()
+ def ajouteMCParPB(self):
+ texteListeNom="+"+self.obj.nom
+ parentOuAjouter=self.parentQt
+ from .monWidgetBloc import MonWidgetBloc
+ while (parentOuAjouter and isinstance(parentOuAjouter, MonWidgetBloc)) :
+ parentOuAjouter=parentOuAjouter.parentQt
+ parentOuAjouter.ajoutMC(texteListeNom)
+
class MonWidgetFact(Ui_WidgetFact,MonWidgetFactCommun):
def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):
self.vireLesAutres(MC)
if MC.node.item.nom in self.dicoMCWidgetOptionnel :
+ #print (MC.node.item.nom)
self.dicoMCWidgetOptionnel[MC.node.item.nom].close()
self.dicoMCWidgetOptionnel[MC.node.item.nom].setParent(None)
self.dicoMCWidgetOptionnel[MC.node.item.nom].deleteLater()
+ del self.dicoMCWidgetOptionnel[MC.node.item.nom]
if liste==[] : return
groupe = MonGroupeOptionnel(liste,liste_rouge,self,MC)
self.groupesOptionnelsLayout.insertWidget(0,groupe)
def changeTout(self,int):
- print ('changeTout')
+ #print ('changeTout')
if self.inhibe : return
self.inhibe=True
if not(self.CBCheck.isChecked()) :
self.changeValeur()
def setValeurs(self):
- print ('setValeurs')
+ #print ('setValeurs')
self.listeValeursCourantes =self.node.item.getValeur()
if self.listeValeursCourantes == None : self.listeValeursCourantes=[]
#print "ds set Valeur", self.listeValeursCourantes, self.node.item.getValeur()
def ajoutCB(self,index,valeur=None):
- print ('ajoutCB')
+ #print ('ajoutCB')
nomCB="lineEditVal"+str(index)
if hasattr(self,nomCB) : return
nouveauCB = QCheckBox(self.scrollArea)
def ajout1Valeur(self,valeur=None):
- print ('ajout1Valeur')
+ #print ('ajout1Valeur')
if valeur == None : return
liste,validite=SaisieValeur.TraiteLEValeur(self,str(valeur))
if validite == 0 : return
def changeValeur(self):
- print ('changeValeur')
+ #print ('changeValeur')
if self.inhibe == True: return
if hasattr(self,'LEFiltre') :self.noircirResultatFiltre()
self.listeValeursCourantesAvant=self.listeValeursCourantes
def prepareListeResultatFiltre(self):
- print ('prepareListeResultatFiltre')
+ #print ('prepareListeResultatFiltre')
filtre=str(self.LEFiltre.text())
for cb in self.listeCB:
texte=cb.text()
self.listeCbRouge.append(cb)
def prepareListeResultat(self):
- print ('prepareListeResultat')
+ #print ('prepareListeResultat')
self.clearAll()
self.setValeurs()
def clearAll(self):
- print ('clearAll')
+ #print ('clearAll')
for cb in self.listeCB :
cb.setText("")
validite,comm,comm2,listeRetour= self.politique.ajoutNTuple(listeComplete)
if not validite :
- self.editor.afficheInfos(texte,Qt.red)
+ self.editor.afficheInfos(comm+comm2,Qt.red)
return
# on calcule le dernier lineedit rempli avant de changer la valeur
def setValeursApresBouton(self):
if self.objSimp.getValeur()==None : return
valeur=self.objSimp.getValeur()
- if not(type(valeur) == str) : valeur=str(valeur)
+ if not(isinstance(valeur, str)) : valeur = str(valeur)
try :
self.dict_bouton[valeur].setChecked(True)
self.dict_bouton[valeur].setFocus(True)
nomBouton="radioButton_"+str(i)
bouton=getattr(self,nomBouton)
valeur=self.maListeDeValeur[i-1]
- if not(type(valeur) == str) : valeur=str(valeur)
+ if not(isinstance(valeur, str)) : valeur = str(valeur)
bouton.setText(tr(valeur))
self.dict_bouton[valeur]=bouton
bouton.clicked.connect(self.boutonclic)
icon = QIcon(self.repIcon+"/parametres.png")
self.actionParametres.setIcon(icon)
-
if hasattr (self, 'maConfiguration') and self.maConfiguration.boutonDsMenuBar :
self.frameEntete.setMaximumSize(QSize(16777215,100))
self.frameEntete.setMinimumSize(QSize(0,100))
-
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.enleverActionStructures :
+ self.enleverActionsStructures()
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.enleverParametres :
+ self.enleverParametres()
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.enleverSupprimer :
+ self.enleverSupprimer()
+
self.myQtab.removeTab(0)
self.blEnteteGlob = QBoxLayout(2,self.frameEntete)
self.menuFichier.removeAction(self.actionARemplacer)
self.connecterSignaux()
self.toolBar.addSeparator()
+
if self.code != None : self.construitMenu()
self.setWindowTitle(self.VERSION_EFICAS)
Appli.__dict__[self.code.upper()](self,)
if self.suiteTelemac : self.lookSuiteTelemac()
self.metMenuAJourUtilisateurs()
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.ajoutExecution :
+ self.ajoutExecution()
def initAides(self):
#print "je passe la"
self.menuOptions.addAction(self.actionParametres_Eficas)
self.menuOptions.setTitle(tr("Options"))
+ def MAPIDENTIFICATION(self):
+ self.enlevernewInclude()
+ self.enleverSupprimer()
+ #self.ajoutExecution()
+ self.enleverRechercherDsCatalogue()
+ self.enleverActionsStructures()
+ self.enleverParametres()
+
def PSEN(self):
if self.first: self.first=0
try : self.action_Nouveau.triggered.disconnect(self.fileNew)
valeur=valeurBrute
# pour traiter 11.0 - 30.0 pour le CIST
- if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
+ #if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
+ if (valeurTraitee and isinstance(valeurTraitee, str) and (self.node.item.waitTxm())) :
valeur=str(valeurTraitee)
"""
# import du catalogue
self.choisitCata()
+
+ if self.appliEficas.maConfiguration.withXSD :
+ try :
+ #import raw.Telemac2d as modeleMetier
+ #import raw.cata_genere_fact as modeleMetier
+ import raw.cata_map_genere as modeleMetier
+ #import raw.cata_bloc as modeleMetier
+ print ('import Test ad modeleMetier')
+ except :
+ modeleMetier = None
+ else :
+ modeleMetier = None
+
self.cata = self.importCata(self.fic_cata)
+ self.cata.modeleMetier = modeleMetier
if not self.cata :
QMessageBox.critical( self.QWParent, tr("Import du catalogue"),tr("Impossible d'importer le catalogue ")+ self.fic_cata)
self.appliEficas.close()
# retrouveOrdreCataStandard fait une analyse textuelle du catalogue
# remplace par retrouveOrdreCataStandardAutre qui utilise une numerotation
# des mots cles a la creation
+ #print (self.cata)
+ #print (dir(self.cata))
self.retrouveOrdreCataStandardAutre()
if self.appliEficas.maConfiguration.modeNouvCommande == "initial" : self.retrouveOrdreCataStandard()
if hasattr(self.cata, 'Ordre_Des_Commandes') : self.Ordre_Des_Commandes=self.cata.Ordre_Des_Commandes
except:
pass
+ #if 1 :
try :
o=__import__(nom_cata)
return o
contient le nom des mots cles dans le bon ordre
"""
self.cata_ordonne_dico, self.appliEficas.liste_simp_reel=autre_analyse_cata.analyseCatalogue(self.cata)
+ #self.appliEficas.liste_simp_reel = ()
+ #self.cata_ordonne_dico = {}
def retrouveOrdreCataStandard(self):
"""
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
import uiinfo
-from Efi2Xsd import readerEfficas
+from Efi2Xsd import readerEfiXsd
+# ATtention pas teste depuis le chgt de nom
from readercata import ReaderCataCommun
#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 = readerEfiXsd.efficas.CreateFromDocument(xml)
SchemaMed.exploreCata()
self.cata=SchemaMed
uiinfo.traite_UIinfo(self.cata)
#---------------------------#
def createPopUpMenu(self):
- print ("createPopUpMenu")
+ #print ("createPopUpMenu")
#self.appliEficas.salome=True
self.createActions()
self.menu = QMenu(self.tree)
if editor.getEtapeCourante() == None :
QMessageBox.information( self.appliEficas,
tr("Selectionner une etape"),
- tr("Le texte ne peut pas etre insere dans un fichier vide,\nCreer un materiau vide et inserer le catalogue apres"))
+ tr("Le texte ne peut pas etre insere dans un fichier vide,\nCreer un materiau vide ou une zone vide et inserer le catalogue apres"))
return
listeParam = []
self.entites = args
self.affecter_parente()
- def __call__(self, val, nom, parent=None):
+ def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None):
"""
Construit un objet MCBLOC a partir de sa definition (self)
de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
"""
- return self.class_instance(nom=nom, definition=self, val=val, parent=parent)
+ return self.class_instance(nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
def verifCata(self):
"""
- reuse : indique le concept d'entree reutilise. Il se trouvera donc en sortie
si les conditions d'execution de l'operateur l'autorise
- valeur : arguments d'entree de type mot-cle=valeur. Initialise avec l'argument args.
- """
+ - objPyxbDeConstruction
+ """
+ # faut il le faire ds MC_Build ?
+ # traitement de Pyxb si Pyxb
+ self.dicoPyxbDeConstruction = args.get('dicoPyxbDeConstruction', None)
+ if self.dicoPyxbDeConstruction :
+ del args['dicoPyxbDeConstruction']
+ self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb']
+ else :
+ self.objPyxbDeConstruction=None
self.definition = oper
self.reuse = reuse
self.valeur = args
self.actif = 1
self.makeRegister()
self.icmd = None
+ print ('uuuuuuuuuuuuuuu fin init de ETAPE', self,oper)
def makeRegister(self):
"""
Initialise les attributs jdc, id, niveau et realise les
enregistrements necessaires
+ surcharge dans Ihm
"""
+ print ('makeRegister de ETAPE')
if self.parent:
self.jdc = self.parent.getJdcRoot()
self.id = self.parent.register(self)
list_instance = N_MCLIST.MCList
label = 'FACT'
- def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",fenetreIhm=None,
+ def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",fenetreIhm=None,
min=0, max=1, validators=None, **args):
"""
Un mot-clé facteur est caractérisé par les attributs suivants :
self.affecter_parente()
self.fenetreIhm = fenetreIhm
- def __call__(self, val, nom, parent):
+ def __call__(self, val, nom, parent, dicoPyxbDeConstruction = None):
"""
Construit la structure de donnee pour un mot cle facteur a partir
de sa definition (self) de sa valeur (val), de son nom (nom) et de
l = self.list_instance()
l.init(nom=nom, parent=parent)
if type(val) in (tuple, list, self.list_instance):
+ indice=0
for v in val:
if type(v) == dict or isinstance(v, _F):
objet = self.class_instance(
- nom=nom, definition=self, val=v, parent=parent)
+ nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice])
+ indice=indice+1
l.append(objet)
elif isinstance(v, self.class_instance):
+# if faut gerer ici --> on passe la avec une liste de concept ?
+# PNPN --> si pyxb
l.append(v)
else:
l.append(N_OBJECT.ErrorObj(self, v, parent, nom))
elif type(val) == dict or isinstance(val, _F):
objet = self.class_instance(
- nom=nom, definition=self, val=val, parent=parent)
+ nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
l.append(objet)
elif isinstance(val, self.class_instance):
+# idem --> quand passe t on la
l.append(val)
else:
l.append(N_OBJECT.ErrorObj(self, val, parent, nom))
-
+ l.cata=l.jdc.cata
+ l.buildObjPyxb(l)
return l
def verifCata(self):
self.cr.exception("Compilation impossible : " + ''.join(l))
return
+ def setCurrentContext(self):
+ # beaucoup trop simple Ne tient pas compte des imports
+ # et des include
+ # ne sert que pour le POC
+ CONTEXT.setCurrentStep(self)
+
def execCompile(self):
"""
Cette methode execute le jeu de commandes compile dans le contexte
init2 = "from " + obj_cata.__name__ + " import *"
exec(init2, self.g_context)
else :
- # ici on est en xml
+ # ici on a un catalogue en grammaire Eficas XML
# il faut ajouter ce qu on a construit au contexte
for (k,v) in obj_cata.contexteXML.items() :
self.g_context[k]=v
CONTEXT.unsetCurrentCata()
CONTEXT.setCurrentCata(self)
self.fenetreIhm=None
-
+ self.dictTypesXSD={}
+
def __call__(self, procedure=None, cata=None, cata_ord_dico=None,
nom='SansNom', parent=None, **args):
"""
nature = "MCBLOC"
- def __init__(self, val, definition, nom, parent):
+ def __init__(self, val, definition, nom, parent,dicoPyxbDeConstruction=None):
"""
Attributs :
- mc_liste : liste des sous-objets du bloc construite par appel à la méthode build_mc
"""
+ #print ('MCBLOC' , val, definition, nom, parent)
self.definition = definition
self.nom = nom
self.val = val
self.parent = parent
self.valeur = val
+ self.objPyxbDeConstruction=None
+ self.dicoPyxbDeConstruction=dicoPyxbDeConstruction
if parent:
self.jdc = self.parent.jdc
self.niveau = self.parent.niveau
Construit la liste des sous-entites du MCCOMPO
à partir du dictionnaire des arguments (valeur)
"""
+
+ #import traceback
+ #traceback.print_stack()
+ #print(("MCCOMPO.build_mc _____________________________________", self.nom))
+ #print (self.dicoPyxbDeConstruction)
if CONTEXT.debug:
print(("MCCOMPO.build_mc ", self.nom))
# Dans la phase de reconstruction args peut contenir des mots-clés
args = self.valeur
if args == None: args = {}
mc_liste = []
+
# On recopie le dictionnaire des arguments pour protéger l'original des
# delete (del args[k])
# 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut
# Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles
# globaux
+ # PN ligne suivante uniquement pour commodite
+ # a detruire quand cela fonctionne recursivement
+ if not hasattr(self, 'dicoPyxbDeConstruction') : self.dicoPyxbDeConstruction = {}
for k, v in list(self.definition.entites.items()):
if v.label != 'SIMP':
continue
# si une valeur existe dans args ou est obligatoire (generique si toutes les
# entites ont l attribut statut )
#
- objet = v(val=args.get(k, None), nom=k, parent=self)
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
+ objPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
+ else :
+ objPyxbDeConstruction=None
+ objet = v(val=args.get(k, None), nom=k, parent=self,objPyxbDeConstruction=objPyxbDeConstruction)
mc_liste.append(objet)
# Si l'objet a une position globale on l'ajoute aux listes
# correspondantes
# si une valeur existe dans args ou est obligatoire (generique si toutes les
# entites ont l attribut statut )
#
- objet = v(val=args.get(k, None), nom=k, parent=self)
+ if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction :
+ dicoPyxbDeConstruction=self.dicoPyxbDeConstruction[k]
+ del self.dicoPyxbDeConstruction[k]
+ else :
+ dicoPyxbDeConstruction=None
+ objet = v(val=args.get(k, None), nom=k, parent=self,dicoPyxbDeConstruction=dicoPyxbDeConstruction)
mc_liste.append(objet)
if k in args:
del args[k]
# 2- on l'ajoute à mc_liste
# 3- on récupère les arguments restant
# 4- on reconstruit le dictionnaire équivalent à mc_liste
- bloc = v(nom=k, val=args, parent=self)
+ bloc = v(nom=k, val=args, parent=self,dicoPyxbDeConstruction=self.dicoPyxbDeConstruction)
mc_liste.append(bloc)
args = bloc.reste_val
# On ne recalcule pas le contexte car on ne tient pas compte des blocs
# (utile seulement pour IHM graphique)
mc_liste = self.ordonneListe(mc_liste)
# on retourne la liste ainsi construite
+ self.cata=self.jdc.cata
+ self.buildObjPyxb(mc_liste)
+ #else : print ('pas de construction pour ', self.nom, self.objPyxbDeConstruction)
+ #print ('buildObjPyxb : ' , self.nom)
+ print(("MCCOMPO.build_mc fin_____________________________________", self.nom))
return mc_liste
def ordonneListe(self, mc_liste):
"""
nature = "MCFACT"
- def __init__(self, val, definition, nom, parent):
+ def __init__(self, val, definition, nom, parent,dicoPyxbDeConstruction):
"""
Attributs :
- val : valeur du mot clé simple
- nom
- parent
"""
+ #print ('MCFACT', self, val, definition, nom, parent, objPyxbDeConstruction)
+ import traceback
+ #traceback.print_stack()
+ #if nom == 'experience' : print ('MCFACT', self, parent, dicoPyxbDeConstruction); exit()
+ self.dicoPyxbDeConstruction=dicoPyxbDeConstruction
+ if self.dicoPyxbDeConstruction :
+ self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb']
+ del self.dicoPyxbDeConstruction['objEnPyxb']
+ else :
+ self.objPyxbDeConstruction=None
self.definition = definition
self.nom = nom
self.val = val
nature = 'MCList'
def init(self, nom, parent):
+ self.objPyxbDeConstruction=None
self.definition = None
self.nom = nom
self.parent = parent
"""
nature = 'MCSIMP'
- def __init__(self, val, definition, nom, parent):
+ def __init__(self, val, definition, nom, parent,objPyxbDeConstruction):
"""
Attributs :
- valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
"""
+ #print ("MCSIMP, ------------------------")
+ #print (self, val, definition, nom, parent)
+ #print ("MCSIMP, ------------------------")
self.definition = definition
self.nom = nom
self.val = val
self.parent = parent
self.convProto = ConversionFactory('type', typ=self.definition.type)
self.valeur = self.GETVAL(self.val)
+ self.objPyxbDeConstruction=objPyxbDeConstruction
if parent:
- self.jdc = self.parent.jdc
+ self.jdc = self.parent.jdc
+ self.cata = self.jdc.cata
self.niveau = self.parent.niveau
self.etape = self.parent.etape
+ self.buildObjPyxb()
else:
# Le mot cle simple a été créé sans parent
+ # est-ce possible ?
+ print ('je suis dans le else sans parent du build')
self.jdc = None
+ self.cata = None
self.niveau = None
self.etape = None
label = 'OPER'
nommage = nommage
- def __init__(self, nom, op, sd_prod, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None,
+ def __init__(self, nom, op=None, sd_prod=None, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None,
docu="", regles=(), op_init=None, niveau = None, UIinfo=None, **args):
"""
Méthode d'initialisation de l'objet OPER. Les arguments sont utilisés pour initialiser
- sug : valeur suggere
- fenetreIhm=None
"""
+ #print (self)
+ #import traceback
+ #traceback.print_stack()
+ #print (self)
N_ENTITE.ENTITE.__init__(self, validators)
# Initialisation des attributs
if type(typ) == tuple:
self.checkPosition()
self.checkValidators()
- def __call__(self, val, nom, parent=None):
+ def __call__(self, val, nom, parent=None, objPyxbDeConstruction = None):
"""
Construit un objet mot cle simple (MCSIMP) a partir de sa definition (self)
de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
"""
- return self.class_instance(nom=nom, definition=self, val=val, parent=parent)
-
- def creeT_SIMP(self):
- from Efi2Xsd.readerEfficas import monSIMP
- from Efi2Xsd.mapDesTypes import dictSIMPEficasXML
-
- self.objXML=monSIMP()
- for nomEficasArg in dictSIMPEficasXML :
- argu=getattr(self,nomEficasArg)
- nomXMLarg=dictSIMPEficasXML[nomEficasArg]
- if not isinstance(nomXMLarg, (list, tuple)) :
- print(nomXMLarg, argu)
+ return self.class_instance(nom=nom, definition=self, val=val, parent=parent, objPyxbDeConstruction=objPyxbDeConstruction)
+
+# def creeT_SIMP(self):
+# from Efi2Xsd.readerEfficas import monSIMP
+# from Efi2Xsd.mapDesTypes import dictSIMPEficasXML
+# self.objXML=monSIMP()
+# for nomEficasArg in dictSIMPEficasXML :
+# argu=getattr(self,nomEficasArg)
+# nomXMLarg=dictSIMPEficasXML[nomEficasArg]
+# if not isinstance(nomXMLarg, (list, tuple)) :
+# print(nomXMLarg, argu)
#if nomEficasArg in listeParamDeTypeTypeAttendu:
# typeAttendu = self.typ
-
- setattr(self.objXML, nomXMLarg, argu)
+#
+# setattr(self.objXML, nomXMLarg, argu)
<property name="spacing">
<number>0</number>
</property>
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
+ <property name="margin">
<number>0</number>
</property>
<item>
</property>
</spacer>
</item>
+ <item>
+ <widget class="QToolButton" name="RBPlus">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QToolButton" name="RBPoubelle">
<property name="minimumSize">
</layout>
<zorder></zorder>
<zorder></zorder>
- <zorder></zorder>
- <zorder>verticalSpacer_2</zorder>
- <zorder></zorder>
</widget>
<customwidgets>
<customwidget>
