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