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: V1_1p1 $"
  17 __Id__="$Id: treewidget.py,v 1.1.1.1 2001/12/04 15:38:23 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 self
 472             print self.item
 473             print self.item.object
 474             print self.item.object.definition.label
 475             print 'y=',self.y
 476             print 'dy=',dy
 477         # on déplace tous les items de dy
 478         self.canvas.move('move',0,dy)
 479         # il faut réactualiser la zone de scroll
 480         self.tree.resizescrollregion()
 481
 482     def trace_ligne(self):
 483         """ Dessine les lignes verticales entre frères et entre père et premier fils"""
 484         if self.state=='collapsed' : return
 485         #if self.displayed == 0 : return
 486         if len(self.children)==0 : return
 487         # on est bien dans le cas d'un noeud expansé avec enfants ...
 488         # il faut rechercher l'ordonnée du dernier fils de self
 489         y_end = self.children[-1].y
 490         ligne = self.canvas.create_line(self.x+15,self.y,self.x+15,y_end,tags='line')
 491         self.canvas.tag_lower(ligne)
 492         for child in self.children :
 493             try:
 494                 child.trace_ligne()
 495             except:
 496                 print child
 497                 print child.item.object
 498
 499     def make_visible_OBSOLETE(self,nb):
 500         """ Cette méthode a pour but de rendre le noeud self (avec tous ses descendants
 501         affichés) visible dans le canvas """
 502         x = self.canvas.canvasx(self.canvas.cget('width'))
 503         y = self.canvas.canvasy(self.canvas.cget('height'))
 504         #print 'x,y =',x,y
 505         x0,y0,x1,y1 = self.canvas.bbox(ALL)
 506         #print 'x0,y1=',x0,y1
 507         y_deb = self.y
 508         nb = self.get_nb_children()
 509         y_fin = y_deb + 20*nb
 510         #print 'y_deb,y_fin=',y_deb,y_fin
 511
 512     #------------------------------------------------------------------
 513     # Méthodes de création et destruction de noeuds
 514     # Certaines de ces méthodes peuvent être appelées depuis l'externe
 515     #------------------------------------------------------------------
 516     def replace_node(self,node1,node2):
 517         """ Remplace le noeud 1 par le noeud 2 dans la liste des enfants de self"""
 518         index= self.children.index(node1)
 519         self.delete_node_child(node1)
 520         self.children.insert(index,node2)
 521
 522     def full_creation(self,name,pos=None):
 523         """
 524         Interface avec ACCAS : création de l'objet de nom name et
 525         du noeud associé. Retourne le noeud fils ainsi créé
 526         """
 527         item = self.item.additem(name,pos)
 528         if item == None or item == 0:
 529             # impossible d'ajouter le noeud de nom : name
 530             return 0
 531         nature = item.get_nature()
 532         #if nature =="COMMANDE" or nature == "OPERATEUR" or nature == "PROCEDURE":
 533         if nature in ("COMMANDE","OPERATEUR","PROCEDURE","COMMENTAIRE",
 534                       "PARAMETRE","COMMANDE_COMMENTARISEE","PARAMETRE_EVAL"):
 535             # on veut ajouter une commande ou un commentaire ou un paramètre
 536             # il ne faut pas rechercher un même objet déjà existant
 537             # à modifier : il faut tester l'attribut 'repetable'
 538             enfant = None
 539         else :
 540             enfant = self.get_node_fils(item.get_nom())
 541         if enfant :
 542             # un fils de même nom existe déjà : on remplace
 543             # un MCFACT (ou une MCList) par une (autre) MCList
 544             child = Node(self,item,self.command)
 545             self.replace_node(enfant,child)
 546         else :
 547             child = Node(self, item,self.command)
 548             if pos is None:
 549                 self.children.append(child)
 550             else :
 551                 self.children.insert(pos,child)
 552         return child
 553
 554     def append_brother(self,name,pos='after',retour='non'):
 555         """
 556         Permet d'ajouter un frère à self
 557         par défaut on l'ajoute après self
 558         Méthode externe
 559         """
 560         # on veut ajouter le frère de nom name directement avant ou après self
 561         index = self.parent.children.index(self)
 562         if pos == 'before':
 563             index = index
 564         elif pos == 'after':
 565             index = index +1
 566         else:
 567             print str(pos)," n'est pas un index valide pour append_brother"
 568             return
 569         return self.parent.append_child(name,pos=index,retour=retour)
 570
 571     def append_node_child(self,fils,pos=None,verif='oui'):
 572         """
 573         Fait appel à la création complète de fils et à la vérification
 574         des conditions en fonction du contexte
 575         Attention : fils peut être un nom ou déjà un object (cas d'une copie)
 576         """
 577         if not self.children : self.build_children()
 578         if pos == None :
 579             #pos = len(self.children)
 580             if type(fils) == types.InstanceType:
 581                 pos = self.item.get_index_child(fils.nom)
 582             else:
 583                 pos = self.item.get_index_child(fils)
 584         child = self.full_creation(fils,pos)
 585         if child == 0 :
 586             # on n'a pas pu créer le noeud fils
 587             return 0
 588         child.displayed = 1
 589         self.state = 'expanded'
 590         if verif == 'oui':
 591             if not child.children : child.build_children()
 592             test = child.item.isMCList()
 593             if test :
 594                 child.children[-1].verif_condition()
 595             else :
 596                 child.verif_condition()
 597             self.verif_condition()
 598         return child
 599
 600     def append_child(self,name,pos=None,verif='oui',retour='non'):
 601         """
 602         Permet d'ajouter un fils à self
 603         on peut l'ajouter en fin de liste (défaut) ou en début
 604         Méthode externe
 605         """
 606         if pos == 'first':
 607             index = 0
 608         elif pos == 'last':
 609             index = len(self.children)
 610         elif pos != None and type(pos) == types.IntType :
 611             # on donne la position depuis l'extérieur
 612             # (appel de append_child par append_brother par exemple)
 613             index = pos
 614         else :
 615             if type(name) == types.InstanceType:
 616                 index = self.item.get_index_child(name.nom)
 617             else:
 618                 index = self.item.get_index_child(name)
 619         nbold = self.get_nb_children()
 620         self.state='expanded'
 621         child = self.append_node_child(name,pos=index)
 622         if child == 0 :
 623             # on n'a pas pu créer le fils
 624             return 0
 625         nbnew = self.get_nb_children()
 626         self.redraw(nbnew-nbold)
 627         child.select()
 628         child.expand()
 629         #child.make_visible()
 630         if retour == 'oui': return child
 631
 632     def delete_node_child(self,child):
 633         """ Supprime child des enfants de self et les id associés """
 634         child.efface()
 635         child.displayed = 0
 636         self.children.remove(child)
 637         self.canvas.update()
 638
 639     def delete_child(self,child):
 640         """
 641             Supprime child des enfants de self, tous les id associés
 642             ET l'objet associé
 643         """
 644         if self.item.suppitem(child.item):
 645             self.delete_node_child(child)
 646             return 1
 647         else :
 648             return 0
 649
 650     def delete(self):
 651         """ Méthode externe pour la destruction du noeud ET de l'objet
 652             Gère l'update du canvas"""
 653         if self.parent.item.isMCList():
 654             pere = self.parent.parent
 655             nbold = pere.get_nb_children()
 656             if self.parent.delete_child(self):
 657                 self.parent.traite_mclist()
 658             if self.item.get_position() == 'global':
 659                 self.etape.verif_all()
 660             elif self.item.get_position() == 'global_jdc':
 661                 self.racine.verif_all()
 662             else:
 663                 self.parent.verif_condition()
 664             nbnew = pere.get_nb_children()
 665         else:
 666             pere = self.parent
 667             nbold = pere.get_nb_children()
 668             if self.parent.delete_child(self):
 669                 if self.item.get_position() == 'global':
 670                     self.etape.verif_all()
 671                 elif self.item.get_position() == 'global_jdc':
 672                     self.racine.verif_all()
 673                 else:
 674                     self.parent.verif_condition()
 675             else :
 676                 print 'Erreur dans la destruction de ',self.item.get_nom(),' dans delete'
 677             nbnew = pere.get_nb_children()
 678         pere.redraw(nbnew-nbold)
 679
 680     def copynode(self,node,pos) :
 681         """ node est le noeud à copier à la position pos de self ( = parent de node) """
 682         objet_copie = node.item.get_copie_objet()
 683         child = self.full_creation(node.item,pos)
 684         child.displayed = node.displayed
 685         #child.image_id = node.image_id
 686         #child.label_id = node.label_id
 687         if child.item.get_nature() == "MCList":
 688             child.item.object[-1].mc_liste = objet_copie.mc_liste
 689         else :
 690             try :
 691                 child.item.object.mc_liste = objet_copie.mc_liste
 692             except:
 693                 pass
 694     #--------------------------------------------------------------
 695     # Méthodes de vérification du contexte et de validité du noeud
 696     #--------------------------------------------------------------
 697     def traite_mclist(self):
 698         """ Dans le cas d'une MCList il faut vérifier qu'elle n'est pas vide
 699             ou réduite à un seul élément suite à une destruction
 700         """
 701         # self représente une MCList
 702         if len(self.item) == 0 :
 703             # la liste est vide : il faut la supprimer
 704             self.delete()
 705         elif len(self.item) == 1:
 706             # il ne reste plus qu'un élément dans la liste
 707             # il faut supprimer la liste et créer directement l'objet
 708             index = self.parent.children.index(self)
 709             noeud = self.children[0]
 710             if self.parent.delete_child(self):
 711                 self.parent.append_node_child(noeud.item,pos=index,verif='non')
 712             #if self.parent.delete_child(self):
 713             #    self.parent.copynode(self.children[0],index)
 714             #else :
 715             #    print 'erreur dans la destruction de :',self.item.get_nom(),' dans traite_mclist'
 716         else :
 717             return
 718
 719     def verif_all(self):
 720         self.verif_all_children()
 721
 722     def verif_all_children(self):
 723         if not self.children : self.build_children()
 724         if self.nature != 'JDC' :
 725             self.verif()
 726         for child in self.children :
 727             child.verif_all_children()
 728
 729     def verif(self) :
 730         """
 731             Lance la vérification des conditions des blocs de self et le cas
 732             échéant redessine self
 733         """
 734         nbold = self.get_nb_children()
 735         test = self.verif_condition()
 736         nbnew = self.get_nb_children()
 737         if test != 0 :
 738             self.redraw(nbnew-nbold)
 739
 740     def verif_condition(self):
 741         """
 742         on lance la vérification des conditions de chaque bloc de self
 743         on crée ou supprime les noeuds concernés
 744         (self est d'un niveau inférieur ou égal à l'ETAPE)
 745         """
 746         if self.item.object.__class__.__name__ == 'ETAPE_NIVEAU': return 0
 747         test = 0
 748         l_bloc_arajouter,l_bloc_aenlever = self.verif_condition_bloc()
 749         if len(l_bloc_arajouter) > 0:
 750             test = 1
 751             for mc in l_bloc_arajouter:
 752                 self.append_node_child(mc,verif='non')
 753         if len(l_bloc_aenlever) > 0:
 754             test = 1
 755             for mc in l_bloc_aenlever:
 756                 mocle = self.get_node_fils(mc)
 757                 self.delete_child(mocle)
 758         l_mc_presents = self.item.get_liste_mc_presents()
 759         l_mc_arajouter= self.verif_condition_regles(l_mc_presents)
 760         if len(l_mc_arajouter) > 0:
 761             test = 1
 762             for mc in l_mc_arajouter:
 763                 self.append_node_child(mc,verif='non')
 764         if len(l_mc_arajouter)+len(l_bloc_arajouter)+len(l_bloc_aenlever) != 0 :
 765             self.verif_condition()
 766         return test
 767
 768     def verif_condition_bloc(self):
 769         return self.item.verif_condition_bloc()
 770
 771     def verif_condition_regles(self,l_mc_presents):
 772         return self.item.verif_condition_regles(l_mc_presents)
 773
 774