Editeur/composimp.py

   1 #@ MODIF composimp Editeur  DATE 05/09/2001   AUTEUR DURAND C.DURAND
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
   5 #              SEE THE FILE "LICENSE.TERMS" FOR INFORMATION ON USAGE AND
   6 #              REDISTRIBUTION OF THIS FILE.
   7 # ======================================================================
   8 # Modules Python
   9 import string,types,os
  10 from Tkinter import *
  11 import Pmw
  12 from tkFileDialog import *
  13 from tkMessageBox import showinfo
  14 from copy import copy,deepcopy
  15 import traceback
  16
  17 # Modules Eficas
  18 import Objecttreeitem
  19 import prefs
  20 import panels
  21 import images
  22 from widgets import ListeChoix
  23 from widgets import FenetreDeSelection
  24
  25 from Noyau.N_CR import justify_text
  26 from utils import substract_list
  27
  28
  29 class newSIMPPanel(panels.OngletPanel):
  30   """
  31   Classe virtuelle servant de classe mère à toutes les classes Panel
  32   servant à afficher et récupérer la valeur d'un mot-clé simple.
  33   Le panel est différent suivant le type de la valeur attendu
  34   """
  35   def init(self):
  36       """
  37       Méthode appelée par le constructeur de OngletPanel :
  38       construit le notebook à 2 onglets utilisé par tous les panels de
  39       tous les mots-clés simples
  40       """
  41       nb = Pmw.NoteBook(self,raisecommand=self.raisecmd)
  42       nb.pack(fill = 'both', expand = 1)
  43       self.nb=nb
  44       nb.add('Valeur', tab_text='Saisir valeur')
  45       #nb.add('Commentaire',tab_text='Insérer commentaire')
  46       self.makeValeurPage(nb.page('Valeur'))
  47       #self.makeCommentairePage(nb.page("Commentaire"))
  48       nb.setnaturalsize()
  49
  50 # ----------------------------------------------------------------------------------------
  51 #   Méthodes utlisées pour l'affectation de la valeur donnée par l'utilisateur
  52 #    au mot-clé courant
  53 # ----------------------------------------------------------------------------------------
  54
  55   def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
  56       """
  57           Enregistre  val comme valeur de self.node.item.object SANS
  58           faire de test de validité
  59       """
  60       if self.parent.modified == 'n' : self.parent.init_modif()
  61       if name != None:
  62           valeur =name
  63       else :
  64           valeur= self.entry.get()
  65           self.entry.delete(0,END)
  66       self.node.item.set_valeur(valeur,evaluation='non')
  67       self.parent.appli.affiche_infos(mess)
  68       if self.node.item.get_position()=='global':
  69           self.node.etape.verif_all()
  70       elif self.node.item.get_position()=='global_jdc':
  71           self.node.racine.verif_all()
  72       else :
  73           self.node.parent.verif()
  74       self.node.update()
  75       if self.node.item.isvalid():
  76           self.node.parent.select()
  77 # ----------------------------------------------------------------------------------------
  78 #   Méthodes utlisées pour la manipulation des items dans les listes de choix
  79 # ----------------------------------------------------------------------------------------
  80   def selectValeur(self,name):
  81       self.selected_valeur = name
  82
  83   def deselectValeur(self,name):
  84       self.selectValeur = None
  85
  86   def sup_valeur(self,name=None):
  87       """
  88       Supprime la valeur selectionnée de la liste des valeurs et la rajoute
  89       à la liste des choix possibles
  90       """
  91       liste_valeurs = self.Liste_valeurs.get_liste()
  92       liste_valeurs.remove(self.selected_valeur)
  93       liste_choix = self.node.item.get_definition().into
  94       liste_choix = substract_list(liste_choix,liste_valeurs)
  95       self.Liste_valeurs.put_liste(liste_valeurs)
  96       self.Liste_choix.put_liste(liste_choix)
  97       self.selected_valeur = None
  98
  99   def add_choix(self,name=None):
 100       """
 101       Ajoute le choix selectionné à la liste des valeurs et le retire
 102       de la liste des choix possibles
 103       """
 104       min,max = self.node.item.GetMinMax()
 105       liste_valeurs = self.Liste_valeurs.get_liste()
 106       if len(liste_valeurs) >= max :
 107           self.parent.appli.affiche_infos("La liste ne peut pas avoir plus de %d éléments" %max)
 108           return
 109       liste_valeurs.append(self.selected_choix)
 110       liste_choix = self.Liste_choix.get_liste()
 111       liste_choix.remove(self.selected_choix)
 112       self.Liste_valeurs.put_liste(liste_valeurs)
 113       self.Liste_choix.put_liste(liste_choix)
 114       self.selected_choix = None
 115
 116   def selectChoix(self,name):
 117       self.selected_choix = name
 118
 119   def deselectChoix(self,name):
 120       self.selectChoix = None
 121
 122 class SHELLPanel(newSIMPPanel):
 123   """
 124   Classe Panel utilisé pour les mots-clés simples qui attendent un shell pour valeur
 125   """
 126
 127   def makeValeurPage(self,page):
 128       """
 129       Affiche la page concernant l'objet pointé par self qui attend un shell
 130       """
 131       objet_mc = self.node.item.get_definition()
 132       aide = self.gen_aide()
 133       aide = justify_text(texte=aide)
 134       self.frame = Frame(page)
 135       self.frame.place(relx=0,rely=0,relwidth=1,relheight=1)
 136       label_aide = Label(self.frame,text = aide)
 137       label_aide.place(relx=0.5,rely=0.1,anchor='center')
 138       self.text = Text(self.frame,bg='gray95')
 139       self.text.place(relx=0.2,rely=0.2,relwidth=0.6,relheight=0.6)
 140       but_val = Button(self.frame,text='Valider',command = self.valide_shell)
 141       but_ann = Button(self.frame,text='Annuler',command = self.annule_shell)
 142       but_val.place(relx=0.35,rely=0.9,anchor='center')
 143       but_ann.place(relx=0.65,rely=0.9,anchor='center')
 144       self.display_valeur()
 145
 146   def gen_aide(self):
 147       """
 148       Retourne une chaîne de caractères d'aide sur la valeur qu'attend l'objet
 149       pointé par self
 150       """
 151       return "Un shell est attendu"
 152
 153   def valide_shell(self,event=None):
 154       """
 155       Récupère la valeur saisie par l'utilisateur dans self.text
 156       et la stocke dans l'objet MCSIMP courant
 157       """
 158       texte = self.text.get(1.0,END)
 159       self.record_valeur(texte)
 160
 161   def annule_shell(self,event=None):
 162       """
 163       Annule toute saisie dans self.text
 164       """
 165       self.text.delete(0,END)
 166
 167   def display_valeur(self,val=None):
 168       """
 169       Affiche la valeur de l'objet pointé par self
 170       """
 171       if val != None :
 172           valeur = val
 173       else:
 174           valeur = self.node.item.get_valeur()
 175       if valeur == None : return
 176       self.text.insert(END,valeur)
 177
 178 class PLUSIEURS_Panel(newSIMPPanel):
 179   """
 180   Classe virtuelle servant de classe mère à toutes celles définissant
 181   un panneau pour un mot-clé simple qui attend une liste de valeurs
 182   """
 183   def accepte_modifs_valeur(self,min,max):
 184       """
 185       Méthode qui récupère la liste des valeurs donnée par l'utilisateur
 186       et l'affecte au mot-clé courant.
 187       """
 188       l_valeurs = self.Liste_valeurs.get_liste()
 189       longueur = len(l_valeurs)
 190       if longueur < min or longueur > max :
 191           self.parent.appli.affiche_infos("Valeur refusée : nombre d'éléments incorrect dans la liste")
 192           return
 193       if longueur > 1:
 194          valeur = tuple(l_valeurs)
 195       elif longueur == 1:
 196          valeur = l_valeurs[0]
 197       else:
 198          valeur = None
 199       self.parent.appli.affiche_infos("Valeur acceptée")
 200       self.record_valeur(valeur)
 201       if self.node.item.isvalid():
 202           self.node.parent.select()
 203       # fermeture de la fenêtre de sélection
 204       if self.ajout_valeurs:
 205           self.ajout_valeurs.quit()
 206
 207   def annule_modifs_valeur(self):
 208       """
 209       RAZ de la liste des valeurs (annule toutes les valeurs saisies par l'utilisateur)
 210       """
 211       self.node.select()
 212       # fermeture de la fenêtre de sélection
 213       if self.ajout_valeurs:
 214           self.ajout_valeurs.quit()
 215
 216   def traite_reel(self,valeur):
 217       """
 218       Cette fonction a pour but de rajouter le '.' en fin de chaîne pour un réel
 219       ou de détecter si on fait référence à un concept produit par DEFI_VALEUR
 220       ou un EVAL ...
 221       """
 222       valeur = string.strip(valeur)
 223       liste_reels = self.node.item.get_sd_avant_du_bon_type()
 224       if valeur in liste_reels:
 225           return valeur
 226       if len(valeur) >= 3 :
 227           if valeur[0:4] == 'EVAL' :
 228               # on a trouvé un EVAL --> on retourne directement la valeur
 229               return valeur
 230       if string.find(valeur,'.') == -1 :
 231           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un à la fin
 232           return valeur+'.'
 233       else:
 234           return valeur
 235
 236   def add_valeur_sans_into(self,name=None):
 237       """
 238       Lit ce que l'utilisateur a saisi dans self.entry et cherche à
 239       l'évaluer :
 240       - si la valeur est acceptable, elle est ajoutée dans la liste des valeurs
 241       - sinon elle est refusée
 242       """
 243       min,max = self.node.item.GetMinMax()
 244       if name != None :
 245           valeur = name
 246       else:
 247           valeur = self.get_valeur()
 248       if self.node.item.wait_reel():
 249           valeur = self.traite_reel(valeur)
 250       if self.node.item.wait_geom():
 251           val,test1 = valeur,1
 252       else:
 253           val,test1 = self.node.item.object.eval_valeur(valeur)
 254       if test1 :
 255           test2 = self.node.item.object.verif_type(val)
 256           if test2 :
 257               liste_valeurs = self.Liste_valeurs.get_liste()
 258               if len(liste_valeurs) >= max :
 259                   self.parent.appli.affiche_infos("La liste a déjà atteint le nombre maximum d'éléments, ajout refusé")
 260                   self.erase_valeur()
 261                   return
 262               liste_valeurs.append(val)
 263               self.Liste_valeurs.put_liste(liste_valeurs)
 264               self.erase_valeur()
 265               self.parent.appli.affiche_infos("Nouvelle valeur acceptée")
 266           else:
 267               self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé")
 268       else:
 269           print "impossible d'évaluer %s" %val
 270           self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé")
 271       #if self.node.item.isvalid():
 272       #    self.node.parent.select()
 273
 274   def sup_valeur_sans_into(self,name=None):
 275       """
 276       Méthode qui sert à retirer de la liste des valeurs la valeur sélectionnée
 277       """
 278       liste_valeurs = self.Liste_valeurs.get_liste()
 279       try:
 280           liste_valeurs.remove(self.selected_valeur)
 281       except:
 282           # la valeur sélectionnée n'est pas dans la liste
 283           return
 284       self.Liste_valeurs.put_liste(liste_valeurs)
 285       #self.display_valeur('')
 286       self.display_valeur(self.selected_valeur)
 287       self.selected_valeur = None
 288
 289   def display_valeur(self,val=None):
 290       """
 291       Affiche la valeur passée en argument dans l'entry de saisie.
 292       Par défaut affiche la valeur du mot-clé simple
 293       """
 294       if not val :
 295           valeur = self.node.item.getval()
 296       else:
 297           valeur = val
 298       self.entry.delete(0,END)
 299       if not valeur : return
 300       self.entry.insert(0,str(valeur))
 301
 302
 303 class PLUSIEURS_INTO_Panel(PLUSIEURS_Panel):
 304   """
 305   Classe servant à définir le panneau permettant d'afficher et de saisir une
 306   liste de valeurs à choisir parmi une liste discrètes de valeurs possibles
 307   """
 308   def makeValeurPage(self,page):
 309       """
 310       Génère la page de saisie de plusieurs valeurs parmi un ensemble discret
 311       de possibles
 312       """
 313       self.ajout_valeurs = None
 314       # On récupère la bulle d'aide du panneau, l'objet, min et max (cardinalité de la liste),
 315       # la liste des choix et la liste des valeurs
 316       bulle_aide=self.get_bulle_aide()
 317       objet_mc = self.node.item.get_definition()
 318       min,max = self.node.item.GetMinMax()
 319       l_choix=list(objet_mc.into)
 320       l_choix.sort()
 321       l_valeurs = self.node.item.GetListeValeurs()
 322       # remplissage du panneau
 323       self.frame_valeurs = Frame(page)
 324       self.frame_valeurs.place(relx=0.05,rely=0.05,relwidth=0.35,relheight=0.7)
 325       self.frame_boutons_fleches = Frame(page)
 326       self.frame_boutons_fleches.place(relx=0.4,rely=0.,relwidth=0.2,relheight=0.7)
 327       self.frame_choix = Frame(page)
 328       self.frame_choix.place(relx=0.6,rely=0.05,relwidth=0.35,relheight=0.7)
 329       self.frame_boutons = Frame(page)
 330       self.frame_boutons.place(relx=0.35,rely=0.87,relwidth=0.3,relheight=0.1)
 331       liste_commandes_valeurs = (("<Button-1>",self.selectValeur),
 332                                  ("<Button-3>",self.deselectValeur),
 333                                  ("<Double-Button-1>",self.sup_valeur))
 334       liste_commandes_choix = (("<Button-1>",self.selectChoix),
 335                                ("<Button-3>",self.deselectChoix),
 336                                ("<Double-Button-1>",self.add_choix))
 337       self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,liste_commandes = liste_commandes_valeurs,
 338                                       titre="Valeur(s) actuelle(s)")
 339       self.Liste_choix = ListeChoix(self,self.frame_choix,l_choix,liste_commandes = liste_commandes_choix,
 340                                     titre= "Valeurs possibles")
 341       bouton_add = Button(self.frame_boutons_fleches,
 342                           #text="<--",
 343                           image = images.get_image('arrow_left'),
 344                           command = self.add_choix)
 345       bouton_sup = Button(self.frame_boutons_fleches,
 346                           #text="-->",
 347                           image = images.get_image('arrow_right'),
 348                           command = self.sup_valeur)
 349       bouton_accepter = Button(self.frame_boutons,
 350                                text='Valider',
 351                                command = lambda s=self,m=min,M=max : s.accepte_modifs_valeur(m,M))
 352       bouton_annuler = Button(self.frame_boutons,
 353                               text = 'Annuler',
 354                               command = self.annule_modifs_valeur)
 355       bouton_add.place(relx=0.3,rely=0.35)
 356       bouton_sup.place(relx=0.3,rely=0.65)
 357       for but in (bouton_accepter,bouton_annuler):
 358           but.pack(side='left',padx=5)
 359       self.Liste_valeurs.affiche_liste()
 360       self.Liste_choix.affiche_liste()
 361       for fram in (self.frame_valeurs,self.frame_boutons_fleches,self.frame_choix,self.frame_boutons):
 362           fram.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 363           fram.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 364
 365   def get_bulle_aide(self):
 366       """
 367       Retourne la bulle d'aide du panneau (affichée par clic droit)
 368       """
 369       return """Un clic sur une valeur des deux listes la sélectionne.
 370       - Un clic sur la flèche gauche stocke la valeur possible sélectionnée
 371       dans la liste des valeurs que vous voulez affecter au mot-clé simple
 372       - Un clic sur la flèche droite déstocke la valeur du mot-clé simple
 373       sélectionnée (elle apparaît alors à nouveau comme choix possible
 374       dans la liste des choix à droite)
 375       - Cliquez sur 'Valider' pour affecter la liste des valeurs sélectionnées
 376       au mot-clé simple courant
 377       - Cliquez sur 'Annuler' pour restaurer la valeur du mot-clé simple
 378       avant toute modification depuis le dernier 'Valider'"""
 379
 380 class PLUSIEURS_BASE_Panel(PLUSIEURS_Panel):
 381   """
 382   Classe définissant le panel associé aux mots-clés qui demandent
 383   à l'utilisateur de donner une liste de valeurs qui ne sont pas
 384   à choisir dans une liste discrètes et qui sont de type de base :
 385   entier, réel, string,...
 386   """
 387   def makeValeurPage(self,page):
 388       """
 389       Crée la page de saisie d'une liste de valeurs à priori quelconques,
 390       cad qui ne sont  pas à choisir dans une liste prédéfinie
 391       """
 392       # On récupère la bulle d'aide du panneau, l'objet, l'aide,min et max (cardinalité de la liste),
 393       # et la liste des valeurs déjà affectées à l'objet courant
 394       bulle_aide=self.get_bulle_aide()
 395       objet_mc = self.node.item.get_definition()
 396       aide = self.get_aide()
 397       aide = justify_text(texte=aide)
 398       min,max = self.node.item.GetMinMax()
 399       l_valeurs = self.node.item.GetListeValeurs()
 400       # création des frames globales
 401       self.frame1 = Frame(page,relief='groove',bd=2)
 402       self.frame2 = Frame(page)
 403       self.frame1.place(relx=0.,rely=0.,relwidth=1.,relheight=0.85)
 404       self.frame2.place(relx=0.,rely=0.85,relwidth=1,relheight=0.15)
 405       self.frame_right = Frame(self.frame1)
 406       self.frame_right.place(relx=0.35,rely=0.,relwidth=0.65,relheight=1.)
 407       # création des frames internes
 408       self.frame_valeurs = Frame(self.frame1)
 409       self.frame_valeurs.place(relx=0.02,rely=0.05,relwidth=0.35,relheight=0.95)
 410       self.frame_boutons_fleches = Frame(self.frame_right)
 411       self.frame_boutons_fleches.place(relx=0.,rely=0.2,relwidth=0.2,relheight=0.5)
 412       self.frame_choix = Frame(self.frame_right)
 413       self.frame_choix.place(relx=0.2,rely=0.2,relwidth=0.7,relheight=0.5)
 414       self.frame_aide = Frame(self.frame_right)
 415       self.frame_aide.place(relx=0.1,rely=0.7,relwidth=0.8,relheight=0.3)
 416       self.frame_boutons = Frame(self.frame2)
 417       self.frame_boutons.place(relx=0.35,rely=0.,relwidth=0.3,relheight=1.)
 418       for fram in (self.frame1,self.frame2,self.frame_right,self.frame_valeurs,
 419                  self.frame_boutons_fleches,self.frame_choix,self.frame_aide,self.frame_boutons):
 420           fram.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 421           fram.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 422       # création des objets dans les frames
 423       liste_commandes_valeurs = (("<Button-1>",self.selectValeur),
 424                                  ("<Button-3>",self.deselectValeur),
 425                                  ("<Double-Button-1>",self.sup_valeur_sans_into))
 426       self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,liste_commandes = liste_commandes_valeurs,
 427                                       titre="Valeur(s) actuelle(s)")
 428       # Création de l'entry ou de la liste des SD
 429       self.label = Label(self.frame_choix,text="Valeur :")
 430       self.make_entry(frame = self.frame_choix,command = self.add_valeur_sans_into)
 431       self.label.place(relx=0.05,rely=0.5)
 432       # Création d'un bouton "Importer ..." sur le panel.
 433       bouton_valeurs_fichier = Button(self.frame_choix,
 434                                       text="Importer ...",
 435                                       command=self.select_in_file)
 436       bouton_valeurs_fichier.place(relx=0.28,rely=0.7,relwidth=0.6)
 437       self.ajout_valeurs = None
 438       # boutons Ajouter et Supprimer
 439       bouton_add = Button(self.frame_boutons_fleches,
 440                           image = images.get_image('arrow_left'),
 441                           command = self.add_valeur_sans_into)
 442       bouton_sup = Button(self.frame_boutons_fleches,
 443                           image = images.get_image('arrow_right'),
 444                           command = self.sup_valeur_sans_into)
 445       bouton_add.place(relx=0.3,rely=0.35)
 446       bouton_sup.place(relx=0.3,rely=0.65)
 447       # affichage de l'aide
 448       self.frame_aide.update()
 449       self.aide = Label(self.frame_aide,
 450                         text = aide,
 451                         justify='center',
 452                         anchor='center',
 453                         wraplength=int(self.frame_aide.winfo_width()*0.8))
 454       self.aide.place(relx=0.5,rely=0.5,anchor='center',relwidth=1)
 455       self.Liste_valeurs.affiche_liste()
 456       # boutons Accepter et Annuler
 457       bouton_accepter = Button(self.frame_boutons,
 458                                text='Valider',
 459                                command = lambda s=self,m=min,M=max : s.accepte_modifs_valeur(m,M))
 460       bouton_annuler = Button(self.frame_boutons,
 461                               text = 'Annuler',
 462                               command = self.annule_modifs_valeur)
 463       for but in (bouton_accepter,bouton_annuler):
 464           but.pack(side='left',padx=5)
 465
 466   def select_in_file(self):
 467       """ Permet d'ouvrir un fichier choisi par l'utilisateur. """
 468       nom_fichier = askopenfilename(title="Choix fichier :")
 469       if nom_fichier == "":
 470           return
 471       try:
 472           f = open(nom_fichier, "rb")
 473           selection_texte = f.read()
 474           f.close()
 475           self.ajout_valeurs = FenetreDeSelection(self, self.node.item,
 476                                          titre="Sélection de valeurs",
 477                                          texte=selection_texte)
 478       except:
 479           showinfo("Erreur de fichier","impossible d'ouvir le fichier "+nom_fichier)
 480
 481   def get_bulle_aide(self):
 482       """
 483       Retourne l'aide associée au panneau courant
 484       """
 485       return """Taper dans la boîte de saisie de droite la valeur que
 486       vous voulez affecter au mot-clé simple.
 487       - Cliquez sur la flèche gauche ou pressez <Return> pour la faire glisser
 488       dans la liste des valeurs que vous voulez affecter au mot-clé simple
 489       - Un clic sur une valeur de la liste la sélectionne
 490       - Un clic sur la flèche droite ou un double-clic retire la valeur
 491       sélectionnée de la liste
 492       - Cliquez sur 'Valider' pour que la nouvelle valeur désirée soit affectée
 493       au mot-clé simple
 494       - Cliquez sur 'Annuler' pour annuler toutes les modifications faites
 495       depuis le dernier clic sur 'Valider'"""
 496
 497   def get_aide(self):
 498       """
 499       Retourne la phrase d'aide indiquant de quel type de base doivent être les valeurs
 500       que saisit l'utilisateur
 501       """
 502       mc = self.node.item.get_definition()
 503       d_aides = { 'TXM' : 'chaînes de caractères',
 504                   'R'   : 'réels',
 505                   'I'   : 'entiers',
 506                   'C'   : 'complexes'}
 507       type = mc.type[0]
 508       if not d_aides.has_key(type) : return 'Type de base inconnu'
 509       if mc.min == mc.max:
 510           return "Une liste de "+d_aides[type]+" chaînes de caractères est attendue"
 511       else :
 512           return "Une liste de "+d_aides[type]+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
 513
 514   def make_entry(self,frame,command):
 515       """
 516       Crée l'entry de saisie de la valeur souhaitée : distingue le
 517       cas d'un complexe attendu, d'une autre valeur quelconque
 518       """
 519       if self.node.item.wait_complex():
 520           self.typ_cplx=StringVar()
 521           self.typ_cplx.set('RI')
 522           rb1 = Radiobutton(frame, text='RI',variable=self.typ_cplx,value='RI')
 523           rb2 = Radiobutton(frame, text='MP',variable=self.typ_cplx,value='MP')
 524           self.entry1 = Pmw.EntryField(frame,validate='real')
 525           self.entry2 = Pmw.EntryField(frame,validate='real')
 526           rb1.place(relx=0.05,rely = 0.4)
 527           rb2.place(relx=0.05,rely = 0.6)
 528           self.entry1.component('entry').bind("<Return>",lambda e,s=self:s.entry2.component('entry').focus)
 529           self.entry2.component('entry').bind("<Return>",lambda e,c=command:c())
 530           self.entry1.place(relx=0.27,rely = 0.5,relwidth=0.35)
 531           self.entry2.place(relx=0.65,rely = 0.5,relwidth=0.35)
 532           self.entry1.focus()
 533       else:
 534           self.entry = Entry(frame,relief='sunken')
 535           self.entry.place(relx=0.28,rely=0.5,relwidth=0.6)
 536           self.entry.bind("<Return>",lambda e,c=command:c())
 537           self.entry.focus()
 538
 539   def get_valeur(self):
 540       """
 541       Retourne la valeur saisie par l'utilisateur dans self.entry
 542       """
 543       return self.entry.get()
 544
 545   def erase_valeur(self):
 546       """
 547       Efface la valeur donnée par l'utilisateur dans l'entry
 548       """
 549       self.entry.delete(0,END)
 550
 551 class PLUSIEURS_ASSD_Panel(PLUSIEURS_Panel):
 552   """
 553   Classe définissant le panel associé aux mots-clés qui demandent
 554   à l'utilisateur de donner une liste de valeurs qui ne sont pas
 555   à choisir dans une liste discrètes et qui sont de type dérivé d'ASSD
 556   """
 557   def makeValeurPage(self,page):
 558       """
 559       Génère la page de saisie de plusieurs noms de SD parmi un ensemble discret
 560       de SD possibles, cad d'un type cohérent avec les types attendus par le mot-clé simple
 561       """
 562       # On récupère la bulle d'aide du panneau, l'objet, l'aide, min et max (cardinalité de la liste),
 563       # la liste des valeurs déjà affectées à l'objet courant et la liste des SD du bon type
 564       bulle_aide=self.get_bulle_aide()
 565       self.ajout_valeurs=None
 566       objet_mc = self.node.item.get_definition()
 567       aide = self.get_aide()
 568       aide = justify_text(texte=aide)
 569       min,max = self.node.item.GetMinMax()
 570       l_valeurs = self.node.item.GetListeValeurs()
 571       l_choix=self.node.item.get_sd_avant_du_bon_type()
 572       l_choix.sort()
 573       # remplissage du panneau
 574       self.frame_valeurs = Frame(page)
 575       self.frame_valeurs.place(relx=0.05,rely=0.05,relwidth=0.35,relheight=0.7)
 576       self.frame_boutons_fleches = Frame(page)
 577       self.frame_boutons_fleches.place(relx=0.4,rely=0.,relwidth=0.2,relheight=0.7)
 578       self.frame_choix = Frame(page)
 579       self.frame_choix.place(relx=0.6,rely=0.05,relwidth=0.35,relheight=0.7)
 580       self.frame_boutons = Frame(page)
 581       self.frame_boutons.place(relx=0.35,rely=0.87,relwidth=0.3,relheight=0.1)
 582       liste_commandes_valeurs = (("<Button-1>",self.selectValeur),
 583                                  ("<Button-3>",self.deselectValeur),
 584                                  ("<Double-Button-1>",self.sup_valeur_sans_into))
 585       liste_commandes_choix = (("<Button-1>",self.selectChoix),
 586                                ("<Button-3>",self.deselectChoix),
 587                                ("<Double-Button-1>",self.add_valeur_sans_into))
 588       self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs,liste_commandes = liste_commandes_valeurs,
 589                                       titre="Valeur(s) actuelle(s)")
 590       self.Liste_choix = ListeChoix(self,self.frame_choix,l_choix,liste_commandes = liste_commandes_choix,
 591                                     titre= "Valeurs possibles")
 592       bouton_add = Button(self.frame_boutons_fleches,
 593                           #text="<--",
 594                           image = images.get_image('arrow_left'),
 595                           command = self.add_valeur_sans_into)
 596       bouton_sup = Button(self.frame_boutons_fleches,
 597                           #text="-->",
 598                           image = images.get_image('arrow_right'),
 599                           command = self.sup_valeur_sans_into)
 600       bouton_accepter = Button(self.frame_boutons,
 601                                text='Valider',
 602                                command = lambda s=self,m=min,M=max : s.accepte_modifs_valeur(m,M))
 603       bouton_annuler = Button(self.frame_boutons,
 604                               text = 'Annuler',
 605                               command = self.annule_modifs_valeur)
 606       bouton_add.place(relx=0.3,rely=0.35)
 607       bouton_sup.place(relx=0.3,rely=0.65)
 608       for but in (bouton_accepter,bouton_annuler):
 609           but.pack(side='left',padx=5)
 610       self.Liste_valeurs.affiche_liste()
 611       self.Liste_choix.affiche_liste()
 612       for fram in (self.frame_valeurs,self.frame_boutons_fleches,self.frame_choix,self.frame_boutons):
 613           fram.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 614           fram.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 615
 616   def get_bulle_aide(self):
 617       """
 618       Retourne la bulle d'aide associée au panneau
 619       """
 620       return """Un clic sur une valeur des deux listes la sélectionne.
 621       - Un clic sur la flèche gauche stocke la valeur possible sélectionnée
 622       dans la liste des valeurs que vous voulez affecter au mot-clé simple
 623       - Un clic sur la flèche droite déstocke la valeur du mot-clé simple
 624       sélectionnée (elle apparaît alors à nouveau comme choix possible
 625       dans la liste des choix à droite)
 626       - Cliquez sur 'Valider' pour affecter la liste des valeurs sélectionnées
 627       au mot-clé simple courant
 628       - Cliquez sur 'Annuler' pour restaurer la valeur du mot-clé simple
 629       avant toute modification depuis le dernier 'Valider'"""
 630
 631   def get_aide(self):
 632       """
 633       Retourne la phrase d'aide indiquant de quel type doivent être les
 634       valeurs que doit entrer l'utilisateur
 635       """
 636       mc = self.node.item.get_definition()
 637       type = mc.type[0].__name__
 638       if len(mc.type)>1 :
 639           for typ in mc.type[1:] :
 640               type = type + ' ou '+typ.__name__
 641       if mc.min == mc.max:
 642         return "Une liste de "+`mc.min`+" objets de type "+type+" est attendue"
 643       else :
 644         return "Une liste d'objets de type "+type+" est attendue (min="+`mc.min`+",max="+`mc.max`+')'
 645
 646   def sup_valeur(self,name=None):
 647       """
 648       Supprime la valeur selectionnée de la liste des valeurs et la rajoute
 649       à la liste des choix possibles
 650       """
 651       liste_valeurs = self.Liste_valeurs.get_liste()
 652       liste_valeurs.remove(self.selected_valeur)
 653       liste_choix = self.node.item.get_definition().into
 654       liste_choix = substract_list(liste_choix,liste_valeurs)
 655       self.Liste_valeurs.put_liste(liste_valeurs)
 656       self.Liste_choix.put_liste(liste_choix)
 657       self.selected_valeur = None
 658
 659   def erase_valeur(self):
 660       pass
 661
 662   def get_valeur(self):
 663       """
 664       Retourne la valeur sélectionnée dans la liste des choix
 665       """
 666       return self.selected_choix
 667
 668   def display_valeur(self,val=None):
 669       """
 670          Affiche la valeur passée en argument dans l'entry de saisie.
 671          Par défaut affiche la valeur du mot-clé simple
 672       """
 673       # Il n'y a pas d'entry pour ce type de panneau
 674       return
 675
 676
 677 class UNIQUE_Panel(newSIMPPanel):
 678   """
 679   Classe virtuelle servant de classe mère à toutes celles définissant un panneau
 680   permettant l'affichage et la saisie d'une valeur unique pour le mot-clé simple
 681   """
 682
 683   def erase_valeur(self):
 684       """
 685       Efface l'entry de saisie
 686       """
 687       self.entry.delete(0,END)
 688
 689   def get_valeur(self):
 690       """
 691       Retourne la valeur donnée par l'utilisateur
 692       """
 693       return self.entry.get()
 694
 695   def valid_valeur(self):
 696       """
 697       Teste si la valeur fournie par l'utilisateur est une valeur permise :
 698       - si oui, l'enregistre
 699       - si non, restaure l'ancienne valeur
 700       """
 701       if self.parent.modified == 'n' : self.parent.init_modif()
 702       valeur = self.get_valeur()
 703       self.erase_valeur()
 704       anc_val = self.node.item.get_valeur()
 705       test = self.node.item.set_valeur(valeur)
 706       if not test :
 707           mess = "impossible d'évaluer : %s " %`valeur`
 708           self.parent.appli.affiche_infos("Valeur du mot-clé non autorisée :"+mess)
 709       elif self.node.item.isvalid() :
 710           self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
 711           if self.node.item.get_position()=='global':
 712               self.node.etape.verif_all()
 713           elif self.node.item.get_position()=='global_jdc':
 714               self.node.racine.verif_all()
 715           else :
 716               self.node.parent.verif()
 717           self.node.update()
 718           self.node.parent.select()
 719       else :
 720           cr = self.node.item.get_cr()
 721           mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
 722           self.record_valeur(anc_val,mess=mess)
 723
 724 class UNIQUE_INTO_Panel(UNIQUE_Panel):
 725   """
 726   Classe définissant le panel associé aux mots-clés qui demandent
 727   à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
 728   discrètes
 729   """
 730   def makeValeurPage(self,page):
 731       """
 732       Génère la page de saisie d'une seule valeur parmi un ensemble
 733       discret de possibles
 734       """
 735       # récupération de la bulle d'aide et de l'objet mc
 736       bulle_aide=self.get_bulle_aide()
 737       objet_mc = self.node.item.get_definition()
 738       # remplissage du panel
 739       self.frame_valeur = Frame(page)
 740       self.frame_valeur.pack(fill='both',expand=1)
 741       self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 742       self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 743       l_choix=list(objet_mc.into)
 744       l_choix.sort()
 745       self.label = Label(self.frame_valeur,text='Choisir une valeur :')
 746       self.label.pack(side='top')
 747       self.frame = Frame(page)
 748       self.frame.place(relx=0.33,rely=0.2,relwidth=0.33,relheight=0.6)
 749       liste_commandes = (("<Button-1>",self.selectChoix),
 750                          ("<Button-3>",self.deselectChoix),
 751                          ("<Double-Button-1>",self.record_valeur))
 752       self.Liste_choix = ListeChoix(self,self.frame,l_choix,liste_commandes = liste_commandes,
 753                                     titre="Valeurs possibles")
 754       self.Liste_choix.affiche_liste()
 755
 756   def get_bulle_aide(self):
 757       """
 758       Retourne la bulle d'aide affectée au panneau courant (affichée par clic droit)
 759       """
 760       return """Double-cliquez sur la valeur désirée
 761       pour valoriser le mot-clé simple courant"""
 762
 763 class UNIQUE_ASSD_Panel(UNIQUE_Panel):
 764   """
 765   Classe servant à définir le panneau associé aux objets qui attendent une valeur unique
 766   d'un type dérivé d'ASSD
 767   """
 768   def makeValeurPage(self,page):
 769       """
 770           Génère la page de saisie de la valeur du mot-clé simple courant qui doit être une
 771           SD de type dérivé d'ASSD
 772       """
 773       # Récupération de l'aide associée au panneau, de l'aide destinée à l'utilisateur,
 774       # et de la liste des SD du bon type (constituant la liste des choix)
 775       bulle_aide=self.get_bulle_aide()
 776       aide=self.get_aide()
 777       aide= justify_text(texte=aide)
 778       liste_noms_sd = self.node.item.get_sd_avant_du_bon_type()
 779       # Remplissage du panneau
 780       self.valeur_choisie = StringVar()
 781       self.valeur_choisie.set('')
 782       self.frame_valeur = Frame(page)
 783       self.frame_valeur.pack(fill='both',expand=1)
 784       self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 785       self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 786       self.listbox = Pmw.ScrolledListBox(self.frame_valeur,
 787                                          items=liste_noms_sd,
 788                                          labelpos='n',
 789                                          label_text="Structures de données du type\n requis par l'objet courant :",
 790                                          listbox_height = 6,
 791                                          selectioncommand=self.select_valeur_from_list,
 792                                          dblclickcommand=lambda s=self,c=self.valid_valeur : s.choose_valeur_from_list(c))
 793       self.listbox.place(relx=0.5,rely=0.3,relheight=0.4,anchor='center')
 794       Label(self.frame_valeur,text='Structure de donnée choisie :').place(relx=0.05,rely=0.6)
 795       #self.label_valeur = Label(self.frame_valeur,textvariable=self.valeur_choisie)
 796       Label(self.frame_valeur,textvariable=self.valeur_choisie).place(relx=0.5,rely=0.6)
 797       # affichage de la valeur courante
 798       self.display_valeur()
 799
 800   def get_bulle_aide(self):
 801       """
 802       Retourne l'aide associée au panneau
 803       """
 804       return "Double-cliquez sur la structure de donnée désirée pour valoriser le mot-clé simple courant"
 805
 806   def get_aide(self):
 807       """
 808       Retourne la phrase d'aide indiquant de quel type doit être la valeur à donner par l'utilisateur
 809       """
 810       mc = self.node.item.get_definition()
 811       type = mc.type[0].__name__
 812       if len(mc.type)>1 :
 813           for typ in mc.type[1:] :
 814               type = type + ' ou '+typ.__name__
 815       return  "Un objet de type "+type+" est attendu"
 816
 817   def select_valeur_from_list(self):
 818       """
 819       Affecte à valeur choisie la sélection courante dans la liste des choix proposée
 820       """
 821       if len(self.listbox.get()) == 0 : return
 822       choix = self.listbox.getcurselection()[0]
 823       self.valeur_choisie.set(choix)
 824
 825   def choose_valeur_from_list(self,command):
 826       """
 827       Affecte à valeur choisie la sélection courante dans la liste des choix proposée
 828       Exécute command
 829       """
 830       if len(self.listbox.get()) == 0 : return
 831       choix = self.listbox.getcurselection()[0]
 832       self.valeur_choisie.set(choix)
 833       apply(command,(),{})
 834
 835   def get_valeur(self):
 836       """
 837       Retourne la valeur donnée par l'utilisateur au MCS
 838       """
 839       return self.valeur_choisie.get()
 840
 841   def display_valeur(self):
 842       """
 843       Affiche la valeur de l'objet pointé par self
 844       """
 845       valeur = self.node.item.get_valeur()
 846       if valeur == None : return # pas de valeur à afficher ...
 847       self.valeur_choisie.set(valeur.nom)
 848
 849   def erase_valeur(self):
 850       pass
 851
 852 class UNIQUE_SDCO_Panel(UNIQUE_ASSD_Panel):
 853   """
 854   Classe servant à définir le panneau correspondant à un mot-clé simple
 855   qui attend une valeur unique de type dérivé d'ASSD ou non encore
 856   existante (type CO(...) utilisé dans les macros uniquement)
 857   """
 858   def makeValeurPage(self,page):
 859       """
 860       Génère la page de saisie de la valeur du mot-clé simple courant qui doit être une SD de type dérivé
 861       d'ASSD
 862       """
 863       # Récupération de l'aide associée au panneau, de l'aide destinée à l'utilisateur,
 864       # et de la liste des SD du bon type (constituant la liste des choix)
 865       bulle_aide=self.get_bulle_aide()
 866       aide=self.get_aide()
 867       aide= justify_text(texte=aide)
 868       liste_noms_sd = self.node.item.get_sd_avant_du_bon_type()
 869       # Remplissage du panneau
 870       self.frame_valeur = Frame(page)
 871       self.frame_valeur.pack(fill='both',expand=1)
 872       self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
 873       self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
 874       # affichage de la liste des SD existantes et du bon type
 875       self.listbox = Pmw.ScrolledListBox(self.frame_valeur,
 876                                          items=liste_noms_sd,
 877                                          labelpos='n',
 878                                          label_text="Structures de données du type\n requis par l'objet courant :",
 879                                          listbox_height = 6,
 880                                          selectioncommand=self.select_valeur_from_list,
 881                                          dblclickcommand=lambda s=self,c=self.valid_valeur : s.choose_valeur_from_list(c))
 882       self.listbox.place(relx=0.5,rely=0.3,relheight=0.4,anchor='center')
 883       # affichage du bouton 'Nouveau concept'
 884       self.b_co = Pmw.OptionMenu(self.frame_valeur,labelpos='w',label_text = "Nouveau concept : ",
 885                                  items = ('NON','OUI'),menubutton_width=10)
 886       self.b_co.configure(command = lambda e,s=self : s.ask_new_concept())
 887       self.b_co.place(relx=0.05,rely=0.6,anchor='w')
 888       self.label_co = Label(self.frame_valeur,text='Nom du nouveau concept :')
 889       self.entry_co = Entry(self.frame_valeur)
 890       self.entry_co.bind('<Return>',self.valid_nom_concept_co)
 891       # affichage du label de la structure de donnée choisie
 892       self.l_resu = Label(self.frame_valeur,text='Structure de donnée choisie :')
 893       self.valeur_choisie = StringVar()
 894       self.label_valeur = Label(self.frame_valeur,textvariable=self.valeur_choisie)
 895       self.frame_valeur.update()
 896       self.aide = Label(self.frame_valeur,
 897                         text = aide,
 898                         wraplength=int(self.frame_valeur.winfo_width()*0.8),
 899                         justify='center')
 900       self.aide.place(relx=0.5,rely=0.85,anchor='n')
 901       # affichage de la valeur courante
 902       self.display_valeur()
 903
 904   def get_bulle_aide(self):
 905       """
 906       Retourne la bulle d'aide du panneau
 907       """
 908       return """Double-cliquez sur la structure de donnée désirée
 909       pour valoriser le mot-clé simple courant ou cliquez sur NOUVEAU CONCEPT pour
 910       entrer le nom d'un concept non encore existant"""
 911
 912   def valid_valeur(self):
 913       """
 914       Teste si la valeur fournie par l'utilisateur est une valeur permise :
 915       - si oui, l'enregistre
 916       - si non, restaure l'ancienne valeur
 917       """
 918       if self.parent.modified == 'n' : self.parent.init_modif()
 919       valeur = self.get_valeur()
 920       self.erase_valeur()
 921       anc_val = self.node.item.get_valeur()
 922       test_CO=self.node.item.is_CO(anc_val)
 923       test = self.node.item.set_valeur(valeur)
 924       if not test :
 925           mess = "impossible d'évaluer : %s " %`valeur`
 926           self.parent.appli.affiche_infos("Valeur du mot-clé non autorisée :"+mess)
 927           return
 928       elif self.node.item.isvalid() :
 929           self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
 930           if test_CO:
 931              # il faut egalement propager la destruction de l'ancien concept
 932              self.node.item.delete_valeur_co(valeur=anc_val)
 933              # et on force le recalcul des concepts de sortie de l'etape
 934              self.node.item.object.etape.get_type_produit(force=1)
 935              # et le recalcul du contexte
 936              self.node.item.object.etape.parent.reset_context()
 937           self.node.parent.select()
 938       else :
 939           cr = self.node.item.get_cr()
 940           mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
 941           self.record_valeur(anc_val,mess=mess)
 942           return
 943       if self.node.item.get_position()=='global':
 944           self.node.etape.verif_all()
 945       elif self.node.item.get_position()=='global_jdc':
 946           self.node.racine.verif_all()
 947       else :
 948           self.node.parent.verif()
 949       self.node.update()
 950
 951   def valid_nom_concept_co(self,event=None):
 952       """
 953       Lit le nom donné par l'utilisateur au concept de type CO qui doit être
 954       la valeur du MCS courant et stocke cette valeur
 955       """
 956       if self.parent.modified == 'n' : self.parent.init_modif()
 957       anc_val = self.node.item.get_valeur()
 958       nom_concept = self.entry_co.get()
 959       test,mess=self.node.item.set_valeur_co(nom_concept)
 960       if not test:
 961           # On n'a pas pu créer le concept
 962           self.parent.appli.affiche_infos(mess)
 963           return
 964       elif self.node.item.isvalid() :
 965           self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
 966           self.node.parent.select()
 967       else :
 968           cr = self.node.item.get_cr()
 969           mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
 970           self.record_valeur(anc_val,mess=mess)
 971           return
 972       if self.node.item.get_position()=='global':
 973           self.node.etape.verif_all()
 974       elif self.node.item.get_position()=='global_jdc':
 975           self.node.racine.verif_all()
 976       else :
 977           self.node.parent.verif()
 978       if self.node.item.isvalid():
 979           self.node.parent.select()
 980       self.node.update()
 981
 982   def ask_new_concept(self):
 983       """
 984       Crée une entry dans le panneau d'un MCS qui attend un concept OU un CO() afin de
 985       permettre à l'utilisateur de donner le nom du nouveau concept
 986       """
 987       new_concept = self.b_co.getcurselection()
 988       if new_concept == 'OUI':
 989           self.label_co.place(relx=0.05,rely=0.7)
 990           self.entry_co.place(relx=0.45,rely=0.7,relwidth=0.25)
 991           self.l_resu.place_forget()
 992           self.label_valeur.place_forget()
 993           self.entry_co.focus()
 994       elif new_concept == 'NON':
 995           # On est passe de OUI à NON, on supprime la valeur
 996           self.node.item.delete_valeur_co()
 997           self.record_valeur(name=None,mess="Suppression CO enregistrée")
 998           self.label_co.place_forget()
 999           self.entry_co.place_forget()
