Editeur/treewidget.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 import os,sys,string,re,types,traceback
  22 from Tkinter import *
  23
  24
  25 import fontes
  26 import images
  27
  28 #
  29 __version__="$Name:  $"
  30 __Id__="$Id: treewidget.py,v 1.14 2004/09/10 15:51:52 eficas Exp $"
  31 #
  32
  33 Fonte_Standard = fontes.standard
  34
  35 class Tree :
  36     def __init__(self,appli,jdc_item,scrolledcanvas,command = None,rmenu=None):
  37         self.item = jdc_item
  38         self.scrolledcanvas = scrolledcanvas
  39         self.canvas = self.scrolledcanvas.component('canvas')
  40         self.canvas.bind("<Key-Prior>", self.page_up)
  41         self.canvas.bind("<Key-Next>", self.page_down)
  42         self.canvas.bind("<Key-Up>", self.unit_up)
  43         self.canvas.bind("<Key-Down>", self.unit_down)
  44         self.canvas.bind("<1>", self.canvas_select)
  45         self.tree = self
  46         self.command = command
  47         self.rmenu=rmenu
  48         self.appli = appli
  49         self.parent = None
  50         self.racine = self
  51         self.node_selected = None
  52         self.build_children()
  53
  54     def canvas_select(self,event):
  55         self.canvas.focus_set()
  56
  57     def page_up(self,event):
  58         event.widget.yview_scroll(-1, "page")
  59     def page_down(self,event):
  60         event.widget.yview_scroll(1, "page")
  61     def unit_up(self,event):
  62         event.widget.yview_scroll(-1, "unit")
  63     def unit_down(self,event):
  64         event.widget.yview_scroll(1, "unit")
  65
  66     def build_children(self):
  67         """ Construit la liste des enfants de self """
  68         self.children = []
  69         child = self.item.itemNode(self,self.item,self.command,self.rmenu)
  70         self.children.append(child)
  71         child.state='expanded'
  72
  73     def draw(self):
  74         """ Dessine l'arbre """
  75         lasty = 8
  76         x = 5
  77         for child in self.children:
  78             child.draw(x,lasty)
  79             lasty = child.lasty + 15
  80         self.children[0].select()
  81         self.resizescrollregion()
  82
  83     def deselectall(self):
  84         """ déselectionne tous les éléments de l'arbre """
  85         if self.node_selected :
  86             self.node_selected.deselect()
  87
  88     def update(self):
  89         """ Update tous les éléments de l'arbre """
  90         for child in self.children:
  91             child.update()
  92
  93     def update_valid(self) :
  94         """Cette methode a pour but de mettre a jour la validite du noeud
  95            et de propager la demande de mise à jour à son parent
  96         """
  97         pass
  98
  99     def resizescrollregion(self):
 100         x0,y0,x1,y1=self.canvas.bbox(ALL)
 101         # On ajoute une marge approximativement de la moitié du canvas
 102         y1=y1+self.canvas.winfo_height()/2
 103         self.canvas.configure(scrollregion = (x0,y0,x1,y1))
 104
 105     def select_next(self,event):
 106         self.node_selected.select_next()
 107
 108     def select_previous(self,event):
 109         self.node_selected.select_previous()
 110
 111     def full_creation(self,name,index):
 112         # A changer lorsqu'il y aura plusieurs jdc ouverts en même temps
 113         self.children[0].full_creation(name,index)
 114
 115     def verif_all(self):
 116         for child in self.children :
 117             self.verif_all_children()
 118
 119     def see(self,items):
 120         x1, y1, x2, y2=apply(self.canvas.bbox, items)
 121         while x2 > self.canvas.canvasx(0)+self.canvas.winfo_width():
 122             old=self.canvas.canvasx(0)
 123             self.canvas.xview_scroll( 1, 'units')
 124             # avoid endless loop if we can't scroll
 125             if old == self.canvas.canvasx(0):
 126                 break
 127         while y2 > self.canvas.canvasy(0)+self.canvas.winfo_height():
 128             old=self.canvas.canvasy(0)
 129             self.canvas.yview_scroll( 1, 'units')
 130             if old == self.canvas.canvasy(0):
 131                 break
 132         # done in this order to ensure upper-left of object is visible
 133         while x1 < self.canvas.canvasx(0):
 134             old=self.canvas.canvasx(0)
 135             self.canvas.xview_scroll( -1, 'units')
 136             if old == self.canvas.canvasx(0):
 137                 break
 138         while y1 < self.canvas.canvasy(0):
 139             old=self.canvas.canvasy(0)
 140             self.canvas.yview_scroll( -1, 'units')
 141             if old == self.canvas.canvasy(0):
 142                 break
 143
 144 class Node :
 145     def __init__(self,parent,item,command=None,rmenu=None):
 146         self.parent = parent
 147         self.item = item
 148         self.command = command
 149         self.rmenu=rmenu
 150         self.tree = self.parent.tree
 151         self.appli = self.parent.appli
 152         self.canvas = self.parent.canvas
 153         self.init()
 154
 155     def init(self):
 156         self.state='collapsed'
 157         self.displayed = 0
 158         self.selected = 0
 159         self.x = self.y  =None
 160         self.lasty = 0
 161         self.children = None
 162         self.id = []
 163         # etape = noeud d'étape auquel appartient self
 164         # = self si c'est lui-même
 165         if isinstance(self.parent,Tree) :
 166             # on est  sur un noeud de JDC
 167             self.racine=self
 168             self.etape=None
 169             self.nature='JDC'
 170         elif isinstance(self.parent.parent,Tree) :
 171             # on est sur un noeud d'étape
 172             self.racine = self.parent
 173             self.etape=self
 174             self.nature = 'ETAPE'
 175         else :
 176             # on est sur un noeud de mot-clé
 177             self.racine = self.parent.racine
 178             self.etape=self.parent.etape
 179             self.nature = 'MOTCLE'
 180
 181     def build_children(self):
 182         """ Construit la liste des enfants de self """
 183         self.children = []
 184         sublist = self.item._GetSubList()
 185         if not sublist : return
 186         for item in sublist :
 187             child = item.itemNode(self,item,self.command,self.rmenu)
 188             self.children.append(child)
 189
 190     #-----------------------------------------------
 191     # Méthodes de sélection/déselection d'un noeud
 192     #-----------------------------------------------
 193
 194     def select(self, event=None):
 195         """
 196         Rend le noeud courant (self) sélectionné et déselectionne
 197         tous les autres
 198         """
 199         if not self.children : self.build_children()
 200         self.tree.deselectall()
 201         self.selected = 1
 202         self.tree.node_selected = self
 203         if self.command:apply(self.command,(self,))
 204         self.highlight()
 205         self.make_visible()
 206
 207     def deselect(self, event=None):
 208         """ Déselectionne self """
 209         self.selected = 0
 210         if self.displayed == 1 : self.dehighlight()
 211
 212     def make_visible(self):
 213         """ Rend l'objet self visible cad déplace le scroll pour que self soit dans
 214             la fenêtre de visu
 215         """
 216         lchild=self.last_child()
 217         self.tree.see((self.image_id,lchild.image_id))
 218
 219     def select_next(self,ind=0):
 220         """ on doit chercher à sélectionner dans l'ordre:
 221                 - son premier fils s'il est affiché
 222                 - son frère cadet s'il existe
 223                 - son oncle (benjamin de son père)
 224                 - ... appel récursif ...
 225         """
 226         if self.state=='expanded' and len(self.children) > ind:
 227             self.children[ind].select()
 228         else :
 229             index = self.parent.children.index(self) + 1
 230             if isinstance(self.parent,TREE) :
 231                 try:
 232                     self.children[ind].select()
 233                 except:
 234                     self.children[0].select()
 235             else :
 236                 self.parent.select_next(index)
 237
 238     def select_previous(self):
 239         """ on doit d'abord sélectionner(dans l'ordre) :
 240              - son frère aîné
 241              - son père
 242         """
 243         index = self.parent.children.index(self) + 1
 244         try :
 245             self.parent.children[index].select()
 246         except:
 247             self.parent.select()
 248
 249     def popup(self,event=None):
 250         """
 251             Declenche le traitement associé au clic droit de la souris
 252             sur l'icone du Node
 253         """
 254         if not self.rmenu:return
 255         apply(self.rmenu,(self,event))
 256
 257     #-----------------------------------------------
 258     # Méthodes de recherche d'informations
 259     #-----------------------------------------------
 260     def geticonimage(self,name=None):
 261         """
 262         Retourne l'image qui doit être associée à self
 263         """
 264         if not name :
 265             name = self.item.GetIconName()
 266         if not name or name == 'aucune' :
 267             return None
 268         return images.get_image(name)
 269
 270     def get_nb_children(self):
 271         """ Retourne le nombre d'enfants affichés de self """
 272         nb = 0
 273         if self.state =='collapsed' :  return nb
 274         for child in self.children :
 275             nb = nb + 1 + child.get_nb_children()
 276         return nb
 277
 278     def get_liste_id(self):
 279         """ Retourne la liste de tous les id (filiation comprise) de self """
 280         liste = self.id
 281         for child in self.children:
 282             liste.extend(child.get_liste_id())
 283         return liste
 284
 285     def get_node_fils(self,name) :
 286         """ Retourne le fils de self de nom name s'il existe"""
 287         for child in self.children:
 288             if child.item.get_nom() == name: return child
 289         return None
 290     #-----------------------------------------------
 291     # Méthodes d'affichage d'un noeud
 292     #-----------------------------------------------
 293     def draw(self,x,y):
 294         """ Permet de tracer le noeud self """
 295         # le début du noeud est en x,y
 296         self.x = x
 297         self.y = y
 298         self.lasty = y
 299         self.displayed = 1
 300         self.id=[]
 301         # choix de l'icone à afficher : + ou -
 302         if self.item.IsExpandable():
 303             if self.state == 'expanded':
 304                 iconname = "minusnode"
 305                 callback = self.collapse
 306             else:
 307                 iconname = "plusnode"
 308                 callback = self.expand
 309             image = self.geticonimage(name=iconname)
 310             self.icone_id = self.canvas.create_image(self.x, self.y, image=image)
 311             self.canvas.tag_bind(self.icone_id, "<1>", callback)
 312             self.id.append(self.icone_id)
 313         # création de la ligne horizontale
 314         self.ligne_id = self.canvas.create_line(self.x,self.y,self.x+10,self.y)
 315         self.id.append(self.ligne_id)
 316         self.canvas.tag_lower(self.ligne_id)
 317         # affichage de l'icone (carre ,rond, ovale ...) de couleur
 318         image = self.geticonimage()
 319         if image != None :
 320             self.image_id = self.canvas.create_image(self.x+15,self.y,image = image)
 321             self.canvas.tag_bind(self.image_id,"<1>",self.select)
 322             self.canvas.tag_bind(self.image_id,"<3>",self.popup)
 323             self.id.append(self.image_id)
 324         else:
 325             self.image_id = None
 326         # affichage du texte : nom de l'objet (ETAPE ou MOT-CLE) et sa valeur
 327         self.drawtext()
 328         if self.state == 'expanded' :
 329             if not self.children : self.build_children()
 330             if len(self.children) > 0:
 331                 self.drawchildren()
 332                 self.lasty = self.children[-1].lasty
 333
 334     def drawchildren(self):
 335         """ Dessine les enfants de self """
 336         y = self.y + 20
 337         x = self.x + 15
 338         for child in self.children:
 339             child.draw(x,y)
 340             nb = child.get_nb_children()
 341             y = y + 20*(nb+1)
 342         self.trace_ligne()
 343
 344     def drawtext(self):
 345         """ Affiche les deux zones de texte après l'icône de couleur de l'objet """
 346         if self.image_id != None :
 347             textx = self.x + 30
 348         else:
 349             textx = self.x + 15
 350         texty = self.y
 351         # nom,fonte et couleur de l'objet du noeud à afficher
 352         labeltext,fonte,couleur = self.item.GetLabelText()
 353         if labeltext    == ''   : labeltext = '   '
 354         if fonte        == None : fonte = Fonte_Standard
 355         if couleur      == None : couleur = 'black'
 356         # création du widget label
 357         self.label = Label(self.canvas,
 358                            text = labeltext,
 359                            fg = couleur,
 360                            bg = 'gray95',
 361                            font=fonte)
 362         self.label_id = self.canvas.create_window(textx,texty,window=self.label,anchor='w')
 363         self.id.append(self.label_id)
 364         # bindings sur le widget label
 365         self.label.bind("<1>", self.select)
 366         self.label.bind("<3>", self.popup)
 367         self.label.bind("<Enter>",self.enter)
 368         self.label.bind("<Leave>",self.leave)
 369         # valeur de cet objet à afficher
 370         x0, y0, x1, y1 = self.canvas.bbox(self.label_id)
 371         textx = max(x1, 200) + 10
 372         text = self.item.GetText() or " "
 373         self.text = Label(self.canvas, text=text,
 374                             bd=0, padx=2, pady=2,background='gray95',
 375                             font=fonte)
 376         if self.selected:
 377             self.highlight()
 378         else:
 379             self.dehighlight()
 380         self.text_id = self.canvas.create_window(textx, texty,anchor="w", window=self.text)
 381         self.id.append(self.text_id)
 382
 383     def highlight(self,event=None):
 384         """ Met en surbrillance self"""
 385         if hasattr(self,'label'):
 386             self.label.configure(fg='white',bg='#00008b')
 387
 388     def dehighlight(self,event=None):
 389         """ Rétablit l'affichage normal de self"""
 390         if hasattr(self,'label'):
 391             self.label.configure(fg='black',bg='gray95')
 392
 393     def enter(self,event=None):
 394         """ Met en surbrillance self et affiche le fr de l'objet """
 395         self.highlight()
 396         fr = self.item.get_fr()
 397         self.appli.affiche_infos(fr)
 398
 399     def leave(self,event=None):
 400         """ Rétablit l'affichage normal de self et efface le fr de l'objet """
 401         if not self.selected :
 402             self.dehighlight()
 403         self.appli.affiche_infos('')
 404
 405     def collapse_children(self):
 406         """ Collapse récursivement tous les descendants de self """
 407         if not self.children : return
 408         for child in self.children:
 409             child.state='collapsed'
 410             child.displayed = 0
 411             child.collapse_children()
 412
 413     def collapse(self,event = None):
 414         """ Collapse self et descendants et retrace self """
 415         nb = self.get_nb_children()
 416         self.state = 'collapsed'
 417         self.collapse_children()
 418         self.redraw(-nb)
 419         self.select()
 420
 421     def expand(self,event = None):
 422         """ Expanse self et le retrace """
 423         if not self.item.isactif() : return
 424         if not self.children : self.build_children()
 425         self.state = 'expanded'
 426         nb = self.get_nb_children()
 427         self.redraw(nb)
 428         self.select()
 429
 430     def redraw(self,nb):
 431         """ Redessine self :  nb est le décalage à introduire
 432             en dessous de self pour le redessiner """
 433         # nb = nombre d'items de décalage
 434         self.move(20*nb)
 435         # on efface self et on le redessine
 436         self.efface()
 437         self.draw(self.x,self.y)
 438         # Il n'est pas nécessaire d'appeler update
 439         # il suffit d'updater les coordonnees et de retracer les lignes
 440         self.racine.update_coords()
 441         self.racine.trace_ligne()
 442         self.update_valid()
 443         self.tree.resizescrollregion()
 444
 445     def update_coords(self):
 446         """ Permet d'updater les coordonnes de self et de tous ses enfants"""
 447         if self.displayed == 0 : return
 448         if self.image_id != None :
 449             coords = self.canvas.coords(self.image_id)
 450             self.x = coords[0]-15
 451         else:
 452             coords = self.canvas.coords(self.label_id)
 453             self.x = coords[0]-15
 454         self.y = coords[1]
 455         if self.state == 'expanded' :
 456             for child in self.children:
 457                 if child.displayed != 0:
 458                     child.update_coords()
 459
 460     def update_icone(self):
 461         """ Met à jour les icônes de tous les noeuds : teste la validité de l'objet
 462         Cette méthode est très lente, trop !!"""
 463         if self.image_id != None :
 464             image = self.geticonimage()
 465             self.canvas.itemconfig(self.image_id,image=image)
 466         if self.state == 'expanded':
 467             for child in self.children:
 468                 if child.displayed != 0:
 469                     child.update_icone()
 470
 471     def update_texte(self):
 472         """ Met à jour les noms des SD et valeurs des mots-clés """
 473         text = self.item.GetText()
 474         if text == None : text = ''
 475         self.text.configure(text=text)
 476         if self.state == 'expanded' :
 477             for child in self.children:
 478                 if child.displayed != 0 : child.update_texte()
 479
 480     def update_valid(self) :
 481         """Cette methode a pour but de mettre a jour la validite du noeud
 482            et de propager la demande de mise à jour à son parent
 483         """
 484         if self.image_id != None :
 485             image = self.geticonimage()
 486             self.canvas.itemconfig(self.image_id,image=image)
 487         self.parent.update_valid()
 488
 489     def update(self,event=None) :
 490         """ Classe Node :
 491             Cette méthode est appelée pour demander l update d un noeud
 492             d'un jeu de commandes
 493             Cette demande est transmise au noeud racine (le JDC) qui update
 494             tout l arbre représentant le jeu de commandes
 495             Pendant cette mise à jour, on appelle la méthode isvalid qui
 496             fera l update de tous les objets déclarés modifiés lors des
 497             actions précédentes
 498             La métode isvalid est en général appelée par l intermédiaire de
 499             update_icone -> geticonimage -> GetIconName
 500         """
 501         self.racine.update_coords()
 502         self.racine.trace_ligne()
 503         self.racine.update_icone()
 504         self.racine.update_texte()
 505         self.tree.resizescrollregion()
 506
 507     def efface(self):
 508         """ Efface du canvas les id associés à self : cad les siens et ceux
 509             de ses enfants """
 510         for id in self.id :
 511             self.canvas.delete(id)
 512         if not self.children : return
 513         for child in self.children:
 514             child.efface()
 515
 516     def move(self,dy):
 517         """ Déplace de l'incrément dy tous les id en dessous de self """
 518         # il faut marquer tous les suivants de self
 519         bbox1 = self.canvas.bbox(ALL)
 520         self.canvas.dtag(ALL,'move')
 521         self.canvas.delete('line')
 522         try:
 523             self.canvas.addtag_overlapping('move',bbox1[0],self.y +10,bbox1[2],bbox1[3])
 524         except:
 525             print "Erreur dans move :"
 526             print self
 527             print self.item
 528             print self.item.getObject()
 529             print self.item.getObject().definition.label
 530             print 'y=',self.y
 531             print 'dy=',dy
 532         # on déplace tous les items de dy
 533         self.canvas.move('move',0,dy)
 534
 535     def trace_ligne(self):
 536         """ Dessine les lignes verticales entre frères et entre père et premier fils"""
 537         if self.state=='collapsed' : return
 538         #if self.displayed == 0 : return
 539         if len(self.children)==0 : return
 540         # on est bien dans le cas d'un noeud expansé avec enfants ...
 541         # il faut rechercher l'ordonnée du dernier fils de self
 542         y_end = self.children[-1].y
 543         ligne = self.canvas.create_line(self.x+15,self.y,self.x+15,y_end,tags='line')
 544         self.canvas.tag_lower(ligne)
 545         for child in self.children :
 546             try:
 547                 child.trace_ligne()
 548             except:
 549                 print "Erreur dans trace_ligne :"
 550                 print child
 551                 print child.item.getObject()
 552
 553     def last_child(self):
 554         lchild=self
 555         if self.state == 'expanded' and self.children:
 556            lchild= self.children[-1].last_child()
 557         return lchild
 558
 559     #------------------------------------------------------------------
 560     # Méthodes de création et destruction de noeuds
 561     # Certaines de ces méthodes peuvent être appelées depuis l'externe
 562     #------------------------------------------------------------------
 563     def replace_node(self,node1,node2):
 564         """ Remplace le noeud 1 par le noeud 2 dans la liste des enfants de self"""
 565         index= self.children.index(node1)
 566         self.delete_node_child(node1)
 567         self.children.insert(index,node2)
 568
 569     def replace_enfant(self,item):
 570         """ Retourne le noeud fils à éventuellement remplacer """
 571         return self.get_node_fils(item.get_nom())
 572
 573     def full_creation(self,name,pos=None):
 574         """
 575             Interface avec ACCAS : création de l'objet de nom name et
 576             du noeud associé. Retourne le noeud fils ainsi créé
 577         """
 578         item = self.item.additem(name,pos)
 579         if item == None or item == 0:
 580             # impossible d'ajouter le noeud de nom : name
 581             return 0
 582
 583         enfant = self.replace_enfant(item)
 584         if enfant :
 585             # un fils de même nom existe déjà : on le remplace
 586             child = item.itemNode(self,item,self.command,self.rmenu)
 587             self.replace_node(enfant,child)
 588         else :
 589             child = item.itemNode(self, item,self.command,self.rmenu)
 590             if pos is None:
 591                 self.children.append(child)
 592             else :
 593                 self.children.insert(pos,child)
 594         return child
 595
 596     def append_brother(self,name,pos='after',retour='non'):
 597         """
 598         Permet d'ajouter un frère à self
 599         par défaut on l'ajoute après self
 600         Méthode externe
 601         """
 602         # on veut ajouter le frère de nom name directement avant ou après self
 603         index = self.parent.children.index(self)
 604         if pos == 'before':
 605             index = index
 606         elif pos == 'after':
 607             index = index +1
 608         else:
 609             print str(pos)," n'est pas un index valide pour append_brother"
 610             return
 611         return self.parent.append_child(name,pos=index,retour=retour)
 612
 613     def append_node_child(self,fils,pos=None,verif='oui'):
 614         """
 615         Fait appel à la création complète de fils et à la vérification
 616         des conditions en fonction du contexte
 617         Attention : fils peut être un nom ou déjà un object (cas d'une copie)
 618         """
 619         if not self.children : self.build_children()
 620         if pos == None :
 621             if type(fils) == types.InstanceType:
 622                 pos = self.item.get_index_child(fils.nom)
 623             else:
 624                 pos = self.item.get_index_child(fils)
 625         child = self.full_creation(fils,pos)
 626         if child == 0 :
 627             # on n'a pas pu créer le noeud fils
 628             return 0
 629         self.state = 'expanded'
 630         child.displayed = 1
 631         if child.item.isactif():
 632            child.state = 'expanded'
 633         if not child.children : child.build_children()
 634         if verif == 'oui':
 635            child.verif_condition()
 636            self.verif_condition()
 637         return child
 638
 639     def append_child(self,name,pos=None,verif='oui',retour='non'):
 640         """
 641         Permet d'ajouter un fils à self
 642         on peut l'ajouter en fin de liste (défaut) ou en début
 643         Méthode externe
 644         """
 645         if pos == 'first':
 646             index = 0
 647         elif pos == 'last':
 648             index = len(self.children)
 649         elif pos != None and type(pos) == types.IntType :
 650             # on donne la position depuis l'extérieur
 651             # (appel de append_child par append_brother par exemple)
 652             index = pos
 653         elif type(pos) == types.InstanceType:
 654             # pos est un item. Il faut inserer name apres pos
 655             index = self.item.get_index(pos) +1
 656         else :
 657             if type(name) == types.InstanceType:
 658                 index = self.item.get_index_child(name.nom)
 659             else:
 660                 index = self.item.get_index_child(name)
 661         nbold = self.get_nb_children()
 662         self.state='expanded'
 663         child = self.append_node_child(name,pos=index)
 664         if child == 0 :
 665             # on n'a pas pu créer le fils
 666             return 0
 667         nbnew = self.get_nb_children()
 668         self.redraw(nbnew-nbold)
 669         child.select()
 670         if retour == 'oui': return child
 671
 672     def delete_node_child(self,child):
 673         """ Supprime child des enfants de self et les id associés """
 674         child.efface()
 675         child.displayed = 0
 676         self.children.remove(child)
 677         self.canvas.update()
 678
 679     def delete_child(self,child):
 680         """
 681             Supprime child des enfants de self, tous les id associés
 682             ET l'objet associé
 683         """
 684         if self.item.suppitem(child.item):
 685             self.delete_node_child(child)
 686             return 1
 687         else :
 688             return 0
 689
 690     def delete(self):
 691         """ Méthode externe pour la destruction du noeud ET de l'objet
 692             Gère l'update du canvas"""
 693         pere = self.parent
 694         nbold = pere.get_nb_children()
 695
 696         if self.parent.delete_child(self):
 697             if self.item.get_position() == 'global':
 698                 self.etape.verif_all()
 699             elif self.item.get_position() == 'global_jdc':
 700                 self.racine.verif_all()
 701             else:
 702                 self.parent.verif_condition()
 703         else:
 704             print 'Erreur dans la destruction de ',self.item.get_nom(),' dans delete'
 705
 706         nbnew = pere.get_nb_children()
 707         pere.redraw(nbnew-nbold)
 708         pere.select()
 709
 710     def doPaste(self,node_selected):
 711         self.appli.message="Vous ne pouvez copier que des commandes ou des mots-clés facteurs !"
 712         return 0
 713
 714     #--------------------------------------------------------------
 715     # Méthodes de vérification du contexte et de validité du noeud
 716     #--------------------------------------------------------------
 717     def verif_all(self):
 718         self.verif_all_children()
 719
 720     def verif_all_children(self):
 721         if not self.children : self.build_children()
 722         self.verif()
 723         for child in self.children :
 724             child.verif_all_children()
 725
 726     def verif(self) :
 727         """
 728             Lance la vérification des conditions des blocs de self et le cas
 729             échéant redessine self
 730         """
 731         nbold = self.get_nb_children()
 732         test = self.verif_condition()
 733         nbnew = self.get_nb_children()
 734         if test != 0 :
 735             self.redraw(nbnew-nbold)
 736
 737     def verif_condition(self):
 738         """
 739         on lance la vérification des conditions de chaque bloc de self
 740         on crée ou supprime les noeuds concernés
 741         (self est d'un niveau inférieur ou égal à l'ETAPE)
 742         """
 743         test = 0
 744         l_bloc_arajouter,l_bloc_aenlever = self.verif_condition_bloc()
 745         if len(l_bloc_arajouter) > 0:
 746             test = 1
 747             for mc in l_bloc_arajouter:
 748                 self.append_node_child(mc,verif='non')
 749         if len(l_bloc_aenlever) > 0:
 750             test = 1
 751             for mc in l_bloc_aenlever:
 752                 mocle = self.get_node_fils(mc)
 753                 self.delete_child(mocle)
 754         l_mc_presents = self.item.get_liste_mc_presents()
 755         l_mc_arajouter= self.verif_condition_regles(l_mc_presents)
 756         if len(l_mc_arajouter) > 0:
 757             test = 1
 758             for mc in l_mc_arajouter:
 759                 self.append_node_child(mc,verif='non')
 760         if len(l_mc_arajouter)+len(l_bloc_arajouter)+len(l_bloc_aenlever) != 0 :
 761             self.verif_condition()
 762         return test
 763
 764     def verif_condition_bloc(self):
 765         return self.item.verif_condition_bloc()
 766
 767     def verif_condition_regles(self,l_mc_presents):
 768         return self.item.verif_condition_regles(l_mc_presents)
 769
 770