Editeur/treewidget.py

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