-#@ MODIF composimp Editeur DATE 05/09/2001 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
-# SEE THE FILE "LICENSE.TERMS" FOR INFORMATION ON USAGE AND
-# REDISTRIBUTION OF THIS FILE.
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
# ======================================================================
# Modules Python
import string,types,os
nb.setnaturalsize()
# ----------------------------------------------------------------------------------------
-# Méthodes utlisées pour l'affectation de la valeur donnée par l'utilisateur
+# Méthodes utilisées pour l'affectation de la valeur donnée par l'utilisateur
# au mot-clé courant
# ----------------------------------------------------------------------------------------
- def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
+ def reset_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é
+ 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()
- if name != None:
- valeur =name
- else :
- valeur= self.entry.get()
- self.entry.delete(0,END)
- self.node.item.set_valeur(valeur,evaluation='non')
+ 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()
+
+ 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
+ validite = 1
+ else :
+ valeurentree= self.entry.get()
+ self.entry.delete(0,END)
+ if valeurentree == '': valeurentree=None
+ valeur,validite=self.node.item.eval_valeur(valeurentree)
+ if not validite :
+ valeur= self.entry.get()
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.parent.appli.affiche_infos(commentaire)
+
+ if validite :
+ if self.node.item.is_list() :
+ validite=self.node.item.valide_liste_complete(valeur)
+ commentaire=self.node.item.info_erreur_liste()
+ else :
+ validite=self.node.item.valide_item(valeur)
+ commentaire=self.node.item.info_erreur_item()
+
+ if validite :
+ self.node.item.set_valeur(valeur)
+ 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 :
+ self.parent.appli.affiche_infos(commentaire)
+
# ----------------------------------------------------------------------------------------
-# Méthodes utlisées pour la manipulation des items dans les listes de choix
+# Méthodes utilisées pour la manipulation des items dans les listes de choix
# ----------------------------------------------------------------------------------------
def selectValeur(self,name):
self.selected_valeur = name
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
def deselectChoix(self,name):
self.selectChoix = None
+ def raisecmd(self,page):
+ try:
+ self.entry.focus()
+ except:
+ pass
+
class SHELLPanel(newSIMPPanel):
"""
Classe Panel utilisé pour les mots-clés simples qui attendent un shell pour valeur
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):
Méthode qui récupère la liste des valeurs donnée par l'utilisateur
et l'affecte au mot-clé courant.
"""
- l_valeurs = self.Liste_valeurs.get_liste()
+ l1_valeurs = self.Liste_valeurs.get_liste()
+ l_valeurs=[]
+ for val in l1_valeurs :
+ if val != '' and val != None :
+ l_valeurs.append(val)
+
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")
valeur = l_valeurs[0]
else:
valeur = None
+
self.parent.appli.affiche_infos("Valeur acceptée")
self.record_valeur(valeur)
- if self.node.item.isvalid():
- self.node.parent.select()
+ #if self.node.item.isvalid():
+ # self.node.parent.select()
# fermeture de la fenêtre de sélection
if self.ajout_valeurs:
self.ajout_valeurs.quit()
if self.ajout_valeurs:
self.ajout_valeurs.quit()
- def traite_reel(self,valeur):
- """
- Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
- ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
- ou un EVAL ...
- """
- valeur = string.strip(valeur)
- liste_reels = self.node.item.get_sd_avant_du_bon_type()
- if valeur in liste_reels:
- return valeur
- if len(valeur) >= 3 :
- if valeur[0:4] == 'EVAL' :
- # on a trouvé un EVAL --> on retourne directement la valeur
- return valeur
- if string.find(valeur,'.') == -1 :
- # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
- return valeur+'.'
- 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
+ - 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()
+
+ commentaire="Valeur incorrecte : ajout à la liste refusé"
+ testvalide=1
+
+ # Lecture de la zone de saisie et evaluation si nécessaire
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)
- 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()
+ valeurentree = self.get_valeur()
+ if valeurentree == '': valeur=None
+ valeurentree,testvalide=self.node.item.eval_valeur(valeur)
+ if (not testvalide) :
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+
+ # Pas de traitement des valeurs nulles ( a priori clic involontaire
+ if (valeur == None or valeur =="") :
+ commentaire = "Pas de saisie des valeurs nulles"
+ encorevalide = -2
+ testtype=0
+ else :
+ testtype = self.node.item.object.verif_type(valeur)
+ if not testtype :
+ commentaire ="Type de la valeur incorrecte"
+ encorevalide=-2
+
+ if (encorevalide ==0) :
+ commentaire=self.node.item.info_erreur_item()
+ if (encorevalide == -1) :
+ commentaire=self.node.item.info_erreur_liste()
+ # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
+ min,max = self.node.item.GetMinMax()
+ if len(self.Liste_valeurs.get_liste()) >= max :
+ commentaire="La liste a déjà atteint le nombre maximum d'éléments,ajout refusé"
+
+ if testvalide and (encorevalide == 1):
+ min,max = self.node.item.GetMinMax()
+
+ if testtype :
+ 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):
"""
# la valeur sélectionnée n'est pas dans la liste
return
self.Liste_valeurs.put_liste(liste_valeurs)
- #self.display_valeur('')
self.display_valeur(self.selected_valeur)
self.selected_valeur = None
self.ajout_valeurs = None
# On récupère la bulle d'aide du panneau, l'objet, min et max (cardinalité de la liste),
# la liste des choix et la liste des valeurs
+ aide = self.get_aide()
+ aide = justify_text(texte=aide)
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.sort()
+ #l_choix=list(objet_mc.into)
l_valeurs = self.node.item.GetListeValeurs()
+ l_choix= self.node.item.get_liste_possible(l_valeurs)
+ # 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)
self.frame_choix.place(relx=0.6,rely=0.05,relwidth=0.35,relheight=0.7)
self.frame_boutons = Frame(page)
self.frame_boutons.place(relx=0.35,rely=0.87,relwidth=0.3,relheight=0.1)
+ self.frame_aide = Frame(page)
+ self.frame_aide.place(relx=0.1,rely=0.75,relwidth=0.9,relheight=0.1)
liste_commandes_valeurs = (("<Button-1>",self.selectValeur),
("<Button-3>",self.deselectValeur),
("<Double-Button-1>",self.sup_valeur))
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="<--",
for fram in (self.frame_valeurs,self.frame_boutons_fleches,self.frame_choix,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)
+ self.frame_aide.update()
+ self.aide = Label(self.frame_aide,
+ text = aide,
+ justify='center',
+ anchor='center',
+ wraplength=int(self.frame_aide.winfo_width()*0.8))
+ self.aide.place(relx=0.5,rely=0.5,anchor='center',relwidth=1)
+
+ def get_aide(self):
+ """
+ Retourne la phrase d'aide indiquant de quel type de base doivent être les valeurs
+ que saisit l'utilisateur
+ """
+ commentaire=""
+ mc = self.node.item.get_definition()
+ d_aides = { 'TXM' : 'chaînes de caractères',
+ 'R' : 'réels',
+ 'I' : 'entiers',
+ 'C' : 'complexes'}
+ type = mc.type[0]
+ if not d_aides.has_key(type) :
+ if mc.min == mc.max:
+ return str(mc.min)+" valeur(s) est(sont) attendue(s)"
+ else :
+ return "entrez entre "+str(mc.min)+" et "+str(mc.max)+" valeurs"
+ if mc.min == mc.max:
+ commentaire="Une liste de "+str(mc.min)+" "+d_aides[type]+" est attendue"
+ else :
+ commentaire="Entre "+str(mc.min)+" et "+str(mc.max)+" valeurs de type "+d_aides[type]+" sont attendues"
+ aideval=self.node.item.aide()
+ commentaire=commentaire + "\n" + aideval
+ return commentaire
def get_bulle_aide(self):
"""
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_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)
+ 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 :
+ valeur = name
+ else:
+ valeurentree = self.get_valeur()
+ if valeurentree == '': valeur=None
+ valeur,validite=self.node.item.eval_valeur(valeurentree)
+ if not validite :
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.parent.appli.affiche_infos(commentaire)
+ return
+
+ encorevalide=self.node.item.valide_item(valeur)
+ 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 :")
Retourne la phrase d'aide indiquant de quel type de base doivent être les valeurs
que saisit l'utilisateur
"""
+ commentaire=""
mc = self.node.item.get_definition()
d_aides = { 'TXM' : 'chaînes de caractères',
'R' : 'réels',
type = mc.type[0]
if not d_aides.has_key(type) : return 'Type de base inconnu'
if mc.min == mc.max:
- return "Une liste de "+d_aides[type]+" chaînes de caractères est attendue"
+ commentaire="Une liste de "+d_aides[type]+" chaînes de caractères est attendue"
else :
- return "Une liste de "+d_aides[type]+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
+ commentaire="Une liste de "+d_aides[type]+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
+ aideval=self.node.item.aide()
+ commentaire=commentaire +"\n"+aideval
+ return commentaire
def make_entry(self,frame,command):
"""
("<Double-Button-1>",self.sup_valeur_sans_into))
liste_commandes_choix = (("<Button-1>",self.selectChoix),
("<Button-3>",self.deselectChoix),
- ("<Double-Button-1>",self.add_valeur_sans_into))
+ # ("<Double-Button-1>",self.add_valeur_sans_into))
+ ("<Double-Button-1>",self.add_eval_valeur_sans_into))
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,
bouton_add = Button(self.frame_boutons_fleches,
#text="<--",
image = images.get_image('arrow_left'),
- command = self.add_valeur_sans_into)
+ # command = self.add_valeur_sans_into)
+ command = self.add_eval_valeur_sans_into)
bouton_sup = Button(self.frame_boutons_fleches,
#text="-->",
image = images.get_image('arrow_right'),
for fram in (self.frame_valeurs,self.frame_boutons_fleches,self.frame_choix,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)
+
+ def add_eval_valeur_sans_into(self,valeurentree=None):
+ valeur,validite=self.node.item.eval_valeur(valeurentree)
+ if not validite :
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.parent.appli.affiche_infos(commentaire)
+ return
+ self.add_valeur_sans_into(valeur)
def get_bulle_aide(self):
"""
Retourne la phrase d'aide indiquant de quel type doivent être les
valeurs que doit entrer l'utilisateur
"""
+ commentaire=""
mc = self.node.item.get_definition()
type = mc.type[0].__name__
if len(mc.type)>1 :
for typ in mc.type[1:] :
type = type + ' ou '+typ.__name__
if mc.min == mc.max:
- return "Une liste de "+`mc.min`+" objets de type "+type+" est attendue"
+ commentaire="Une liste de "+`mc.min`+" objets de type "+type+" est attendue"
else :
- return "Une liste d'objets de type "+type+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
+ commentaire="Une liste d'objets de type "+type+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
+ aideval=self.node.item.aide()
+ commentaire=commentaire +"\n"+ aideval
+ return commentaire
+
def sup_valeur(self,name=None):
"""
- si non, restaure l'ancienne valeur
"""
if self.parent.modified == 'n' : self.parent.init_modif()
- valeur = self.get_valeur()
- self.erase_valeur()
anc_val = self.node.item.get_valeur()
+ valeurentree = self.get_valeur()
+ self.erase_valeur()
+ valeur,validite=self.node.item.eval_valeur(valeurentree)
+ if not validite :
+ commentaire = "impossible d'évaluer : %s " %`valeurentree`
+ self.parent.appli.affiche_infos(commentaire)
+ return
+
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)
+ self.parent.appli.affiche_infos("Valeur du mot-clé non autorisée : "+mess)
elif self.node.item.isvalid() :
self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
if self.node.item.get_position()=='global':
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.reset_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()
Classe servant à définir le panneau associé aux objets qui attendent une valeur unique
d'un type dérivé d'ASSD
"""
+ def valid_valeur_automatique(self):
+ """
+ Réalise la validation d'un concept sans remonter dans le
+ node parent dans le cas ou il n'y a qu'un concept possible (liste de longueur 1)
+ Identique à valid_valeur moins appel de self.node.parent.select()
+ On pourrait supposer que le seul concept présent est valide et donc ne pas
+ réaliser tous les tests de vérification.
+ """
+ if self.parent.modified == 'n' : self.parent.init_modif()
+ valeur = self.get_valeur()
+ self.erase_valeur()
+ anc_val = self.node.item.get_valeur()
+ valeur,validite=self.node.item.eval_valeur_item(valeur)
+ 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)
+ elif self.node.item.isvalid() :
+ self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
+ 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()
+ else :
+ cr = self.node.item.get_cr()
+ mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
+ self.reset_old_valeur(anc_val,mess=mess)
+
def makeValeurPage(self,page):
"""
Génère la page de saisie de la valeur du mot-clé simple courant qui doit être une
# Remplissage du panneau
self.valeur_choisie = StringVar()
self.valeur_choisie.set('')
+ min,max = self.node.item.GetMinMax()
+ if (min == 1 and min == max and len(liste_noms_sd)==1):
+ if self.valeur_choisie.get() != liste_noms_sd[0]:
+ self.valeur_choisie.set(liste_noms_sd[0])
+ self.valid_valeur_automatique()
+
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))
if len(mc.type)>1 :
for typ in mc.type[1:] :
type = type + ' ou '+typ.__name__
- return "Un objet de type "+type+" est attendu"
+ commentaire="Un objet de type "+type+" est attendu"
+ aideval=self.node.item.aide()
+ commentaire=commentaire +"\n"+ aideval
+ return commentaire
+
def select_valeur_from_list(self):
"""
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.reset_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.reset_old_valeur(anc_val,mess=mess)
return
if self.node.item.get_position()=='global':
self.node.etape.verif_all()
self.entry_co.focus()
elif new_concept == 'NON':
# On est passe de OUI à NON, on supprime la valeur
- self.node.item.delete_valeur_co()
- self.record_valeur(name=None,mess="Suppression CO enregistrée")
- self.label_co.place_forget()
- self.entry_co.place_forget()
- self.l_resu.place(relx=0.05,rely=0.7)
- self.label_valeur.place(relx=0.45,rely=0.7)
+# PN correction de bug (on passe de non a non et cela supprime la valeur)
+# ajout du if de le ligne suivane
+ if self.node.item.is_CO():
+ self.node.item.delete_valeur_co()
+ self.record_valeur(name=None,mess="Suppression CO enregistrée")
+ self.label_co.place_forget()
+ self.entry_co.place_forget()
+ self.l_resu.place(relx=0.05,rely=0.7)
+ self.label_valeur.place(relx=0.45,rely=0.7)
def display_valeur(self):
"""
'R' : "Un réel est attendu",
'I' : "Un entier est attendu"}
type = mc.type[0]
- return d_aides.get(type,"Type de base inconnu")
+ commentaire=d_aides.get(type,"Type de base inconnu")
+ aideval=self.node.item.aide()
+ commentaire=commentaire +"\n"+ aideval
+ return commentaire
def get_bulle_aide(self):
"""
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()
class UNIQUE_COMP_Panel(UNIQUE_Panel):
"""
wraplength=int(self.frame_valeur.winfo_width()*0.8),
justify='center')
self.aide.place(relx=0.5,rely=0.7,anchor='n')
+ # affichage de la valeur du MCS
+ self.display_valeur()
+
+ def display_valeur(self):
+ """
+ Affiche la valeur de l'objet pointé par self
+ """
+ valeur = self.node.item.get_valeur()
+ if valeur == None or valeur == '' : return # pas de valeur à afficher ...
+ typ_cplx,x1,x2=valeur
+ self.entry1.delete(0,END)
+ self.entry2.delete(0,END)
+ self.typ_cplx.set(typ_cplx)
+ self.entry1.setentry(x1)
+ self.entry2.setentry(x2)
def get_bulle_aide(self):
"""
Retourne la phrase d'aide décrivant le type de la valeur que peut prendre
le mot-clé simple courant
"""
- return 'Un complexe est attendu'
+ commentaire='Un complexe est attendu'
+ aideval=self.node.item.aide()
+ commentaire=commentaire +"\n"+ aideval
+ return commentaire
def get_valeur(self):
"""
Cette méthode attribue le panel à l'objet pointé par self en fonction de la
nature de la valeur demandée pour cet objet
"""
+ #print "affect_panel : ",self.nom,self.is_list(),self.has_into(), self.get_into(None)
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()
- if max != 1 and ((min != 0 and min != max) or (min == 0)):
- # 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
+ #print "affect_panel : ",self.panel
+
+ def is_list(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)
+
+ 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
+ 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).
+ """
+ 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):
+ """
+ Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
+ pas de liste de choix, la méthode retourne None.
+ L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déjà
+ effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
+ en en tenant compte.
+ Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
+ une relation de type ET (AndVal).
+ """
+ if not self.object.definition.validators :
+ return self.object.definition.into
+ else:
+ return self.object.definition.validators.get_into(liste_courante,self.definition.into)
+
+ def has_into(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)
+
+ 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
+ de la definition du mot cle.
+ 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):
+ """
+ On fait un try except pour les erreurs de types (exple
+ on rentre 1 pour une chaine de caracteres
+ """
+ valide=1
+ if self.definition.validators :
+ try :
+ valide=self.definition.validators.verif_item(item)
+ except :
+ valide = 0
+ return valide
+
+ def valide_liste_partielle(self,item,listecourante):
+ valeuravant=self.object.valeur
+ valeur=listecourante
+ valeur.append(item)
+ valeur = tuple(valeur)
+ retour=self.object.set_valeur(valeur)
+ validite=0
+ if self.object.isvalid():
+ validite=1
+ elif self.definition.validators :
+ validite=self.definition.validators.valide_liste_partielle(valeur)
+
+ if validite==0:
+ min,max=self.GetMinMax()
+ if len(valeur) < min :
+ validite=1
+ retour=self.object.set_valeur(valeuravant)
+ return validite
+
+ def valide_liste_complete (self,valeur):
+ valeuravant=self.object.valeur
+ retour=self.object.set_valeur(valeur)
+ validite=0
+ if self.object.isvalid():
+ validite=1
+ retour=self.object.set_valeur(valeuravant)
+ return validite
+
+ def info_erreur_item(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.info_erreur_item()
+ return commentaire
+ def aide(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.aide()
+ 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)
Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
pointé par self
"""
- return self.object.GetText()
+ text= self.object.GetText()
+ return text
def wait_co(self):
"""
Retourne la liste des noms des SD présentes avant l'étape qui contient
le MCS pointé par self et du type requis par ce MCS
"""
+ a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
return self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,
self.object.definition.type)
pass
def isvalid(self):
+ valide=self.object.isvalid()
return self.object.isvalid()
def eval_valeur(self,valeur):
""" 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 :
+ 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):
+ if valeur==None or valeur == "" :
+ return None,0
+ validite=1
+ if self.wait_reel():
+ valeurinter = self.traite_reel(valeur)
+ valeurretour,validite= self.object.eval_valeur(valeurinter)
+ elif self.wait_geom():
+ valeurretour,validite = valeur,1
+ else :
+ valeurretour,validite= self.object.eval_valeur(valeur)
+ if validite == 0:
+ if type(valeur) == types.StringType and self.object.wait_TXM():
+ essai_valeur="'" + valeur + "'"
+ valeurretour,validite= self.object.eval_valeur(essai_valeur)
+ if hasattr(valeurretour,'__class__'):
+ if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ validite=1
+ if self.wait_co():
+ try:
+ valeurretour=Accas.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) != types.StringType:
+ valeurretour=str(valeur)
+ validite=1
+
+ return valeurretour,validite
+
def is_CO(self,valeur=None):
"""
# et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
if not valeur:valeur=self.object.valeur
if valeur in self.object.etape.sdprods:return 1
- if type(valeur) is not types.ClassType:return 0
+ if type(valeur) is not types.InstanceType:return 0
if valeur.__class__.__name__ == 'CO':return 1
return 0
#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
+ # CCAR : Ne serait-il pas preferable d'appeler get_into ?
+ #valeurspossibles=self.get_into(listeActuelle)
+
+ 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
+
+ def traite_reel(self,valeur):
+ """
+ Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
+ ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
+ ou un EVAL ...
+ """
+ valeur = string.strip(valeur)
+ liste_reels = self.get_sd_avant_du_bon_type()
+ if valeur in liste_reels:
+ return valeur
+ if len(valeur) >= 3 :
+ if valeur[0:4] == 'EVAL' :
+ # on a trouvé un EVAL --> on retourne directement la valeur
+ return valeur
+ if string.find(valeur,'.') == -1 :
+ # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
+ return valeur+'.'
+ else:
+ return valeur
+
+
import Accas
treeitem = SIMPTreeItem
objet = Accas.MCSIMP
