#rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
self.isValid()
if not self.isValid() and self.nom == "INCLUDE" :
- self.cr.fatal(('Etape : %s ligne : %r %s'),
- self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte"))
+ self.cr.fatal('Etape : {} ligne : {} {}'.format(self.nom, self.appel[0], tr("\n Include Invalide. \n ne sera pas pris en compte")))
return cr
l=[]
for k,v in d.items():
- print (k,v)
#if type(v) != types.InstanceType and not isinstance(v,object): continue
if not isinstance(v,object): continue
# On considere que seul assd indique un type quelconque pas CO
etapeTraitee.isValid()
def recalculeValiditeApresChangementGlobalJdc(self, motClef):
- print ("je passe dans recalculeValiditeApresChangementGlobalJdc")
+ #print ("je passe dans recalculeValiditeApresChangementGlobalJdc")
#import traceback
#traceback.print_stack()
try :
liste=()
for etapeTraitee in self.etapes :
if etapeTraitee.nom not in liste: continue
- print ('me voila pour ', etapeTraitee.nom)
#self.forceRecalculBloc(etapeTraitee)
etapeTraitee.state='arecalculer'
etapeTraitee.deepUpdateConditionBloc()
ou leve une exception
--> utilisee par ops.POURSUITE et INCLUDE
"""
- #print ("getContexteJdc",self,self.nom, text)
+ print ("getContexteJdc",self,self.nom, text)
# On recupere l'etape courante
step=CONTEXT.getCurrentStep()
self.text_included_converted=0
- #try:
- if 1 :
+ try:
+ #if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
# Attention getContexteAvant retourne un dictionnaire qui contient
# le contexte courant. Ce dictionnaire est reactualise regulierement.
self.jdc_aux=j
self.jdc.jdcDict=self.jdc_aux
- #except:
- else :
+ except:
+ #else :
traceback.print_exc()
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
if callable(v):continue
self.g_context[k]=param2.Variable(k,v)
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
+ print (j)
+ print (dir(j))
+ print (j.current_context)
# On recupere le contexte courant
self.current_context=j.current_context
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
self.index_etape_courante=j.index_etape_courante
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
self.jdc_aux=j
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
CONTEXT.setCurrentStep(step)
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
+ print ('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkmmmmmmmmmmmmmmmmmmmmmm')
return j_context
def reevalueSdJdc(self):
"""
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)
+ print (contexte)
if contexte == None :
raise EficasException("Impossible de construire le jeu de commandes correspondant au fichier")
else:
# 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"""
return
if type(self.definition.op_init) == types.FunctionType:
+ print ('mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm dans updateContext')
self.definition.op_init(*(self,d))
if self.sd != None :d[self.sd.nom]=self.sd
for co in self.sdprods:
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
+ #def makeInclude(self, unite=None, fname=None):
def makeInclude(self, unite=None, fname=None):
"""
Inclut un fichier dont l'unite logique est unite
Sinon on retourne None. Les concepts produits par l'INCLUDE sont
pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
"""
- #print "makeInclude",unite
+ print ("makeInclude",fname)
# On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
# car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
# Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
- if not unite and not fname:
- return
+ #if not unite and not fname:
+ # return
+ # 2020 on supprime unite
+ # attention cependant c est utilise pour poursuite
+ # PNPN a revoir
+ if not fname : return
if not hasattr(self,'fichier_ini') :
# Si le fichier n'est pas defini on le demande
raise EficasException(self.fichier_err)
try:
+ print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii')
self.makeContexteInclude(self.fichier_ini ,self.fichier_text)
+ print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii')
self.parent.recordUnit(unite,self)
+ print ('iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii')
except:
l=traceback.format_exception_only(tr("Fichier invalide %s",sys.exc_info()[1]))
if self.jdc.appliEficas:
self.updateFichierInit(unite)
self.fichier_unite=unite
if self.fichier_err is not None: raise EficasException(self.fichier_err)
+ print ('self.g_context', self.g_context)
#ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
self.initModif()
self.valeur = new_valeur
self.val = new_valeur
- print ('dans setValeur pour ', self.nom)
if self.valeur and self.waitUserAssd() and not(self.waitUserAssdEnCreation()) : self.valeur.ajoutUtilisePar(self)
if self.isValid():self.setValeurObjPyxb(new_valeur)
self.updateConditionBloc()
# doit etre surcharge dans MC_COMPO et MC_SIMP
pass
+ def demandeRedessine(self):
+ CONNECTOR.Emit(self,"redessine")
self.item.connect("valid",self.onValid,())
self.item.connect("supp" ,self.onSupp,())
self.item.connect("add" ,self.onAdd,())
+ self.item.connect("redessine" ,self.onRedessine,())
self.state=""
self.fenetre=None
self.updateNodes()
if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
-
+ def onRedessine(self):
+ #---------------------
+ print ('dans redessine pour', self)
+ self.updateNodeTexte()
+ #if not(self.fenetre): return
+ # a priori l objet C++ n est plus la si la fenetre n est pas visible
def updateNodeValid(self):
#-----------------------
def getPanelGroupe(self,parentQt,maCommande):
+ #print (self,self.item.nom, )
maDefinition=self.item.get_definition()
monObjet=self.item.object
monNom=self.item.nom
from InterfaceQT4.monWidgetSDCOInto import MonWidgetSDCOInto
widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.waitAssd():
+
+ # PN - pour ne pas appeller trop souvent self.item.getSdAvantDuBonType()
+ if not (self.item.waitUserAssdEnCreation()) : maListe=self.item.getSdAvantDuBonType()
if self.item.waitUserAssdEnCreation() :
from InterfaceQT4.monWidgetCreeUserAssd import MonWidgetCreeUserAssd
widget=MonWidgetCreeUserAssd(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif len(self.item.getSdAvantDuBonType()) == 0 :
+ #elif len(self.item.getSdAvantDuBonType()) == 0 :
+ elif len(maListe) == 0 :
from InterfaceQT4.monWidgetVide import MonWidgetVide
widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif len(self.item.getSdAvantDuBonType()) < 4 :
+ #elif len(self.item.getSdAvantDuBonType()) < 4 :
+ elif len(maListe) < 4 :
from InterfaceQT4.monWidgetRadioButton import MonWidgetRadioButtonSD
widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif len(self.item.getSdAvantDuBonType()) < 7 :
+ #elif len(self.item.getSdAvantDuBonType()) < 7 :
+ elif len(maListe) < 7 :
from InterfaceQT4.monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
# ----------------------------------------
def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, units = None, include=0):
- #------------------------------------------------------------------------------------------
+ #------------------------------------------------------------------------------------------------
QWidget.__init__(self,None)
# ---------------------------------------------
def __init__ (self,appliEficas,fichier = None, jdc = None, units = None, include=0 ):
- #------------------------------------------------------------------------------#
+ #-----------------------------------------------------------------------------------#
# paticularisee avec Ihm
if debug : print ('dans le init de JDCEditorSsIhm')
#jdc=self.readercata.cata[0].JdC(procedure=text,
jdc=self.readercata.cata.JdC(procedure=text,
- appliEficas=self,
+ appliEficas=self.appliEficas,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
nom=jdcName,
jdc=self.readercata.cata.JdC( procedure =texte,
- appliEficas=self,
+ appliEficas=self.appliEficas,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
rep_mat=self.maConfiguration.rep_mat
#jaux=self.readercata.cata[0].JdC( procedure="",
jaux=self.readercata.cata.JdC( procedure="",
- appliEficas=self,
+ appliEficas=self.appliEficas,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
rep_mat=self.maConfiguration.rep_mat,
jaux.analyse()
J=JdC_aux( procedure="",
- appliEficas=self,
+ appliEficas=self.appliEficas,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
jdc_pere=jaux,
if editeurDir not in sys.path : sys.path.append(editeurDir)
-def lanceEficas(code=None, multi=False, langue='en'):
-#---------------------------------------------------
+def lanceEficas(code=None, multi=False, langue='en', labelCode=None):
+#-------------------------------------------------------------------
"""
Lance l'appli EFICAS avec Ihm
"""
from InterfaceQT4.qtEficas import Appli
app = QApplication(sys.argv)
- Eficas=Appli(code=code,salome=0,multi=multi,langue=langue)
+ Eficas=Appli(code=code,salome=0,multi=multi,langue=langue,labelCode=labelCode)
Eficas.show()
res=app.exec_()
sys.exit(res)
-def getEficasSsIhm(code=None, multi=False, langue='en'):
-#------------------------------------------------------
+def getEficasSsIhm(code=None, multi=False, langue='en', labelCode=None):
+#------------------------------------------------------------------------
"""
Lance l'appli EFICAS sans Ihm
"""
if options.code != None : code=options.code
from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
- Eficas=AppliSsIhm(code=code, salome=0, multi=multi, langue=langue)
+ Eficas=AppliSsIhm(code=code, salome=0, multi=multi, langue=langue, labelCode=labelCode)
return Eficas
self.parentQt.commandesLayout.insertWidget(-1,self,1)
+ def afficheOptionnel(self):
+ return
self.editor.ajoutOptionnel()
self.editor.inhibeSplitter=0
self.monOptionnel=self.editor.widgetOptionnel
- self.afficheOptionnel()
+ self.afficheOptionnel()
#print "fin init de widget Commande"
self.order = self.parent.icmd
else:
self.order = 0
- # attributs pour le Catalogue de Structure de Données Jeveux
+ # attributs pour le Catalogue de Structure de Données
# "self.cata_sdj" est un attribut de classe
self.ptr_class_sdj = None
self.ptr_sdj = None
from .N_types import forceList
+
class BLOC(N_ENTITE.ENTITE):
"""
self.checkCondition()
self.verifCataRegles()
+
def verifPresence(self, dict, globs):
"""
Cette méthode vérifie si le dictionnaire passé en argument (dict)
dico.update(dict)
if self.condition != None:
try:
+ #if 1 :
test = eval(self.condition, globs, dico)
return test
+ #try:
+ # 1
except NameError:
# erreur 'normale' : un mot-clé n'est pas présent et on veut
# l'évaluer dans la condition
"""Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'."""
return not au_moins_un(mcsimp, valeurs)
+ def getEficasAttribut( nomUserASSD, nomAttr):
+ #print ('dans getEficasAttribut de Bloc')
+ if nomUserASSD == None : return None
+ return ( nomUserASSD.getEficasAttribut(nomAttr))
+
return locals()
TypeConversion.__init__(self, classUser)
def function(self, o):
+ #print ('je convertis : ', o, 'en ', self.typeACreer )
#import traceback
- print ('je convertis : ', o, 'en ', self.typeACreer )
#traceback.print_stack()
if o == None : return None
nouvelObj=self.typeACreer(o)
cata_ord_dico=None, parent=None,
nom='SansNom', appliEficas=None, context_ini=None, **args):
self.procedure = procedure
- print (self.procedure)
self.definition = definition
self.cata = cata
# PN pourquoi ?
exec(self.proc_compile, self.g_context)
CONTEXT.unsetCurrentStep()
- if self.appliEficas != None:
- self.appliEficas.afficheInfos('')
#try :
# print ('PNPN')
Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
- if self.appliEficas:
+ #if self.appliEficas:
# Si le JDC est relie a une appliEficascation maitre, on delègue la
# recherche
- return self.appliEficas.getFile(unite, fic_origine)
- else:
- if unite != None:
- if os.path.exists("fort." + str(unite)):
- fname = "fort." + str(unite)
- if fname == None:
- raise AsException("Impossible de trouver le fichier correspondant"
- " a l unite %s" % unite)
- if not os.path.exists(fname):
- raise AsException("%s n'est pas un fichier existant" % fname)
- fproc = open(fname, 'r')
- text = fproc.read()
- fproc.close()
- text = text.replace('\r\n', '\n')
- linecache.cache[fname] = 0, 0, text.split('\n'), fname
- return fname, text
+ # return self.appliEficas.getFile(unite, fic_origine)
+ #else:
+ # if unite != None:
+ # if os.path.exists("fort." + str(unite)):
+ # fname = "fort." + str(unite)
+ if fname == None:
+ raise AsException("Impossible de trouver le fichier correspondant")
+ if not os.path.exists(fname):
+ raise AsException(fname + " n'est pas un fichier existant" )
+ fproc = open(fname, 'r')
+ text = fproc.read()
+ fproc.close()
+ text = text.replace('\r\n', '\n')
+ linecache.cache[fname] = 0, 0, text.split('\n'), fname
+ return fname, text
def set_parLot(self, parLot, user_value=False):
"""
nommage = nommage
def __init__(
- self, nom, op, sd_prod=None, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None,
+ self, nom, op=None, sd_prod=None, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None,
docu="", regles=(), op_init=None, niveau = None, fichier_ini=0, UIinfo=None, **args):
"""
Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser
- 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, ------------------------")
+ #print (self, val, definition, nom, parent)
self.definition = definition
self.nom = nom
self.val = val
for leNom,laVariable in self.jdc.g_context.items():
if id(laVariable)== id(val) and (leNom != 'sansNom'):
val.initialiseNom(leNom)
+ if val.parent== None : val.initialiseParent(self)
return val
if self.convProto:
val = self.convProto.convert(val)
if self.convProto:
objVal = self.convProto.convert(nomVal)
objVal.initialiseNom(nomVal)
+ if objVal.parent== None : objVal.initialiseParent(self)
p=self.parent
while p in self.parent :
print ('mise a jour de ',p)
- if has_attr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.objVal)
- else : p.listeDesReferencesCrees=(self.objVal,)
+ if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objVal)
+ else : p.listeDesReferencesCrees=(objVal,)
p=p.parent
return (self.setValeur(objVal), 'reference cree')
"""
return [co for co in forceList(self.valeur)
if isinstance(co, CO) and co.isTypCO()]
+
+ def supprime(self):
+ if hasattr(self, 'val') and hasattr(self.val, 'supprime') :self.val.supprime()
+ N_OBJECT.OBJECT.supprime(self)
Classe de base pour definir des types de structures de donnees definie par
l utilisateur
equivalent d un concept ASSD pour un SIMP ou un FACT
- Attention : le parent est le JDC et non le MC createur que l on ne connait pas
+ Attention : le parent est a None au debut et non le MC createur que l on ne connait pas
Lorsqu on ecrit le jdc, n ecrit nom=UserASSD()
+ le parent est le SIMP qui cree l objet
a la lecture si la classe commence par un majuscule on fait le boulot dans MCSIMP, sinon dans
l init de parametre car le parsing considere qu on a un parametre
"""
def __init__(self,nom='sansNom'):
- self.nom = nom
- self.jdc = CONTEXT.getCurrentJdC()
- self.parent = self.jdc
+ self.nom = nom
+ self.jdc = CONTEXT.getCurrentJdC()
+ self.parent = None
self.initialiseValeur()
self.utilisePar = set()
- if self.nom != 'sansNom' : self.id = self.parent.regSD(self)
+ if self.nom != 'sansNom' : self.id = self.jdc.regSD(self)
else : self.id = None
+ self.ptr_sdj = None
+ def initialiseParent(self, parent):
+ #print ('je passe initialiseParent pour : ', self, parent)
+ self.parent= parent
+
def initialiseNom(self,nom):
- print ('je passe initialiseNom pour : ', self, nom)
- for (i,j) in self.parent.sdsDict.items() :
+ #print ('je passe initialiseNom pour : ', self, nom)
+ for (i,j) in self.jdc.sdsDict.items() :
if j == self :
- del(self.parent.sdsDict[i])
- self.parent.sdsDict[nom]=self
+ del(self.jdc.sdsDict[i])
+ self.jdc.sdsDict[nom]=self
self.nom=nom
- if self.nom != 'sansNom' and self.id ==None : self.id = self.parent.regSD(self)
+ if self.nom != 'sansNom' and self.id ==None : self.id = self.jdc.regSD(self)
def initialiseValeur(self,valeur=None):
self.valeur=valeur
try : self.utilisePar.remove(mc)
except : pass
-
def renomme(self,nouveauNom):
- self.parent.delConcept(self.nom)
- self.parent.sdsDict[nouveauNom] = self
+ self.jdc.delConcept(self.nom)
+ self.jdc.sdsDict[nouveauNom] = self
self.setName(nouveauNom)
+ #print ('je suis dans renomme',nouveauNom, self.nom)
+ #print (self.utilisePar)
+ for mc in (self.utilisePar):
+ mc.demandeRedessine()
+
def deleteReference(self):
print ('je suis dans deleteReference')
for MC in self.utilisePar :
MC.valeur=None
- self.parent.delConcept(self.nom)
+ self.jdc.delConcept(self.nom)
+ def getEficasAttribut(self, attribut):
+ #print ('je suis dans getEficasAttr', attribut)
+ if self.parent == None : return None
+ #print ('apres if')
+ try :
+ valeur = self.parent.parent.getMocle(attribut)
+ except :
+ valeur = None
+ #print (valeur)
+ return valeur
+
+
+ def supprime(self):
+ self.deleteReference()
+ ASSD.supprime(self)
+
self.args = {}
def register(self, T, A):
- print (T,A)
+ print ('register Protocol',T,A)
self.registry[T] = A
def adapt(self, obj):
<string>...</string>
</property>
<property name="icon">
- <iconset theme="add"/>
+ <iconset>
+ <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
</property>
<property name="iconSize">
<size>
if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
else : self.textePy += mot+' = ' +str(valeurs[mot])+','
self.textePy+=');\n' # fin de la commande
- print (self.textePy)
+ #print (self.textePy)
return self.textePy
def traiteMCFact(self,mot,valeurs):
