InterfaceQT4/browser.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 from __future__ import absolute_import
  22 from __future__ import print_function
  23 try :
  24    from builtins import str
  25    from builtins import range
  26 except : pass
  27 import re
  28 import types,sys,os
  29 import traceback
  30 from . import typeNode
  31 #import pdb
  32
  33 import six
  34 from six.moves import range
  35 from PyQt5.QtWidgets import QTreeWidget , QTreeWidgetItem, QApplication, QMessageBox
  36 from PyQt5.QtGui import QIcon
  37 from PyQt5.QtCore  import Qt
  38 from Extensions.i18n import tr
  39 from .gereRegles import GereRegles
  40 from .monChoixCommande import MonChoixCommande
  41
  42 class JDCTree( QTreeWidget,GereRegles ):
  43     def __init__( self, jdc_item, QWParent):
  44         #if hasattr(QWParent,'widgetTree') :
  45         self.editor        = QWParent
  46         self.plie=False
  47         if self.editor.widgetTree !=None  :
  48            QTreeWidget.__init__(self, self.editor.widgetTree )
  49            self.editor.verticalLayout_2.addWidget(self)
  50            if self.editor.enteteQTree=='complet':
  51                  self.headerItem().setText(0,  "Commande   ")
  52                  self.headerItem().setText(1, "Concept/Valeur")
  53            else :
  54                  self.headerItem().setText(0,  "Commande   ")
  55            self.setColumnWidth(0,200)
  56            self.setExpandsOnDoubleClick(False)
  57            self.setSelectionMode(3)
  58         else :
  59            QTreeWidget.__init__(self, None )
  60         self.item          = jdc_item
  61         self.tree          = self
  62         self.appliEficas   = self.editor.appliEficas
  63         self.childrenComplete=[]
  64         self.racine=self.item.itemNode(self,self.item)
  65
  66         self.itemCourrant=None
  67
  68         self.itemClicked.connect(self.handleOnItem)
  69         self.itemCollapsed.connect(self.handleCollapsedItem)
  70         self.itemExpanded.connect(self.handleExpandedItem)
  71
  72         #PNPNPN verifier dans quel cas on se trouve : affiche l arbre ou la commande
  73         self.node_selected=self.racine
  74         self.inhibeExpand=True
  75         self.expandItem(self.racine)
  76         self.inhibeExpand=False
  77         #print "self.editor.afficheCommandesPliees", self.editor.afficheCommandesPliees
  78         if self.racine.children !=[] :
  79            #self.editor.initSplitterSizes(3)
  80            if self.editor.afficheCommandesPliees : self.racine.children[0].plieToutEtReaffiche()
  81            else : self.racine.children[0].deplieToutEtReaffiche()
  82            self.racine.children[0].fenetre.donnePremier()
  83         else :
  84           #self.editor.initSplitterSizes(2)
  85           self.racine.affichePanneau()
  86           #print self.editor.splitter.sizes()
  87         #PNPNPN
  88         #pdb.set_trace()
  89
  90     def contextMenuEvent(self,event) :
  91         #print "contextMenuEvent"
  92         coord=event.globalPos()
  93         item= self.currentItem()
  94         self.handleContextMenu(item,coord)
  95
  96     def handleContextMenu(self,item,coord):
  97         """
  98         Private slot to show the context menu of the listview.
  99
 100         @param itm the selected listview item (QListWidgetItem)
 101         @param coord the position of the mouse pointer (QPoint)
 102         Attention : existeMenu permet de savoir si un menu est associe a cet item
 103         """
 104         #print "handleContextMenu"
 105         if item == None : return
 106         if item.existeMenu == 0 : return
 107         if item.menu == None:
 108            item.createPopUpMenu()
 109         if item.menu != None:
 110            if item.item.get_nom() == "DISTRIBUTION" and item.item.isvalid() :
 111               item.Graphe.setEnabled(1)
 112            item.menu.exec_(coord)
 113
 114
 115     def handleCollapsedItem(self,item):
 116         #print "dans CollapsedItem", self.inhibeExpand
 117         if self.inhibeExpand == True : return
 118         # On traite le cas de l item non selectionne
 119         itemParent=item
 120         while not (hasattr (itemParent,'getPanel')) :
 121            itemParent=itemParent.treeParent
 122         if self.tree.node_selected != itemParent :
 123              item.setExpanded(False)
 124              return
 125
 126         itemParent=item
 127         item.setPlie()
 128         item.plieToutEtReaffiche()
 129         item.select()
 130
 131     def handleExpandedItem(self,item):
 132         #print "handleExpandedItem pour ", item.item.nom, self.inhibeExpand
 133         #import traceback
 134         #traceback.print_stack()
 135         if self.inhibeExpand == True : return
 136         self.inhibeExpand = True
 137         itemParent=item
 138         while not (hasattr (itemParent,'getPanel')) :
 139            if itemParent.plie==True : itemParent.setDeplie()
 140            itemParent=itemParent.treeParent
 141         if self.tree.node_selected != itemParent :
 142              item.setExpanded(True)
 143              self.inhibeExpand = False
 144              return
 145         item.deplieToutEtReaffiche()
 146         self.inhibeExpand = False
 147
 148
 149     def handleOnItem(self,item,int):
 150         #print "je passe dans handleOnItem pour ",self, item.item.nom, item, item.item
 151
 152         from InterfaceQT4 import composimp
 153         self.inhibeExpand = True
 154         self.itemCourrant=item
 155         itemParent=item
 156
 157         while not (hasattr (itemParent,'getPanel')) :
 158            if itemParent.plie==True : itemParent.setDeplie()
 159            itemParent=itemParent.treeParent
 160
 161         if itemParent.fenetre != self.editor.fenetreCentraleAffichee :
 162
 163             estUneFeuille=(isinstance(item,composimp.Node))
 164              # il faut afficher le parent
 165             #print "estUneFeuille", estUneFeuille
 166             #print "afficheCommandesPliees", self.editor.afficheCommandesPliees
 167             if estUneFeuille                        : itemParent.affichePanneau()
 168             elif self.editor.afficheCommandesPliees : itemParent.plieToutEtReafficheSaufItem(item)
 169             else                                    : itemParent.affichePanneau()
 170
 171
 172         elif (isinstance(item,composimp.Node)) and item.fenetre : item.fenetre.rendVisible()
 173         elif itemParent!=item:
 174              self.tree.handleExpandedItem(item)
 175              #item.fenetre.donnePremier()
 176              #item.fenetre.rendActif()
 177              #print 'il faut afficher le 1er'
 178
 179         try :
 180            fr = item.item.get_fr()
 181            if self.editor: self.editor.affiche_commentaire(six.text_type(fr))
 182         except:
 183             pass
 184         item.select()
 185         self.inhibeExpand = False
 186         #print "je mets inhibeExpand a false handleOnItem"
 187
 188
 189     def choisitPremier(self,name):
 190         self.editor.layoutJDCCHOIX.removeWidget(self.racine.fenetre)
 191         self.racine.fenetre.close()
 192         new_node=self.racine.append_brother(name,'after')
 193
 194 # type de noeud
 195 COMMENT     = "COMMENTAIRE"
 196 PARAMETERS  = "PARAMETRE"
 197
 198 class JDCNode(QTreeWidgetItem,GereRegles):
 199     def __init__( self, treeParent, item, itemExpand=False, ancien=False ):
 200         #print "creation d'un noeud : ", item, " ",item.nom,"", treeParent, self
 201         #self.a=0
 202         self.item        = item
 203         self.vraiParent  = treeParent
 204         self.treeParent  = treeParent
 205         self.tree        = self.treeParent.tree
 206         self.editor      = self.treeParent.editor
 207         self.appliEficas = treeParent.appliEficas
 208         self.JESUISOFF=0
 209         self.childrenComplete=[]
 210
 211
 212         from InterfaceQT4 import compocomm
 213         from InterfaceQT4 import compoparam
 214         from InterfaceQT4 import composimp
 215         if   (isinstance(self.item,compocomm.COMMTreeItem)) : name=tr("Commentaire")
 216         elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name=tr(str(item.GetLabelText()[0]))
 217         else:   name  = tr(str(tr(item.GetLabelText()[0]))+" :")
 218         if item.GetLabelText()  != item.nom and item.nom != tr(item.nom) : name = str(tr(item.nom))
 219         value = tr(str( item.GetText() ) )
 220
 221
 222         if self.editor.enteteQTree=='complet':mesColonnes=(name,value)
 223         else : mesColonnes=(name,)
 224
 225         if self.treeParent.plie==True :
 226             self.plie        = True
 227             self.appartientAUnNoeudPlie=True
 228             if self.treeParent.item.isMCList() : self.appartientAUnNoeudPlie =  self.treeParent.appartientAUnNoeudPlie
 229         else :
 230             self.plie        = False
 231             self.appartientAUnNoeudPlie = False
 232
 233         #if item.nom == "POUTRE" :print "creation d'un noeud : ", item, " ",item.nom,"", self.treeParent, self.appartientAUnNoeudPlie , self.plie
 234
 235         if ancien and itemExpand     : self.plie = False
 236         if ancien and not itemExpand : self.plie = True
 237         if (isinstance(self.item,composimp.SIMPTreeItem)) : self.plie=False
 238
 239         from InterfaceQT4 import compobloc
 240         from InterfaceQT4 import compomclist
 241
 242         ajoutAuParentduNoeud=0
 243         self.treeParent=treeParent
 244         while (isinstance(self.treeParent,compobloc.Node) or ( isinstance(self.treeParent,compomclist.Node) and self.treeParent.item.isMCList())) :
 245               self.treeParent.childrenComplete.append(self)
 246               self.treeParent=self.treeParent.vraiParent
 247         self.treeParent.childrenComplete.append(self)
 248
 249
 250         if (isinstance(self,compobloc.Node) or (isinstance(self,compomclist.Node) and self.item.isMCList()) or ( hasattr(self.item.parent,'inhibeValidator') and isinstance(self,compomclist.Node) and self.item.parent.inhibeValidator)) :
 251         # Le dernier or ne sert que lorsqu'on est en train de creer une liste par les validator
 252            QTreeWidgetItem.__init__(self,None,mesColonnes)
 253         else :
 254            QTreeWidgetItem.__init__(self,self.treeParent,mesColonnes)
 255
 256         self.setToolTip(0,self.item.get_fr())
 257         self.setToolTip(1,self.item.get_fr())
 258         repIcon=self.appliEficas.repIcon
 259
 260         monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
 261         self.setIcon(0,monIcone)
 262
 263         self.children = []
 264         self.build_children()
 265         self.menu=None
 266         self.existeMenu=1
 267
 268         self.item.connect("valid",self.onValid,())
 269         self.item.connect("supp" ,self.onSupp,())
 270         self.item.connect("add"  ,self.onAdd,())
 271
 272         self.state=""
 273         self.fenetre=None
 274         try :
 275           if self.item.getObject().isBLOC() :
 276                 self.setExpanded(True)
 277                 self.plie=False
 278         except :
 279           pass
 280
 281
 282     def build_children(self,posInsertion=10000):
 283         """ Construit la liste des enfants de self """
 284         """ Se charge de remettre les noeuds Expanded dans le meme etat """
 285         #print "*********** build_children ",self,self.item, self.item.nom
 286
 287         self.listeItemExpanded=[]
 288         self.listeItemPlie=[]
 289
 290         for enfant in self.childrenComplete :
 291             if enfant.plie : self.listeItemPlie.append(enfant.item)
 292             else : self.listeItemExpanded.append(enfant.item)
 293
 294         for enfant in self.childrenComplete :
 295             parent=enfant.treeParent
 296             parent.removeChild(enfant)
 297             enfant.JESUISOFF=1
 298
 299
 300         self.children = []
 301         self.childrenComplete = []
 302         sublist = self.item._GetSubList()
 303         ind=0
 304
 305         for item in sublist :
 306             itemExpand=False
 307             ancien=False
 308             if item in self.listeItemExpanded : itemExpand=True;  ancien=True
 309             if item in self.listeItemPlie     : itemExpand=False; ancien=True
 310             nouvelItem=item.itemNode(self,item,itemExpand,ancien)
 311             self.children.append(nouvelItem)
 312
 313         #print "fin *********** build_children ",self,self.item, self.item.nom, self.children
 314
 315
 316     def chercheNoeudCorrespondant(self,objSimp):
 317         sublist = self.item._GetSubList()
 318         for node in self.childrenComplete:
 319             if node.item.object==objSimp : return node
 320         return None
 321
 322
 323     def affichePanneau(self) :
 324         #if self.editor.code == 'ASTER' and not(self.item.isactif()) :
 325         # posera des pb si un code decide d appeler FIN un mot clef
 326         # on resoudera a ce moment la
 327         # pour l instant pas de poussiere sous le tapis
 328         #print( 'debut affichePanneau pour', self.item.nom)
 329         if  not(self.item.isactif()) :
 330             from .monWidgetInactif import MonWidgetInactif
 331             self.fenetre = MonWidgetInactif(self,self.editor)
 332         else:
 333            itemParent=self
 334            while not (hasattr (itemParent,'getPanel')) : itemParent=itemParent.treeParent
 335            if itemParent!=self :
 336               itemParent.affichePanneau()
 337               return
 338            self.fenetre=self.getPanel()
 339            #self.editor.restoreSplitterSizes()
 340
 341         for indiceWidget in range(self.editor.widgetCentraleLayout.count()):
 342             widget=self.editor.widgetCentraleLayout.itemAt(indiceWidget)
 343             self.editor.widgetCentraleLayout.removeItem(widget)
 344         # ceinture et bretelle
 345         #print 'old fenetre = ',self.editor.fenetreCentraleAffichee
 346         if self.editor.fenetreCentraleAffichee != None :
 347             self.editor.widgetCentraleLayout.removeWidget(self.editor.fenetreCentraleAffichee)
 348             self.editor.fenetreCentraleAffichee.setParent(None)
 349             self.editor.fenetreCentraleAffichee.close()
 350             self.editor.fenetreCentraleAffichee.deleteLater()
 351
 352         self.editor.widgetCentraleLayout.addWidget(self.fenetre)
 353         #print ("j ajoute ", self.fenetre, self.fenetre.node.item.nom)
 354         self.editor.fenetreCentraleAffichee=self.fenetre
 355         self.tree.node_selected= self
 356
 357         if self.editor.first :
 358            if not(isinstance(self.fenetre,MonChoixCommande)): self.editor.first=False
 359         self.tree.inhibeExpand=True
 360         self.tree.expandItem(self)
 361         self.tree.inhibeExpand=False
 362         #print( 'fin affichePanneau pour', self.item.nom)
 363
 364
 365     def createPopUpMenu(self):
 366         #implemente dans les noeuds derives si necessaire
 367         self.existeMenu = 0
 368
 369     def commentIt(self):
 370         """
 371         Cette methode a pour but de commentariser la commande pointee par self
 372         """
 373         # On traite par une exception le cas ou l'utilisateur final cherche a desactiver
 374         # (commentariser) un commentaire.
 375         try :
 376             pos=self.treeParent.children.index(self)
 377             commande_comment = self.item.get_objet_commentarise()
 378             # On signale a l editeur du panel (le JDCDisplay) une modification
 379             self.editor.init_modif()
 380             self.treeParent.build_children()
 381             self.treeParent.children[pos].select()
 382             self.treeParent.children[pos].affichePanneau()
 383         except Exception as e:
 384             traceback.print_exc()
 385             QMessageBox.critical( self.editor, "TOO BAD",str(e))
 386
 387     def unCommentIt(self):
 388         """
 389         Realise la decommentarisation de self
 390         """
 391         try :
 392             pos=self.treeParent.children.index(self)
 393             commande,nom = self.item.uncomment()
 394             self.editor.init_modif()
 395             self.treeParent.build_children()
 396             self.treeParent.children[pos].select()
 397             self.treeParent.children[pos].affichePanneau()
 398         except Exception as e:
 399             QMessageBox.critical( self.editor, "Erreur !",str(e))
 400
 401     def addComment( self, after=True ):
 402         """
 403         Ajoute un commentaire a l'interieur du JDC :
 404         """
 405         self.editor.init_modif()
 406         if after:
 407             pos = 'after'
 408         else:
 409             pos = 'before'
 410         return self.append_brother( COMMENT, pos )
 411
 412     def addParameters( self, after=True ):
 413         """
 414         Ajoute un parametre a l'interieur du JDC :
 415         """
 416         self.editor.init_modif()
 417         if after: pos = 'after'
 418         else: pos = 'before'
 419         child=self.append_brother( PARAMETERS, pos )
 420         return  child
 421
 422
 423     def select( self ):
 424         """
 425         Rend le noeud courant (self) selectionne et deselectionne
 426         tous les autres
 427         """
 428         #print "select pour", self.item.nom
 429         for item in self.tree.selectedItems() :
 430             item.setSelected(0)
 431         self.tree.setCurrentItem( self )
 432
 433     #------------------------------------------------------------------
 434     # Methodes de creation et destruction de noeuds
 435     # Certaines de ces methodes peuvent etre appelees depuis l'externe
 436     #------------------------------------------------------------------
 437     def append_brother(self,name,pos='after',plier=False):
 438         """
 439         Permet d'ajouter un objet frere a l'objet associe au noeud self
 440         par defaut on l'ajoute immediatement apres
 441         Methode externe
 442         """
 443         self.editor.init_modif()
 444
 445         from InterfaceQT4 import compojdc
 446         if (isinstance(self.treeParent, compojdc.Node)) and not self.verifiePosition(name,pos)  : return 0
 447
 448         if self.treeParent != self.vraiParent :
 449           index = self.vraiParent.children.index(self)
 450           if   pos == 'before': index = index
 451           elif pos == 'after': index = index +1
 452           return self.vraiParent.append_child(name,pos=index,plier=plier)
 453         else :
 454           index = self.treeParent.children.index(self)
 455           if   pos == 'before': index = index
 456           elif pos == 'after': index = index +1
 457           else:
 458               print(six.text_type(pos), tr("  n'est pas un index valide pour append_brother"))
 459               return 0
 460           return self.treeParent.append_child(name,pos=index,plier=plier)
 461
 462     def verifiePosition(self,name,pos,aLaRacine=False):
 463         if name not in self.editor.Classement_Commandes_Ds_Arbre : return True
 464         indexName=self.editor.Classement_Commandes_Ds_Arbre.index(name)
 465
 466         etapes=self.item.get_jdc().etapes
 467         if etapes == [] : return True
 468
 469         if aLaRacine == False :indexOu=etapes.index(self.item.object)
 470         else : indexOu=0
 471
 472         if pos=="after" : indexOu = indexOu+1
 473         for e in etapes[:indexOu] :
 474             nom=e.nom
 475             if nom not in self.editor.Classement_Commandes_Ds_Arbre : continue
 476             indexEtape=self.editor.Classement_Commandes_Ds_Arbre.index(nom)
 477             if indexEtape > indexName :
 478                comment=tr('le mot clef ')+name+tr(' doit etre insere avant ')+nom
 479                QMessageBox.information( None,tr('insertion impossible'),comment, )
 480                return False
 481         for e in etapes[indexOu:] :
 482             nom=e.nom
 483             if nom not in self.editor.Classement_Commandes_Ds_Arbre : continue
 484             indexEtape=self.editor.Classement_Commandes_Ds_Arbre.index(nom)
 485             if indexEtape < indexName :
 486                comment=tr('le mot clef ')+name+tr(' doit etre insere apres ')+nom
 487                QMessageBox.information( None,tr('insertion impossible'),comment, )
 488                return False
 489         return True
 490
 491     def append_child(self,name,pos=None,plier=False):
 492         """
 493            Methode pour ajouter un objet fils a l'objet associe au noeud self.
 494            On peut l'ajouter en debut de liste (pos='first'), en fin (pos='last')
 495            ou en position intermediaire.
 496            Si pos vaut None, on le place a la position du catalogue.
 497         """
 498         #print ("************** append_child ",self.item.GetLabelText(), plier)
 499         #import traceback
 500         #traceback.print_stack()
 501
 502
 503         self.editor.init_modif()
 504         if pos == 'first':
 505             index = 0
 506         elif pos == 'last':
 507             index = len(self.children)
 508         elif type(pos) == int :
 509             # position fixee
 510             index = pos
 511         elif type(pos) == types.InstanceType:
 512             # pos est un item. Il faut inserer name apres pos
 513             index = self.item.get_index(pos) +1
 514         elif type(name) == types.InstanceType:
 515             index = self.item.get_index_child(name.nom)
 516         else:
 517             index = self.item.get_index_child(name)
 518
 519         # si on essaye d inserer a la racine
 520         if (isinstance(self.treeParent,JDCTree) and index==0) :
 521            verifiePosition=self.verifiePosition(name,'first',aLaRacine=True)
 522            if not verifiePosition : return 0
 523
 524         self.tree.inhibeExpand=True
 525         obj=self.item.additem(name,index) # emet le signal 'add'
 526         if obj is None:obj=0
 527         if obj == 0:return 0
 528         try :
 529            child=self.children[index]
 530            if plier == True : child.setPlie()
 531            else             : child.setDeplie()
 532         except :
 533            child=self.children[index]
 534         self.tree.inhibeExpand=False
 535         #print (" fin append child")
 536         return child
 537
 538     def deplace(self):
 539         self.editor.init_modif()
 540         index = self.treeParent.children.index(self) - 1
 541         if index < 0 : index =0
 542         ret=self.treeParent.item.deplaceEntite(self.item.getObject())
 543
 544     def delete(self):
 545         """
 546             Methode externe pour la destruction de l'objet associe au noeud
 547         """
 548         self.editor.init_modif()
 549         index = self.vraiParent.children.index(self) - 1
 550         if index < 0 : index =0
 551         recalcule=0
 552         if self.item.nom == "VARIABLE" :
 553            recalcule=1
 554            jdc=self.item.jdc
 555         ret,commentaire=self.vraiParent.item.suppitem(self.item)
 556         if ret==0 :
 557           self.editor.affiche_infos(commentaire,Qt.red)
 558         else :
 559           self.editor.affiche_infos(commentaire)
 560         self.treeParent.build_children()
 561         if self.treeParent.childrenComplete : toselect=self.treeParent.childrenComplete[index]
 562         else: toselect=self.treeParent
 563         if recalcule : jdc.recalcule_etat_correlation()
 564         if ret==0 :
 565             if self.treeParent.childrenComplete :
 566                 notdeleted=self.treeParent.childrenComplete[index+1]
 567                 notdeleted.select()
 568         else :
 569             toselect.select()
 570         from InterfaceQT4 import compojdc
 571         # cas ou on detruit dans l arbre sans affichage
 572         if isinstance(self.treeParent,compojdc.Node) :
 573            toselect.affichePanneau()
 574         else :
 575            if self.treeParent.fenetre== None : return
 576            #print "J appelle reaffiche de browser apres delete"
 577            self.treeParent.fenetre.reaffiche(toselect)
 578
 579     def deleteMultiple(self,liste=()):
 580         """
 581             Methode externe pour la destruction d une liste de noeud
 582         """
 583         from InterfaceQT4 import compojdc
 584         self.editor.init_modif()
 585         index=9999
 586         recalcule=0
 587         jdc=self.treeParent
 588         parentPosition=jdc
 589         while not(isinstance(jdc,compojdc.Node)):
 590               jdc=jdc.treeParent
 591         for noeud in liste :
 592             if not( isinstance(noeud.treeParent, compojdc.Node)): continue
 593             if noeud.item.nom == "VARIABLE" : recalcule=1
 594             if noeud.treeParent.children.index(noeud) < index : index=noeud.treeParent.children.index(noeud)
 595         if index < 0 : index =0
 596
 597         # Cas ou on detruit dans une ETape
 598         if index == 9999 :
 599               parentPosition=self.treeParent
 600               while not(isinstance(parentPosition, compojdc.Node)):
 601                  index=parentPosition.treeParent.children.index(parentPosition)
 602                  parentPosition=parentPosition.treeParent
 603
 604         for noeud in liste:
 605             noeud.treeParent.item.suppitem(noeud.item)
 606
 607         jdc.build_children()
 608         if recalcule : jdc.recalcule_etat_correlation()
 609         try    : toselect=parentPosition.children[index]
 610         except : toselect=jdc
 611         toselect.select()
 612         toselect.affichePanneau()
 613 #
 614 #    #------------------------------------------------------------------
 615     def onValid(self):
 616
 617         #print "onValid pour ", self.item.nom
 618         if self.JESUISOFF==1 : return
 619         if hasattr(self,'fenetre') and self.fenetre:
 620            try :
 621              self.fenetre.setValide()
 622            except :
 623             # print "onValid pour ", self.item.nom, self,'pb'
 624             pass
 625
 626         if (self.item.nom == "VARIABLE" or self.item.nom == "DISTRIBUTION") and self.item.isvalid():
 627            self.item.jdc.recalcule_etat_correlation()
 628         if hasattr(self.item,'forceRecalcul'):
 629            self.forceRecalculChildren(self.item.forceRecalcul)
 630         self.editor.init_modif()
 631
 632         self.update_node_valid()
 633         self.update_node_label()
 634         self.update_node_texte()
 635
 636     def onAdd(self,object):
 637         if self.JESUISOFF==1 : return
 638         #print "onAdd pour ", self.item.nom, object.nom
 639         self.editor.init_modif()
 640         self.update_nodes()
 641         # PN -- non necessaire si item=jdc
 642         if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
 643
 644     def onSupp(self,object):
 645         if self.JESUISOFF==1 : return
 646         #print "onSup pour ", self.item.nom, object.nom
 647         self.editor.init_modif()
 648         self.update_nodes()
 649         # PN -- non necessaire si item=jdc
 650         if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
 651
 652
 653
 654     def update_node_valid(self):
 655         """Cette methode remet a jour la validite du noeud (icone)
 656            Elle appelle isvalid
 657         """
 658         repIcon=self.appliEficas.repIcon
 659         monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
 660         self.setIcon(0,monIcone)
 661
 662
 663     def update_node_label(self):
 664         """ Met a jour le label du noeud """
 665         #print "NODE update_node_label", self.item.GetLabelText()
 666         labeltext,fonte,couleur = self.item.GetLabelText()
 667         # PNPN a reflechir
 668         self.setText(0, labeltext)
 669
 670     def update_node_label_in_black(self):
 671         if hasattr(self.appliEficas,'noeudColore'):
 672             self.appliEficas.noeudColore.setForeground(0,Qt.black)
 673             self.appliEficas.noeudColore.update_node_label
 674
 675     def update_node_label_in_blue(self):
 676         if hasattr(self.appliEficas,'noeudColore'): self.appliEficas.noeudColore.setForeground(0,Qt.black)
 677         self.setForeground(0,Qt.blue)
 678         labeltext,fonte,couleur = self.item.GetLabelText()
 679         self.setText(0, labeltext)
 680         self.appliEficas.noeudColore=self
 681
 682     def update_plusieurs_node_label_in_blue(self,liste):
 683         if hasattr(self.appliEficas,'listeNoeudsColores'):
 684            for noeud in self.appliEficas.listeNoeudsColores:
 685                noeud.setTextColor( 0,Qt.black)
 686                noeud.update_node_label()
 687         self.appliEficas.listeNoeudsColores=[]
 688         for noeud in liste :
 689             noeud.setTextColor( 0,Qt.blue )
 690             labeltext,fonte,couleur = noeud.item.GetLabelText()
 691             noeud.setText(0, labeltext)
 692             self.appliEficas.listeNoeudsColores.append(noeud)
 693
 694     def update_node_texte_in_black(self):
 695         """ Met a jour les noms des SD et valeurs des mots-cles """
 696         self.setTextColor( 1,Qt.black )
 697         value = self.item.GetText()
 698         self.setText(1, value)
 699
 700     def update_node_texte(self):
 701         """ Met a jour les noms des SD et valeurs des mots-cles """
 702         value = self.item.GetText()
 703         self.setText(1, value)
 704
 705
 706     def update_node_texte_in_blue(self):
 707         self.setTextColor( 1,Qt.blue )
 708         value = self.item.GetText()
 709         self.setText(1, value)
 710
 711     def update_nodes(self):
 712         #print 'NODE update_nodes', self.item.GetLabelText()
 713         self.build_children()
 714
 715     def update_valid(self) :
 716         """Cette methode a pour but de mettre a jour la validite du noeud
 717            et de propager la demande de mise a jour a son parent
 718         """
 719         #print "NODE update_valid", self.item.GetLabelText()
 720         self.update_node_valid()
 721         try :
 722           self.treeParent.update_valid()
 723         except:
 724           pass
 725
 726     def update_texte(self):
 727         """ Met a jour les noms des SD et valeurs des mots-cles """
 728         #print "NODE update_texte", self.item.GetLabelText()
 729         self.update_node_texte()
 730         if self.isExpanded() :
 731             for child in self.children:
 732                 if child.isHidden() == false : child.update_texte()
 733
 734
 735     def forceRecalculChildren(self,niveau):
 736         if self.state=='recalcule' :
 737            self.state=""
 738            return
 739         self.state='recalcule'
 740         if hasattr(self.item,'object'):
 741            self.item.object.state="modified"
 742         for child in self.children:
 743            if niveau > 0 : child.forceRecalculChildren(niveau - 1)
 744
 745
 746
 747     def doPaste(self,node_selected,pos='after'):
 748         """
 749             Declenche la copie de l'objet item avec pour cible
 750             l'objet passe en argument : node_selected
 751         """
 752         objet_a_copier = self.item.get_copie_objet()
 753         child=node_selected.doPasteCommande(objet_a_copier,pos)
 754         if self.editor.fenetreCentraleAffichee : self.editor.fenetreCentraleAffichee.node.affichePanneau()
 755         self.update_node_label_in_black()
 756         return child
 757
 758     def doPasteCommande(self,objet_a_copier,pos='after'):
 759         """
 760           Realise la copie de l'objet passe en argument qui est necessairement
 761           un onjet
 762         """
 763         child=None
 764         try :
 765         #if 1 :
 766           child = self.append_brother(objet_a_copier,pos)
 767         except :
 768            pass
 769         return child
 770
 771     def doPastePremier(self,objet_a_copier):
 772         """
 773            Realise la copie de l'objet passe en argument (objet_a_copier)
 774         """
 775         objet = objet_a_copier.item.get_copie_objet()
 776         child = self.append_child(objet,pos='first')
 777         return child
 778
 779     def plieToutEtReafficheSaufItem(self, itemADeplier):
 780         #print "je suis dans plieToutEtReaffiche", self.item.get_nom()
 781         self.inhibeExpand=True
 782         from InterfaceQT4 import compojdc
 783         if (isinstance(self, compojdc.Node)) :
 784             self.affichePanneau()
 785             self.inhibeExpand=False
 786             return
 787         self.editor.deplier = False
 788         for item in self.children :
 789             # il ne faut pas plier les blocs
 790             from InterfaceQT4 import compobloc
 791             if (isinstance(item,compobloc.Node)) : continue
 792             item.setPlie()
 793             if item==itemADeplier :
 794                   itemADeplier.setDeplie()
 795         self.affichePanneau()
 796         self.inhibeExpand=False
 797
 798     def plieToutEtReaffiche(self):
 799         from InterfaceQT4 import compojdc
 800         if (isinstance(self, compojdc.Node)) : self.affichePanneau(); return
 801         self.inhibeExpand=True
 802         self.editor.deplier = False
 803         for item in self.children :
 804             # il ne faut pas plier les blocs
 805             from InterfaceQT4 import compobloc
 806             if (isinstance(item,compobloc.Node)) : continue
 807             item.setPlie()
 808         self.affichePanneau()
 809
 810     def deplieToutEtReaffiche(self):
 811         self.editor.deplier = True
 812         for item in self.children :
 813             item.setDeplie()
 814         self.affichePanneau()
 815
 816     def setPlie(self):
 817         #print "je mets inhibeExpand a true dans setPlie"
 818         #print "je suis dans plieTout", self.item.get_nom()
 819         from . import compojdc
 820         if self.fenetre == self.editor.fenetreCentraleAffichee  and isinstance(self.treeParent,compojdc.Node):
 821            return
 822         self.tree.inhibeExpand=True
 823         self.tree.collapseItem(self)
 824         self.setPlieChildren()
 825         self.tree.inhibeExpand=False
 826         #print "je mets inhibeExpand a false dans setPlie"
 827
 828
 829         # on ne plie pas au niveau 1
 830         #   self.plie=False
 831         #   for item in self.children :
 832         #       item.appartientAUnNoeudPlie=False
 833
 834     def setPlieChildren(self):
 835         #print "dans setPlieChildren pour", self.item.nom
 836         self.plie=True
 837         for c in self.children :
 838             c.setPlieChildren()
 839             #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.GetLabelText()[0]
 840             c.appartientAUnNoeudPlie=True
 841             c.plie=True
 842             #print "dans setPlieChildren plie", c.item.nom
 843             c.setExpanded(False)
 844
 845         # Pour les blocs et les motcles list
 846         # on affiche un niveau de plus
 847         from InterfaceQT4 import compobloc
 848         from InterfaceQT4 import compomclist
 849         if (isinstance(self,compobloc.Node) or ( isinstance(self,compomclist.Node) and self.item.isMCList())) :
 850             niveauPere=self.treeParent
 851             while (isinstance(niveauPere,compobloc.Node) or (isinstance(niveauPere,compomclist.Node) and niveauPere.item.isMCList())) :
 852                niveauPere=niveauPere.treeParent
 853             for c in self.children :
 854                 c.appartientAUnNoeudPlie=niveauPere.appartientAUnNoeudPlie
 855                 #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.GetLabelText()[0], "mis a la valeur ", niveauPere.appartientAUnNoeudPlie
 856                 c.setExpanded(False)
 857
 858         # on affiche un niveau de plus
 859         #if isinstance(self,compomclist.Node)  :
 860         #if isinstance(self,compobloc.Node)  :
 861         #    niveauPere=self.treeParent
 862         #    while (isinstance(niveauPere,compobloc.Node)):
 863         #       niveauPere=niveauPere.treeParent
 864         #    for c in self.children :
 865         #        c.appartientAUnNoeudPlie=niveauPere.appartientAUnNoeudPlie
 866
 867     def setDeplie(self):
 868         #print "dans setPlieChildren pour", self.item.nom
 869         #print "je mets inhibeExpand a true dans setDeplie"
 870         self.tree.inhibeExpand=True
 871         self.plie=False
 872         self.tree.expandItem(self)
 873         self.setDeplieChildren()
 874         self.tree.inhibeExpand=False
 875         #print "je mets inhibeExpand a false dans setDePlie"
 876
 877     def setDeplieChildren(self):
 878         #print "dans setDeplieChildren appartientAUnNoeudPlie=False ", self.item.GetLabelText()
 879         for c in self.children :
 880             c.setDeplieChildren()
 881             #print "dans setDeplieChildren ", c.item.nom
 882             c.appartientAUnNoeudPlie=False
 883             c.setExpanded(True)
 884             c.plie=False
 885
 886     def selectAvant(self):
 887         i=self.item.jdc.etapes.index(self.item.object)
 888         try :
 889            cherche=self.item.jdc.etapes[i-1]
 890         except :
 891            cherche=self.item.jdc.etapes[-1]
 892         node=None
 893         for i in self.tree.racine.children :
 894             if i.item.object== cherche  :
 895                node=i
 896                break
 897         if node :
 898           node.affichePanneau()
 899           node.select()
 900
 901     def selectApres(self):
 902         i=self.item.jdc.etapes.index(self.item.object)
 903         try :
 904            cherche=self.item.jdc.etapes[i+1]
 905         except :
 906            cherche=self.item.jdc.etapes[0]
 907         node=None
 908         for i in self.tree.racine.children :
 909             if i.item.object== cherche  :
 910                node=i
 911                break
 912         if node :
 913            node.affichePanneau()
 914            node.select()
 915
 916     def ouvreLesNoeudsDsLArbre(self):
 917         return
 918         self.inhibeExpand = True
 919         for i in range(self.childCount()):
 920             self.child(i).inhibeExpand=True
 921             self.child(i).setExpanded(True)
 922             self.child(i).ouvreLesNoeudsDsLArbre()
 923             self.child(i).inhibeExpand=False
 924         self.inhibeExpand = False