# au mot-clé courant
# ----------------------------------------------------------------------------------------
- def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
- """
- Enregistre val comme valeur de self.node.item.object SANS
- faire de test de validité
- """
- if self.parent.modified == 'n' : self.parent.init_modif()
- if name != None:
- valeur =name
- else :
+# def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
+# if self.parent.modified == 'n' : self.parent.init_modif()
+# if name != None:
+# valeur =name
+# else :
#XXX Pourquoi proceder ainsi ? Il n'est pas possible de mettre
# None comme valeur du mot cle.
# Probablement que ce debranchement permet de mettre record_valeur
# en call back, il faut donc aller chercher la valeur dans l'entry
- valeur= self.entry.get()
- self.entry.delete(0,END)
+# valeur= self.entry.get()
+# self.entry.delete(0,END)
#XXX Pour permettre la mise a None du mot cle, on remet None si valeur == ''
- if valeur == '':valeur=None
- self.node.item.set_valeur(valeur,evaluation='non')
+# if valeur == '':valeur=None
+# self.node.item.set_valeur(valeur,evaluation='non')
+# self.parent.appli.affiche_infos(mess)
+# if self.node.item.get_position()=='global':
+# self.node.etape.verif_all()
+# elif self.node.item.get_position()=='global_jdc':
+# self.node.racine.verif_all()
+# else :
+# self.node.parent.verif()
+# self.node.update()
+# if self.node.item.isvalid():
+# self.node.parent.select()
+
+ def record_old_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
+ """
+ Enregistre val comme valeur de self.node.item.object SANS
+ faire de test de validité ni ré-évaluer l'ancienne valeur
+ permet de rester avec des valeurs non entrees et de ne pas
+ ré-évaluer des entiers par exemple
+ """
+ if self.parent.modified == 'n' : self.parent.init_modif()
+ self.node.item.set_valeur(name)
self.parent.appli.affiche_infos(mess)
if self.node.item.get_position()=='global':
- self.node.etape.verif_all()
+ self.node.etape.verif_all()
elif self.node.item.get_position()=='global_jdc':
- self.node.racine.verif_all()
+ self.node.racine.verif_all()
else :
- self.node.parent.verif()
+ self.node.parent.verif()
self.node.update()
if self.node.item.isvalid():
- self.node.parent.select()
+ self.node.parent.select()
+
+ def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
+ """
+ Enregistre val comme valeur de self.node.item.object
+ en evaluant l item et en le validant
+ """
+ if self.parent.modified == 'n' : self.parent.init_modif()
+ if name != None:
+ valeur = name
+ else :
+ valeur= self.entry.get()
+ self.entry.delete(0,END)
+ if valeur == '': valeur=None
+ valeureval,validite=self.node.item.eval_valeur(valeur)
+ if self.node.item.is_list() :
+ verification=self.node.item.valide_liste_complete(valeureval)
+ else :
+ verification=self.node.item.valide_item(valeureval)
+ if verification :
+ self.node.item.set_valeur(valeureval)
+ self.parent.appli.affiche_infos(mess)
+ if self.node.item.get_position()=='global':
+ self.node.etape.verif_all()
+ elif self.node.item.get_position()=='global_jdc':
+ self.node.racine.verif_all()
+ else :
+ self.node.parent.verif()
+ self.node.update()
+ if self.node.item.isvalid():
+ self.node.parent.select()
+ else :
+ commentaire=self.node.item.info_erreur_item()
+ self.parent.appli.affiche_infos(commentaire)
# ----------------------------------------------------------------------------------------
# Méthodes utilisées pour la manipulation des items dans les listes de choix
Supprime la valeur selectionnée de la liste des valeurs et la rajoute
à la liste des choix possibles
"""
- liste_valeurs = self.Liste_valeurs.get_liste()
- liste_valeurs.remove(self.selected_valeur)
- liste_choix = self.node.item.get_definition().into
- liste_choix = substract_list(liste_choix,liste_valeurs)
- self.Liste_valeurs.put_liste(liste_valeurs)
- self.Liste_choix.put_liste(liste_choix)
- self.selected_valeur = None
+ if hasattr(self,'selected_valeur') :
+ if ( self.selected_valeur != None and self.selected_valeur != ''):
+ liste_valeurs = self.Liste_valeurs.get_liste()
+ liste_valeurs.remove(self.selected_valeur)
+ self.Liste_valeurs.put_liste(liste_valeurs)
+ listeActuelle=self.Liste_valeurs.get_liste()
+ liste_choix=self.node.item.get_liste_possible(listeActuelle)
+ self.Liste_choix.put_liste(liste_choix)
+ self.selected_valeur = None
def add_choix(self,name=None):
"""
Ajoute le choix selectionné à la liste des valeurs et le retire
de la liste des choix possibles
"""
- min,max = self.node.item.GetMinMax()
- liste_valeurs = self.Liste_valeurs.get_liste()
- if len(liste_valeurs) >= max :
- self.parent.appli.affiche_infos("La liste ne peut pas avoir plus de %d éléments" %max)
- return
- liste_valeurs.append(self.selected_choix)
- liste_choix = self.Liste_choix.get_liste()
- # liste_choix.remove(self.selected_choix)
- self.Liste_valeurs.put_liste(liste_valeurs)
- self.Liste_choix.put_liste(liste_choix)
- self.selected_choix = None
+
+ if hasattr(self,'selected_choix') :
+ if (self.selected_choix != None and self.selected_choix != ''):
+ min,max = self.node.item.GetMinMax()
+ liste_valeurs = self.Liste_valeurs.get_liste()
+ if len(liste_valeurs) >= max :
+ self.parent.appli.affiche_infos("La liste ne peut pas avoir plus de %d éléments" %max)
+ return
+ liste_valeurs.append(self.selected_choix)
+ self.Liste_valeurs.put_liste(liste_valeurs)
+ listeActuelle=self.Liste_valeurs.get_liste()
+ liste_choix=self.node.item.get_liste_possible(listeActuelle)
+ self.Liste_choix.put_liste(liste_choix)
+ self.selected_choix = None
def selectChoix(self,name):
self.selected_choix = name
valeur = val
else:
valeur = self.node.item.get_valeur()
- if valeur == None : return
+ if valeur == None or valeur == '': return
self.text.insert(END,valeur)
class PLUSIEURS_Panel(newSIMPPanel):
"""
l1_valeurs = self.Liste_valeurs.get_liste()
# PN : remplacement des paramétres par leur nom (cf get_liste)
- #
l_valeurs=[]
for val in l1_valeurs :
+ if val != '' and val != None :
if val.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
v=val.nom
else:
v=val
l_valeurs.append(v)
- print "l_valeurs = ", l_valeurs
longueur = len(l_valeurs)
if longueur < min or longueur > max :
self.parent.appli.affiche_infos("Valeur refusée : nombre d'éléments incorrect dans la liste")
else:
valeur = None
self.parent.appli.affiche_infos("Valeur acceptée")
- print "valeur = " ,valeur
self.record_valeur(valeur)
if self.node.item.isvalid():
self.node.parent.select()
else:
return valeur
- def add_valeur_sans_into(self,name=None):
+ def add_valeur_sans_into(self,name=None,encorevalide=1):
"""
Lit ce que l'utilisateur a saisi dans self.entry et cherche à
l'évaluer :
- si la valeur est acceptable, elle est ajoutée dans la liste des valeurs
- sinon elle est refusée
+ encorevalide vaut 1 si le validateur trouve l item et la liste correctes
+ 0 si le validateur trouve la valeur de l item incorrecte
+ -1 si le validateur trouve la liste incorrecte
"""
- min,max = self.node.item.GetMinMax()
+
+ test1=0
+ test2=0
+ commentaire="Valeur incorrecte : ajout à la liste refusé"
+
if name != None :
- valeur = name
- else:
- valeur = self.get_valeur()
- if self.node.item.wait_reel():
- valeur = self.traite_reel(valeur)
- if self.node.item.wait_geom():
- val,test1 = valeur,1
+ valeur = name
else:
- val,test1 = self.node.item.object.eval_valeur(valeur)
+ valeur = self.get_valeur()
+
+ if (valeur == None or valeur =="") :
+ encorevalide = -2
+ commentaire = "Pas de saisie des valeurs nulles"
+
+ if (encorevalide ==0) :
+ commentaire=self.node.item.info_erreur_item()
+ if (encorevalide == -1) :
+ commentaire=self.node.item.info_erreur_liste()
+ min,max = self.node.item.GetMinMax()
+
+ if (encorevalide == 1) :
+ if self.node.item.wait_reel():
+ valeur = self.traite_reel(valeur)
+ if self.node.item.wait_geom():
+ val,test1 = valeur,1
+ else:
+ #val,test1 = self.node.item.object.eval_valeur(valeur)
+ val,test1 = self.node.item.eval_valeur(valeur)
+
if test1 :
- test2 = self.node.item.object.verif_type(val)
- if test2 :
- liste_valeurs = self.Liste_valeurs.get_liste()
- if len(liste_valeurs) >= max :
- self.parent.appli.affiche_infos("La liste a déjà atteint le nombre maximum d'éléments, ajout refusé")
- self.erase_valeur()
- return
- liste_valeurs.append(val)
- self.Liste_valeurs.put_liste(liste_valeurs)
- self.erase_valeur()
- self.parent.appli.affiche_infos("Nouvelle valeur acceptée")
- else:
- self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé")
- else:
- print "impossible d'évaluer %s" %val
- self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé")
- #if self.node.item.isvalid():
- # self.node.parent.select()
+ test2 = self.node.item.object.verif_type(val)
+
+ if test2 :
+ liste_valeurs = self.Liste_valeurs.get_liste()
+ if len(liste_valeurs) >= max :
+ commentaire="La liste a déjà atteint le nombre maximum d'éléments,ajout refusé"
+ else :
+ liste_valeurs.append(valeur)
+ self.Liste_valeurs.put_liste(liste_valeurs)
+ self.erase_valeur()
+ commentaire="Nouvelle valeur acceptée"
+ else :
+ commentaire ="Type de la valeur incorrecte"
+
+ self.erase_valeur()
+ self.parent.appli.affiche_infos(commentaire)
def sup_valeur_sans_into(self,name=None):
"""
bulle_aide=self.get_bulle_aide()
objet_mc = self.node.item.get_definition()
min,max = self.node.item.GetMinMax()
- l_choix=list(objet_mc.into)
+ #l_choix=list(objet_mc.into)
+ l_valeurs = self.node.item.GetListeValeurs()
+ l_choix= self.node.item.get_liste_possible(l_valeurs)
l_choix.sort()
+ # reinitialisation de l_valeurs
l_valeurs = self.node.item.GetListeValeurs()
+
# remplissage du panneau
self.frame_valeurs = Frame(page)
self.frame_valeurs.place(relx=0.05,rely=0.05,relwidth=0.35,relheight=0.7)
liste_commandes_choix = (("<Button-1>",self.selectChoix),
("<Button-3>",self.deselectChoix),
("<Double-Button-1>",self.add_choix))
- self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,liste_commandes = liste_commandes_valeurs,
+ self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,
+ l_valeurs,liste_commandes = liste_commandes_valeurs,
titre="Valeur(s) actuelle(s)")
- self.Liste_choix = ListeChoix(self,self.frame_choix,l_choix,liste_commandes = liste_commandes_choix,
+ self.Liste_choix = ListeChoix(self,self.frame_choix,l_choix,
+ liste_commandes = liste_commandes_choix,
titre= "Valeurs possibles")
bouton_add = Button(self.frame_boutons_fleches,
#text="<--",
aide = justify_text(texte=aide)
min,max = self.node.item.GetMinMax()
l_valeurs = self.node.item.GetListeValeurs()
+
# création des frames globales
self.frame1 = Frame(page,relief='groove',bd=2)
self.frame2 = Frame(page)
self.frame2.place(relx=0.,rely=0.85,relwidth=1,relheight=0.15)
self.frame_right = Frame(self.frame1)
self.frame_right.place(relx=0.35,rely=0.,relwidth=0.65,relheight=1.)
+
# création des frames internes
self.frame_valeurs = Frame(self.frame1)
self.frame_valeurs.place(relx=0.02,rely=0.05,relwidth=0.35,relheight=0.95)
self.frame_boutons_fleches,self.frame_choix,self.frame_aide,self.frame_boutons):
fram.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
fram.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
+
# création des objets dans les frames
liste_commandes_valeurs = (("<Button-1>",self.selectValeur),
("<Button-3>",self.deselectValeur),
("<Double-Button-1>",self.sup_valeur_sans_into))
self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,liste_commandes = liste_commandes_valeurs,
titre="Valeur(s) actuelle(s)")
+
# Création de l'entry ou de la liste des SD
self.label = Label(self.frame_choix,text="Valeur :")
- self.make_entry(frame = self.frame_choix,command = self.add_valeur_sans_into)
+ # PN : pour ajouter les validators
+ #self.make_entry(frame = self.frame_choix,command = self.add_valeur_sans_into)
+ self.make_entry(frame = self.frame_choix,command = self.add_valeur_plusieurs_base)
self.label.place(relx=0.05,rely=0.5)
+
# Création d'un bouton "Importer ..." sur le panel.
bouton_valeurs_fichier = Button(self.frame_choix,
text="Importer ...",
command=self.select_in_file)
bouton_valeurs_fichier.place(relx=0.28,rely=0.7,relwidth=0.6)
self.ajout_valeurs = None
+
# boutons Ajouter et Supprimer
+ #bouton_add = Button(self.frame_boutons_fleches,
+ # image = images.get_image('arrow_left'),
+ # command = self.add_valeur_sans_into)
bouton_add = Button(self.frame_boutons_fleches,
image = images.get_image('arrow_left'),
- command = self.add_valeur_sans_into)
+ command = self.add_valeur_plusieurs_base)
bouton_sup = Button(self.frame_boutons_fleches,
image = images.get_image('arrow_right'),
command = self.sup_valeur_sans_into)
for but in (bouton_accepter,bouton_annuler):
but.pack(side='left',padx=5)
+ def add_valeur_plusieurs_base(self,name=None):
+ if name != None :
+ valentree = name
+ else:
+ valentree = self.get_valeur()
+ valeur,validite=self.node.item.eval_valeur(valentree)
+ print "EEEEEEE"
+ print valeur
+ print type(valeur)
+ encorevalide=self.node.item.valide_item(valeur)
+ print encorevalide
+ if encorevalide :
+ listecourante=self.Liste_valeurs.get_liste()
+ encorevalide=self.node.item.valide_liste_partielle(valeur,listecourante)
+ if not encorevalide : encorevalide = -1
+ self.add_valeur_sans_into(valeur,encorevalide)
+
def select_in_file(self):
""" Permet d'ouvrir un fichier choisi par l'utilisateur. """
nom_fichier = askopenfilename(title="Choix fichier :")
- si non, restaure l'ancienne valeur
"""
if self.parent.modified == 'n' : self.parent.init_modif()
- valeur = self.get_valeur()
+ valeurentree = self.get_valeur()
self.erase_valeur()
anc_val = self.node.item.get_valeur()
- test = self.node.item.set_valeur(valeur)
+ valeur,test=self.node.item.eval_valeur(valeurentree)
+ if test :
+ test = self.node.item.set_valeur(valeur)
if not test :
mess = "impossible d'évaluer : %s " %`valeur`
self.parent.appli.affiche_infos("Valeur du mot-clé non autorisée :"+mess)
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
- self.record_valeur(anc_val,mess=mess)
+ self.record_old_valeur(anc_val,mess=mess)
class UNIQUE_INTO_Panel(UNIQUE_Panel):
"""
# remplissage du panel
self.frame_valeur = Frame(page)
self.frame_valeur.pack(fill='both',expand=1)
- self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
+ self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide :
+ s.parent.appli.affiche_aide(e,a))
self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
- l_choix=list(objet_mc.into)
- l_choix.sort()
+ #l_choix=list(objet_mc.into)
+ #l_choix.sort()
+ l_choix=self.node.item.get_liste_possible([])
self.label = Label(self.frame_valeur,text='Choisir une valeur :')
self.label.pack(side='top')
self.frame = Frame(page)
liste_commandes = (("<Button-1>",self.selectChoix),
("<Button-3>",self.deselectChoix),
("<Double-Button-1>",self.record_valeur))
- self.Liste_choix = ListeChoix(self,self.frame,l_choix,liste_commandes = liste_commandes,
+ self.Liste_choix = ListeChoix(self,self.frame,l_choix,
+ liste_commandes = liste_commandes,
titre="Valeurs possibles")
self.Liste_choix.affiche_liste()
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
- self.record_valeur(anc_val,mess=mess)
+ self.record_old_valeur(anc_val,mess=mess)
def makeValeurPage(self,page):
"""
Affiche la valeur de l'objet pointé par self
"""
valeur = self.node.item.get_valeur()
- if valeur == None : return # pas de valeur à afficher ...
+ if valeur == None or valeur == '' : return # pas de valeur à afficher ...
self.valeur_choisie.set(valeur.nom)
def erase_valeur(self):
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
- self.record_valeur(anc_val,mess=mess)
+ self.record_old_valeur(anc_val,mess=mess)
return
if self.node.item.get_position()=='global':
self.node.etape.verif_all()
else :
cr = self.node.item.get_cr()
mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
- self.record_valeur(anc_val,mess=mess)
+ self.record_old_valeur(anc_val,mess=mess)
return
if self.node.item.get_position()=='global':
self.node.etape.verif_all()
Affiche la valeur de l'objet pointé par self
"""
valeur = self.node.item.get_valeur()
- if valeur == None : return # pas de valeur à afficher ...
+ if valeur == None or valeur == '' : return # pas de valeur à afficher ...
self.entry.delete(0,END)
self.entry.insert(0,valeur)
self.entry.focus()
if self.wait_shell():
# l'objet attend un shell
self.panel = SHELLPanel
- elif self.wait_into():
+ elif self.has_into():
# l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
- min,max = self.GetMinMax()
- # PN :
- # Remplacement du if ??
- #if max != 1 and ((min != 0 and min != max) or (min == 0)):
- assert (min <= max)
- if max > 1 :
- # l'objet attend une liste de valeurs
+ if self.is_list() :
self.panel = PLUSIEURS_INTO_Panel
else:
- # l'objet n'attend qu'une seule valeur
self.panel = UNIQUE_INTO_Panel
else:
# l'objet prend une ou des valeurs à priori quelconques
- min,max = self.GetMinMax()
- if max != 1 :
+ if self.is_list() :
# on attend une liste de valeurs mais de quel type ?
if self.wait_assd():
# on attend une liste de SD
else:
# on attend un entier, un réel ou une string
self.panel = UNIQUE_BASE_Panel
-
- def SetText(self, text):
- try:
- value = eval(text)
- self.object.setval(value)
- except:
- pass
-
- def GetIconName(self):
- if self.isvalid():
- return "ast-green-ball"
- elif self.object.isoblig():
- return "ast-red-ball"
- else:
- return "ast-yel-ball"
-
- def GetText(self):
- """
- Classe SIMPTreeItem
- Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
- pointé par self
- """
- text= self.object.GetText()
- return text
- def has_into(self):
+ def is_list(self):
"""
- Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
- ou s'il n'en propose pas (valeur de retour 0)
+ Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
+ ou s'il n'en attend pas (valeur de retour 0)
Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
- Dans le cas sans validateur, l'information est donnée par l'attribut into
+ Dans le cas sans validateur, l'information est donnée par l'attribut max
de la definition du mot cle.
Dans le cas avec validateur, il faut combiner l'information précédente avec
- celle issue de l'appel de la méthode has_into sur le validateur. On utilisera
+ celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
l'operateur ET pour effectuer cette combinaison (AndVal).
"""
- if not self.object.definition.validators:
- if self.definition.into:
- return 1
- else:
- return 0
- else:
- # Dans le cas avec validateurs, pour que le mot cle soit considéré
- # comme proposant un choix, il faut que into soit présent OU
- # que la méthode has_into du validateur retourne 1. Dans les autres cas
- # on retournera 0 (ne propose pas de choix)
- if self.definition.into:
- return 1
- elif self.object.definition.validators.has_into():
- return 1
- else:
- return 0
+ is_a_list=0
+ min,max = self.GetMinMax()
+ assert (min <= max)
+ if max > 1 :
+ is_a_list=1
+ # Dans le cas avec validateurs, pour que le mot cle soit considéré
+ # comme acceptant une liste, il faut que max soit supérieur a 1
+ # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
+ # on retournera 0 (n'attend pas de liste)
+ if self.definition.validators :
+ is_a_list= self.definition.validators.is_list() * is_a_list
+ return is_a_list
def get_into(self,liste_courante=None):
"""
return self.object.definition.into
else:
return self.object.definition.validators.get_into(liste_courante,self.definition.into)
-
- def is_list(self):
+
+ def has_into(self):
"""
- Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
- ou s'il n'en attend pas (valeur de retour 0)
+ Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
+ ou s'il n'en propose pas (valeur de retour 0)
Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
- Dans le cas sans validateur, l'information est donnée par l'attribut max
+ Dans le cas sans validateur, l'information est donnée par l'attribut into
de la definition du mot cle.
- Dans le cas avec validateur, il faut combiner l'information précédente avec
- celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
- l'operateur ET pour effectuer cette combinaison (AndVal).
- """
- if not self.object.definition.validators:
- if self.definition.max <= 1:
- return 0
- else:
- return 1
- else:
- # Dans le cas avec validateurs, pour que le mot cle soit considéré
- # comme acceptant une liste, il faut que max soit supérieur a 1
- # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
- # on retournera 0 (n'attend pas de liste)
- if self.definition.max <= 1:
- return 0
- elif not self.object.definition.validators.is_list():
- return 0
- else:
- return 1
+ Dans le cas avec validateurs, pour que le mot cle soit considéré
+ comme proposant un choix, il faut que into soit présent OU
+ que la méthode has_into du validateur retourne 1. Dans les autres cas
+ on retournera 0 (ne propose pas de choix)
+ """
+ has_an_into=0
+ if self.definition.into:
+ has_an_into=1
+ elif self.definition.validators :
+ has_an_into= self.definition.validators.has_into()
+ return has_an_into
+
+ def valide_item(self,item):
+ valide=1
+ if self.definition.validators :
+ valide=self.definition.validators.verif(item)
+ return valide
+
+ def valide_liste_partielle(self,item,listecourante):
+ valeuravant=self.object.valeur
+ valeur=listecourante
+ if (not self.object.wait_TXM()):
+ item=eval(item)
+ valeur.append(item)
+ if len(valeur) > 1 :
+ valeur = tuple(valeur)
+ else :
+ valeur=valeur[0]
+ print valeur
+ retour=self.object.set_valeur(valeur,"non")
+ if self.definition.validators :
+ print self.definition.validators
+ validite=0
+ if self.object.isvalid():
+ validite=1
+ retour=self.object.set_valeur(valeuravant,"non")
+ return validite
+
+ def valide_liste_complete (self,valeur):
+ valide=1
+ return valide
+
+ def info_erreur_item(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.info_erreur_item()
+ return commentaire
+
+ def info_erreur_liste(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.info_erreur_liste()
+ return commentaire
+
+ def SetText(self, text):
+ try:
+ value = eval(text)
+ self.object.setval(value)
+ except:
+ pass
+
+ def GetIconName(self):
+ if self.isvalid():
+ return "ast-green-ball"
+ elif self.object.isoblig():
+ return "ast-red-ball"
+ else:
+ return "ast-yel-ball"
+
+ def GetText(self):
+ """
+ Classe SIMPTreeItem
+ Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
+ pointé par self
+ """
+ text= self.object.GetText()
+ return text
def wait_co(self):
"""
""" Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
de l'objet pointé par self :
- retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
- - retourne 'valeur' (chaîne de caractères) sinon """
- return self.object.eval_valeur(valeur)
+ - retourne 'valeur' (chaîne de caractères) sinon
+ - retourne None en cas d invalidite
+ - retourne invalide si 1 des objets du tuple l est
+ """
+ validite=1
+ if type(valeur) in (types.ListType,types.TupleType) :
+ valeurretour=[]
+ for item in valeur :
+ print "item = ", item
+ print "valeur =" ,valeur
+ newvaleur,validiteitem=self.eval_valeur_item(item)
+ valeurretour.append(newvaleur)
+ if validiteitem == 0:
+ validite=0
+ else :
+ valeurretour,validite= self.eval_valeur_item(valeur)
+ if validite == 0 :
+ valeurretour = None
+ return valeurretour,validite
+
+ def eval_valeur_item(self,valeur):
+ validite=1
+ if self.wait_reel():
+ valeurretour = self.traite_reel(valeur)
+ elif self.wait_geom():
+ valeurretour,validite = valeur,1
+ else :
+ valeurretour,validite= self.object.eval_valeur(valeur)
+ if validite == 0:
+ if types.StringType(valeur) and self.object.wait_TXM():
+ essai_valeur="'" + valeur + "'"
+ valeurretour,validite= self.object.eval_valeur(essai_valeur)
+ if valeur.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ valeurretour=val.nom
+ validite=1
+ if self.wait_co():
+ try:
+ # Pour avoir la classe CO avec tous ses comportements
+ from Accas import CO
+ valeurretour=CO(valeur)
+ except:
+ valeurretour=None
+ validite=0
+ # on est dans le cas où on a évalué et où on n' aurait pas du
+ if self.object.wait_TXM():
+ if type(valeurretour) != 'str':
+ if valeur[0]=="'" and valeur[-1]=="'" :
+ valeurretour=str(valeur)
+ validité=1
+ if 'I' in self.get_definition().type :
+ print " ooooo "
+ if type(valeurretour) == 'str':
+ try :
+ valeurretour=int(valeurretour)
+ validite=1
+ except:
+ valeurretour=None
+ validite=0
+
+ print "XXXXXXXX"
+ print valeur
+ print valeurretour
+ print type(valeurretour)
+ print validite
+ return valeurretour,validite
+
def is_CO(self,valeur=None):
"""
#self.object.etape.parent.del_sdprod(valeur)
self.object.etape.parent.delete_concept(valeur)
+ def get_liste_possible(self,listeActuelle=[]):
+ if hasattr(self.definition.validators,'into'):
+ self.get_definition().into=self.definition.validators.into
+ valeurspossibles = self.get_definition().into
+ listevalideitem=[]
+ for item in valeurspossibles:
+ encorevalide=self.valide_item(item)
+ if encorevalide :
+ listevalideitem.append(item)
+ # on ne verifie pas la liste des choix si max = 1
+ # (sinon cela enleve tous les choix possibles)
+ min,max=self.GetMinMax()
+ if max != 1 :
+ listevalideliste=[]
+ for item in listevalideitem:
+ listetravail=[]
+ for item2 in listeActuelle : listetravail.append(item2)
+ encorevalide=self.valide_liste_partielle(item,listetravail)
+ if encorevalide :
+ listevalideliste.append(item)
+ else :
+ listevalideliste=listevalideitem
+ return listevalideliste
+
+
+
import Accas
treeitem = SIMPTreeItem
objet = Accas.MCSIMP
