Editeur/treewidget.py

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