Editeur/catabrowser.py

   1 #@ MODIF catabrowser 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 # Modules Python
   9 import os
  10 import sys
  11 import types
  12 import string
  13 import Pmw
  14 from Tkinter import *
  15
  16 # Modules Eficas
  17 import fontes
  18 from treewidget import Tree
  19 from Objecttreeitem import TreeItem
  20 from Accas import AsException
  21 from Noyau.N_CR import justify_text
  22 from Accas import OPER,PROC,MACRO,FORM
  23 from Accas import FACT,BLOC,SIMP
  24
  25 #
  26 __version__="$Name: V1_1p1 $"
  27 __Id__="$Id: catabrowser.py,v 1.1.1.1 2001/12/04 15:38:22 eficas Exp $"
  28 #
  29 class Tableau:
  30   incr = 10
  31   def __init__(self,parent,colonnes):
  32     self.parent = parent
  33     self.colonnes = colonnes
  34     self.init()
  35
  36   def init(self):
  37     # recherche du nombre maxi de lignes et de colonnes....
  38     for col in self.colonnes :
  39       nb_l = 0
  40       if len(col) > nb_l : nb_l = len(col)
  41     self.nb_lignes = nb_l
  42     self.nb_colonnes = len(self.colonnes)
  43     # initialisation des coordonnées dans le canvas
  44     self.x0 = self.incr
  45     self.y0 = self.incr
  46     self.x = self.x0 + self.incr
  47     self.y = self.y0 + self.incr
  48
  49   def affiche(self):
  50     self.scrolledcanvas=Pmw.ScrolledCanvas(self.parent,
  51                                            hull_width=1.,
  52                                            hull_height=1.,
  53                                            borderframe=1)
  54     Pmw.Color.changecolor(self.scrolledcanvas.component('canvas'),background='gray95')
  55     self.scrolledcanvas.pack(padx=10,pady=10,expand=1, fill="both")
  56     self.canvas = self.scrolledcanvas.component('canvas')
  57     self.affiche_colonnes()
  58
  59   def affiche_colonnes(self):
  60     for i in range(self.nb_lignes):
  61       self.affiche_ligne(i)
  62     self.aligne_colonnes()
  63     self.trace_traits()
  64     self.scrolledcanvas.resizescrollregion()
  65
  66   def get_xy_max(self):
  67     try:
  68       x0,y0,xmax,ymax = self.canvas.bbox(ALL)
  69       return xmax,ymax
  70     except:
  71       return None,None
  72
  73   def trace_traits(self):
  74     xmax,ymax = self.get_xy_max()
  75     if not xmax : return
  76     xmax = xmax+self.incr
  77     ymax = ymax+self.incr
  78     # trace les traits horizontaux
  79     for i in range(self.nb_lignes):
  80       tag_lig = 'ligne_'+`i`
  81       l_id = self.canvas.find_withtag(tag_lig)
  82       x0,y0,x1,y1 = self.bbox(l_id)
  83       self.canvas.create_line(x0-self.incr,y0-self.incr,xmax,y0-self.incr)
  84     self.canvas.create_line(self.x0,ymax,xmax,ymax)
  85     # trace les traits verticaux
  86     for j in range(self.nb_colonnes):
  87       tag_col = 'colonne_'+`j`
  88       l_id = self.canvas.find_withtag(tag_col)
  89       x0,y0,x1,y1 = self.bbox(l_id)
  90       self.canvas.create_line(x0-self.incr,y0-self.incr,x0-self.incr,ymax)
  91     self.canvas.create_line(xmax,self.y0,xmax,ymax)
  92
  93   def bbox(self,l_id):
  94     x0,y0,x1,y1 = self.canvas.bbox(l_id[0])
  95     for id in l_id[1:]:
  96       x2,y2,x3,y3 = self.canvas.bbox(id)
  97       x0 = min(x2,x0)
  98       y0 = min(y2,y0)
  99       x1 = max(x3,x1)
 100       y1 = max(y3,y1)
 101     return x0,y0,x1,y1
 102
 103   def affiche_ligne(self,num_lig):
 104     tag_lig = 'ligne_'+`num_lig`
 105     num_col = 0
 106     for col in self.colonnes:
 107       tag_col = 'colonne_'+`num_col`
 108       x = 100*num_col+self.x
 109       id = self.canvas.create_text(x,self.y,
 110                                    text = justify_text(col[num_lig],cesure=60),
 111                                    tag=(tag_lig,tag_col),
 112                                    anchor='nw',
 113                                    font = fontes.canvas)
 114       x0,y0,x1,y1 = self.canvas.bbox(id)
 115       num_col = num_col+1
 116     l_id = self.canvas.find_withtag(tag_lig)
 117     x0,y0,x1,y1 = self.bbox(l_id)
 118     self.y = y1 + 2*self.incr
 119
 120   def aligne_colonnes(self):
 121     num_col = 0
 122     for col in self.colonnes:
 123       tag_col = 'colonne_'+`num_col`
 124       l_id = self.canvas.find_withtag(tag_col)
 125       if not l_id : continue
 126       x0,y0,x1,y1 = self.bbox(l_id)
 127       self.move(x1+self.incr,self.colonnes[num_col+1:],num_col+1)
 128       num_col = num_col+1
 129
 130   def move(self,x,colonnes,num):
 131     num_col = num
 132     for col in colonnes:
 133       tag_col = 'colonne_'+`num_col`
 134       l_id = self.canvas.find_withtag(tag_col)
 135       if not l_id : continue
 136       x0,y0,x1,y1 = self.canvas.bbox(l_id[0])
 137       self.canvas.move(tag_col,x+self.incr-x0,0)
 138       num_col = num_col+1
 139
 140 class CATAPanel(Frame) :
 141   """ Classe servant à créer le panneau représentant l'objet sélectionné dans l'arbre"""
 142   def __init__(self,parent,panneau,node) :
 143     self.parent=parent
 144     self.panneau = panneau
 145     self.node=node
 146     Frame.__init__(self,self.panneau)
 147     self.place(x=0,y=0,relheight=1,relwidth=1)
 148     self.init()
 149
 150   def init(self):
 151     # création du label initial
 152     label = Label(self,
 153                   text = 'Attributs de '+self.node.item.labeltext,
 154                   font = fontes.standard_gras_souligne)
 155     label.pack(side='top',pady=10)
 156     # création des listes correspondant aux colonnes du tableau à afficher
 157     colonne1,colonne2 = self.get_listes()
 158     # affichage du tableau
 159     self.tableau = Tableau(self,(colonne1,colonne2))
 160     self.tableau.affiche()
 161
 162   def get_listes(self):
 163     self.node.item.get_dico_attributs()
 164     l_cles_attributs = self.node.item.d_attributs.keys()
 165     l_cles_attributs.sort()
 166     ind=0
 167     liste1 = []
 168     liste2=[]
 169     for nom_attr in l_cles_attributs :
 170       valeur = self.node.item.d_attributs[nom_attr]
 171       if type(valeur) == types.TupleType:
 172         texte =''
 173         for elem in valeur:
 174           if type(elem) == types.ClassType:
 175             texte = texte + elem.__name__
 176           else:
 177             texte = texte + str(elem)
 178       elif type(valeur) == types.ClassType :
 179         texte = valeur.__name__
 180       else:
 181         texte = str(valeur)
 182       liste1.append(nom_attr)
 183       liste2.append(texte)
 184     return liste1,liste2
 185
 186 class CATAItem(TreeItem):
 187   panel = CATAPanel
 188   def __init__(self,appli,labeltext,object,setfunction=None,objet_cata_ordonne = None):
 189     self.appli = appli
 190     self.labeltext = labeltext
 191     self.object=object
 192     self.setfunction = setfunction
 193     self.objet_cata_ordonne = objet_cata_ordonne
 194
 195   def get_dico_fils(self):
 196     d_fils = {}
 197     if type(self.object) != types.TupleType:
 198       for e in dir(self.object):
 199         cmd = getattr(self.object,e)
 200         if isCMD(cmd) :
 201           d_fils[string.strip(cmd.nom)] = cmd
 202     else:
 203       for obj in self.object :
 204         for e in dir(obj):
 205           cmd = getattr(obj,e)
 206           if isCMD(cmd) :
 207             d_fils[string.strip(cmd.nom)] = cmd
 208     self.d_fils = d_fils
 209
 210   def get_dico_attributs(self):
 211     d_attributs ={}
 212     if type(self.object) == types.TupleType :
 213       self.d_attributs = d_attributs
 214       return
 215     l_noms_attributs = ['nom','op','sd_prod','reentrant','repetable','fr','docu','into','valide_vide','actif',
 216                         'regles','op_init','niveau','definition','code','niveaux','statut',
 217                         'defaut','min','max','homo','position','val_min','val_max','condition']
 218     for nom_attribut in l_noms_attributs :
 219       if hasattr(self.object,nom_attribut):
 220         attr = getattr(self.object,nom_attribut)
 221         d_attributs[nom_attribut] = attr
 222     self.d_attributs = d_attributs
 223
 224   def get_liste_mc_ordonnee(self):
 225     """ Retourne la liste ordonnée (suivant le catalogue) brute des fils
 226     de l'entite courante """
 227     if hasattr(self.objet_cata_ordonne,'liste'):
 228       return self.objet_cata_ordonne.liste
 229     else :
 230       l=self.objet_cata_ordonne.keys()
 231       l.sort()
 232       return l
 233
 234   def GetLabelText(self):
 235     return self.labeltext,None,None
 236
 237   def get_fr(self):
 238     return ''
 239
 240   def isMCList(self):
 241     return 0
 242
 243   def GetSubList(self):
 244     sublist=[]
 245     if not hasattr(self,'d_fils'):
 246       self.get_dico_fils()
 247     # on classe les fils dans l'odre du catalogue ...
 248     l_cles_fils = self.get_liste_mc_ordonnee()
 249     for k in l_cles_fils :
 250       if type(self.objet_cata_ordonne) == types.InstanceType :
 251         objet_cata = self.objet_cata_ordonne.dico[k]
 252       else :
 253         objet_cata = self.objet_cata_ordonne.get(k,None)
 254       item = make_objecttreeitem(self.appli,k + " : ",self.d_fils[k],
 255                                  objet_cata_ordonne = objet_cata)
 256       sublist.append(item)
 257     return sublist
 258
 259   def GetIconName(self):
 260     return 'ast-green-square'
 261
 262   def isactif(self):
 263     return 1
 264
 265 class CMDItem(CATAItem):
 266
 267   def get_dico_fils(self):
 268     self.d_fils = self.object.entites
 269
 270 class SIMPItem(CATAItem):
 271   d_fils={}
 272   d_attributs={}
 273
 274   def GetIconName(self):
 275     return 'ast-green-ball'
 276
 277   def IsExpandable(self):
 278     return 0
 279
 280 class FACTItem(CMDItem):
 281   def GetIconName(self):
 282     return 'ast-green-los'
 283
 284 class BLOCItem(FACTItem): pass
 285
 286 class ATTRIBUTItem(SIMPItem):
 287   def get_dico_attributs(self):
 288     self.d_attributs = {}
 289
 290   def GetSubList(self):
 291     return []
 292
 293   def IsExpandable(self):
 294     return 0
 295
 296   def GetText(self):
 297     return self.object
 298
 299   def GetIconName(self):
 300     return 'aucune'
 301
 302 class CataBrowser:
 303   def __init__(self,parent,appli,cata,item = None):
 304     self.parent = parent
 305     self.cata = cata
 306     self.appli = appli
 307     self.item = item
 308     self.init()
 309
 310   def close(self):
 311     self.top.destroy()
 312
 313   def init(self):
 314     self.nodes={}
 315     self.top = Pmw.Dialog(self.parent,
 316                           title = "Visualisation d'un catalogue",
 317                           buttons=('OK',),
 318                           command = self.quit)
 319     self.pane = Pmw.PanedWidget(self.top.component('dialogchildsite'),
 320                                 hull_width = 800,
 321                                 hull_height = 500,
 322                                 orient = 'horizontal')
 323     self.pane.add('canvas',min = 0.4, max = 0.6, size = 0.5)
 324     self.pane.add('panel',min = 0.4, max = 0.6, size = 0.5)
 325     self.pane.pack(expand =1, fill = 'both')
 326     self.scrolledcanvas = Pmw.ScrolledCanvas(self.pane.pane('canvas'),
 327                                              hull_width=1.,
 328                                              hull_height=1.,
 329                                              borderframe=1)
 330     Pmw.Color.changecolor(self.scrolledcanvas.component('canvas'),background='gray95')
 331     self.scrolledcanvas.pack(padx=10,pady=10,expand=1, fill="both")
 332     if self.item == None :
 333       self.item = CATAItem(self.appli,"Catalogue",self.cata)
 334     self.tree = Tree(self.appli,self.item,self.scrolledcanvas,command = self.select_node)
 335     self.tree.draw()
 336     self.node = self.tree.node_selected
 337
 338   def select_node(self,node):
 339     self.nodes[node]=self.create_panel(node)
 340
 341   def create_panel(self,node):
 342     if hasattr(node.item,"panel"):
 343       return getattr(node.item,"panel")(self,self.pane.pane('panel'),node)
 344
 345   def quit(self,nom_bouton) :
 346     self.top.destroy()
 347
 348   def settitle(self):
 349     self.top.wm_title("Browser de catalogue " )
 350     self.top.wm_iconname("CataBrowser")
 351
 352
 353 dispatch = {
 354     OPER  : CMDItem,
 355     PROC  : CMDItem,
 356     MACRO  : CMDItem,
 357     SIMP : SIMPItem,
 358     FACT : FACTItem,
 359     BLOC : BLOCItem,
 360 }
 361
 362 def TYPE(o):
 363   if isinstance(o,OPER):return OPER
 364   elif isinstance(o,PROC):return PROC
 365   elif isinstance(o,MACRO):return MACRO
 366   elif isinstance(o,FORM):return MACRO
 367   elif isinstance(o,SIMP):return SIMP
 368   elif isinstance(o,FACT):return FACT
 369   elif isinstance(o,BLOC):return BLOC
 370   else:return type(o)
 371
 372 def make_objecttreeitem(appli,labeltext, object, setfunction=None,objet_cata_ordonne=None):
 373     t = TYPE(object)
 374     if dispatch.has_key(t):
 375       c = dispatch[t]
 376     else:
 377       #print 'on a un objet de type :',t,'  ',object
 378       c = ATTRIBUTItem
 379     return c(appli,labeltext, object, setfunction = setfunction,objet_cata_ordonne=objet_cata_ordonne)
 380
 381 def isCMD(cmd):
 382    return isinstance(cmd,OPER) or isinstance(cmd,PROC) or isinstance(cmd,MACRO) or isinstance(cmd,FORM)
 383
 384
 385