1000           self.l_resu.place(relx=0.05,rely=0.7)
1001           self.label_valeur.place(relx=0.45,rely=0.7)
1002
1003   def display_valeur(self):
1004       """
1005       Affiche la valeur de l'objet pointé par self
1006       """
1007       valeur = self.node.item.get_valeur()
1008       if valeur == None or valeur == '':
1009          self.valeur_choisie.set('')
1010          return # pas de valeur à afficher ...
1011       # il faut configurer le bouton si la valeur est un objet CO
1012       # sinon afficher le nom du concept dans self.valeur_choisie
1013       if self.node.item.is_CO():
1014           self.b_co.invoke('OUI')
1015           self.entry_co.insert(0,valeur.nom)
1016       else:
1017           self.valeur_choisie.set(valeur.nom)
1018
1019   def record_valeur(self,name=None,mess='Valeur du mot-clé enregistrée'):
1020       """
1021       Enregistre  val comme valeur de self.node.item.object SANS faire de test de validité
1022       """
1023       if self.parent.modified == 'n' : self.parent.init_modif()
1024       if name != None:
1025           valeur =name
1026       else :
1027           self.entry_co.delete(0,END)
1028           valeur= self.entry_co.get()
1029       self.node.item.set_valeur_co(valeur)
1030       self.parent.appli.affiche_infos(mess)
1031       # On met a jour le display dans le panneau
1032       self.display_valeur()
1033       if self.node.item.get_position()=='global':
1034           self.node.etape.verif_all()
1035       elif self.node.item.get_position()=='global_jdc':
1036           self.node.racine.verif_all()
1037       else :
1038           self.node.parent.verif()
1039       if self.node.item.isvalid():
1040           self.node.parent.select()
1041       self.node.update()
1042
1043
1044 class UNIQUE_BASE_Panel(UNIQUE_Panel):
1045   """
1046   Classe servant à définir le panneau associé aux mots-clés simples qui attendent
1047   une valeur d'un type de base (entier, réel ou string).
1048   """
1049   def makeValeurPage(self,page):
1050       """
1051       Génère la page de saisie de la valeur du mot-clé simple courant qui doit être de type
1052       de base cad entier, réel, string ou complexe
1053       """
1054       # Récupération de l'aide associée au panneau, de l'aide destinée à l'utilisateur,
1055       # et de la liste des SD du bon type (constituant la liste des choix)
1056       bulle_aide=self.get_bulle_aide()
1057       aide=self.get_aide()
1058       aide= justify_text(texte=aide)
1059       liste_noms_sd = self.node.item.get_sd_avant_du_bon_type()
1060       # Remplissage du panneau
1061       self.frame_valeur = Frame(page)
1062       self.frame_valeur.pack(fill='both',expand=1)
1063       self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
1064       self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
1065       self.label = Label(self.frame_valeur,text='Valeur :')
1066       self.label.place(relx=0.1,rely=0.5)
1067       self.entry = Entry(self.frame_valeur,relief='sunken')
1068       self.entry.place(relx=0.28,rely=0.5,relwidth=0.6)
1069       self.entry.bind("<Return>",lambda e,c=self.valid_valeur:c())
1070       self.entry.focus()
1071       # aide associée au panneau
1072       self.frame_valeur.update()
1073       self.aide = Label(self.frame_valeur,
1074                         text = aide,
1075                         wraplength=int(self.frame_valeur.winfo_width()*0.8),
1076                         justify='center')
1077       self.aide.place(relx=0.5,rely=0.7,anchor='n')
1078       # affichage de la valeur du MCS
1079       self.display_valeur()
1080
1081   def get_aide(self):
1082       """
1083       Retourne la phrase d'aide indiquant de quel type doit être la valeur
1084       du mot-clé simple fournie par l'utilisateur
1085       """
1086       mc = self.node.item.get_definition()
1087       d_aides = { 'TXM' : "Une chaîne de caractères est attendue",
1088                   'R'   : "Un réel est attendu",
1089                   'I'   : "Un entier est attendu"}
1090       type = mc.type[0]
1091       return d_aides.get(type,"Type de base inconnu")
1092
1093   def get_bulle_aide(self):
1094       """
1095       Retourne la bulle d'aide associée au panneau et affichée par clic droit
1096       """
1097       return """Saisissez la valeur que vous voulez affecter au mot-clé simple
1098       dans la zone de saisie et pressez <Return>"""
1099
1100   def display_valeur(self):
1101       """
1102       Affiche la valeur de l'objet pointé par self
1103       """
1104       valeur = self.node.item.get_valeur()
1105       if valeur == None : return # pas de valeur à afficher ...
1106       self.entry.delete(0,END)
1107       self.entry.insert(0,valeur)
1108
1109 class UNIQUE_COMP_Panel(UNIQUE_Panel):
1110   """
1111   Classe servant à définir le panneau associé aux mots-clés simples
1112   qui attendent une valeur de type complexe
1113   """
1114   def makeValeurPage(self,page):
1115       """
1116       Génère la page de saisie de la valeur du mot-clé simple courant qui doit être de type
1117       de base cad entier, réel, string ou complexe
1118       """
1119       # Récupération de l'aide associée au panneau et de l'aide destinée à l'utilisateur
1120       bulle_aide=self.get_bulle_aide()
1121       aide=self.get_aide()
1122       aide= justify_text(texte=aide)
1123       # Remplissage du panneau
1124       self.frame_valeur = Frame(page)
1125       self.frame_valeur.pack(fill='both',expand=1)
1126       self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
1127       self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
1128       self.label = Label(self.frame_valeur,text='Valeur :')
1129       self.label.place(relx=0.1,rely=0.5)
1130       self.typ_cplx=StringVar()
1131       self.typ_cplx.set('RI')
1132       rb1 = Radiobutton(self.frame_valeur, text='RI',variable=self.typ_cplx,value='RI')
1133       rb2 = Radiobutton(self.frame_valeur, text='MP',variable=self.typ_cplx,value='MP')
1134       self.entry1 = Pmw.EntryField(self.frame_valeur,validate='real')
1135       self.entry2 = Pmw.EntryField(self.frame_valeur,validate='real')
1136       rb1.place(relx=0.05,rely = 0.4)
1137       rb2.place(relx=0.05,rely = 0.6)
1138       self.entry1.component('entry').bind("<Return>",lambda e,s=self:s.entry2.component('entry').focus())
1139       self.entry2.component('entry').bind("<Return>",lambda e,c=self.valid_valeur:c())
1140       self.entry1.place(relx=0.27,rely = 0.5,relwidth=0.35)
1141       self.entry2.place(relx=0.65,rely = 0.5,relwidth=0.35)
1142       self.entry1.focus()
1143       self.frame_valeur.update()
1144       self.aide = Label(self.frame_valeur,
1145                         text = aide,
1146                         wraplength=int(self.frame_valeur.winfo_width()*0.8),
1147                         justify='center')
1148       self.aide.place(relx=0.5,rely=0.7,anchor='n')
1149
1150   def get_bulle_aide(self):
1151       """
1152       Retourne la bulle d'aide du panneau
1153       """
1154       return """-Choisissez votre format de saisie du complexe :
1155       \t 'RI' = parties réelle et imaginaire
1156       \t 'MP' = module/phase (en degrés)
1157       - Saisissez ensuite dans les deux zones de saisie les deux nombres attendus"""
1158
1159   def get_aide(self):
1160       """
1161       Retourne la phrase d'aide décrivant le type de la valeur que peut prendre
1162       le mot-clé simple courant
1163       """
1164       return 'Un complexe est attendu'
1165
1166   def get_valeur(self):
1167       """
1168       Retourne le complexe saisi par l'utilisateur
1169       """
1170       l=[]
1171       l.append(self.typ_cplx.get())
1172       l.append(string.atof(self.entry1.get()))
1173       l.append(string.atof(self.entry2.get()))
1174       return `tuple(l)`
1175
1176   def erase_valeur(self):
1177       """
1178       Efface les entries de saisie
1179       """
1180       self.typ_cplx = 'RI'
1181       self.entry1.delete(0,END)
1182       self.entry2.delete(0,END)
1183
1184 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
1185   panel = newSIMPPanel
1186
1187   def init(self) :
1188       self.expandable = 0
1189       self.affect_panel()
1190
1191   def affect_panel(self):
1192       """
1193       Cette méthode attribue le panel à l'objet pointé par self en fonction de la
1194       nature de la valeur demandée pour cet objet
1195       """
1196       if self.wait_shell():
1197           # l'objet attend un shell
1198           self.panel = SHELLPanel
1199       elif self.wait_into():
1200           # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
1201           min,max = self.GetMinMax()
1202           if max != 1 and ((min != 0 and min != max) or (min == 0)):
1203              # l'objet attend une liste de valeurs
1204              self.panel = PLUSIEURS_INTO_Panel
1205           else:
1206              # l'objet n'attend qu'une seule valeur
1207              self.panel = UNIQUE_INTO_Panel
1208       else:
1209           # l'objet prend une ou des valeurs à priori quelconques
1210           min,max = self.GetMinMax()
1211           if max != 1 :
1212               # on attend une liste de valeurs mais de quel type ?
1213               if self.wait_assd():
1214                   # on attend une liste de SD
1215                   self.panel = PLUSIEURS_ASSD_Panel
1216               else:
1217                   # on attend une liste de valeurs de types debase (entiers, réels,...)
1218                   self.panel = PLUSIEURS_BASE_Panel
1219           else:
1220               # on n'attend qu'une seule valeur mais de quel type ?
1221               if self.wait_co():
1222                   # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
1223                   self.panel = UNIQUE_SDCO_Panel
1224               elif self.wait_assd():
1225                   # on attend une SD
1226                   self.panel = UNIQUE_ASSD_Panel
1227               else:
1228                   # on attend une valeur d'un type de base (entier,réel,...)
1229                   if self.wait_complex():
1230                       # on attend un complexe
1231                       self.panel = UNIQUE_COMP_Panel
1232                   else:
1233                       # on attend un entier, un réel ou une string
1234                       self.panel = UNIQUE_BASE_Panel
1235
1236   def SetText(self, text):
1237     try:
1238       value = eval(text)
1239       self.object.setval(value)
1240     except:
1241       pass
1242
1243   def GetIconName(self):
1244     if self.isvalid():
1245       return "ast-green-ball"
1246     elif self.object.isoblig():
1247       return "ast-red-ball"
1248     else:
1249       return "ast-yel-ball"
1250
1251   def GetText(self):
1252     """
1253     Classe SIMPTreeItem
1254     Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
1255     pointé par self
1256     """
1257     return self.object.GetText()
1258
1259   def wait_co(self):
1260       """
1261       Méthode booléenne qui retourne 1 si l'objet pointé par self
1262       attend un objet de type ASSD qui n'existe pas encore (type CO()),
1263       0 sinon
1264       """
1265       return self.object.wait_co()
1266
1267   def wait_geom(self):
1268       """
1269       Méthode booléenne qui retourne 1 si l'objet pointé par self
1270       attend un objet GEOM, 0 sinon
1271       """
1272       return self.object.wait_geom()
1273
1274   def wait_complex(self):
1275       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
1276       attend un complexe, 0 sinon """
1277       if 'C' in self.object.definition.type:
1278           return 1
1279       else:
1280           return 0
1281
1282   def wait_reel(self):
1283       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
1284       attend un réel, 0 sinon """
1285       if 'R' in self.object.definition.type:
1286           return 1
1287       else:
1288           return 0
1289
1290   def wait_shell(self):
1291       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
1292       attend un shell, 0 sinon """
1293       if 'shell' in self.object.definition.type:
1294           return 1
1295       else:
1296           return 0
1297
1298   def wait_into(self):
1299       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
1300       prend ses valeurs dans un ensemble discret (into), 0 sinon """
1301       if self.object.definition.into != None :
1302           return 1
1303       else:
1304           return 0
1305
1306   def wait_assd(self):
1307       """Méthode booléenne qui retourne 1 si l'objet pointé par self
1308       attend un objet de type ASSD ou dérivé, 0 sinon """
1309       return self.object.wait_assd()
1310
1311   def getval(self):
1312       return self.object.getval()
1313
1314   def GetMinMax(self):
1315       """ Retourne les valeurs min et max de la définition de object """
1316       return self.object.get_min_max()
1317
1318   def GetMultiplicite(self):
1319       """ A préciser.
1320           Retourne la multiplicité des valeurs affectées à l'objet
1321           représenté par l'item. Pour le moment retourne invariablement 1.
1322       """
1323       return 1
1324
1325   def GetType(self):
1326       """
1327           Retourne le type de valeur attendu par l'objet représenté par l'item.
1328       """
1329       return self.object.get_type()
1330
1331   def GetIntervalle(self):
1332       """
1333            Retourne le domaine de valeur attendu par l'objet représenté
1334            par l'item.
1335       """
1336       return self.object.getintervalle()
1337
1338   def IsInIntervalle(self,valeur):
1339       """
1340           Retourne 1 si la valeur est dans l'intervalle permis par
1341           l'objet représenté par l'item.
1342       """
1343       return self.object.isinintervalle(valeur)
1344
1345   def set_valeur_co(self,nom_co):
1346       """
1347       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
1348       """
1349       return self.object.set_valeur_co(nom_co)
1350
1351   def get_sd_avant_du_bon_type(self):
1352       """
1353       Retourne la liste des noms des SD présentes avant l'étape qui contient
1354       le MCS pointé par self et du type requis par ce MCS
1355       """
1356       return self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,
1357                                                                self.object.definition.type)
1358
1359   def GetListeValeurs(self) :
1360       """ Retourne la liste des valeurs de object """
1361       return self.object.get_liste_valeurs()
1362
1363   def verif(self):
1364       pass
1365
1366   def isvalid(self):
1367     return self.object.isvalid()
1368
1369   def eval_valeur(self,valeur):
1370       """ Lance l'interprétation de 'valeur' (chaîne de caractères) comme valeur
1371       de l'objet pointé par self :
1372         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
1373         - retourne 'valeur' (chaîne de caractères) sinon """
1374       return self.object.eval_valeur(valeur)
1375
1376   def is_CO(self,valeur=None):
1377       """
1378          Indique si valeur est un concept produit de la macro
1379          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
1380          Si valeur vaut None on teste la valeur du mot cle
1381       """
1382       # Pour savoir si un concept est un nouveau concept de macro
1383       # on regarde s'il est présent dans l'attribut sdprods de l'étape
1384       # ou si son nom de classe est CO.
1385       # Il faut faire les 2 tests car une macro non valide peut etre
1386       # dans un etat pas tres catholique avec des CO pas encore types
1387       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
1388       if not valeur:valeur=self.object.valeur
1389       if valeur in self.object.etape.sdprods:return 1
1390       if type(valeur) is not types.ClassType:return 0
1391       if valeur.__class__.__name__ == 'CO':return 1
1392       return 0
1393
1394   def delete_valeur_co(self,valeur=None):
1395       """
1396            Supprime la valeur du mot cle (de type CO)
1397            il faut propager la destruction aux autres etapes
1398       """
1399       if not valeur : valeur=self.object.valeur
1400       # XXX faut il vraiment appeler del_sdprod ???
1401       #self.object.etape.parent.del_sdprod(valeur)
1402       self.object.etape.parent.delete_concept(valeur)
1403
1404 import Accas
1405 treeitem = SIMPTreeItem
1406 objet = Accas.MCSIMP
1407