Editeur/Objecttreeitem.py

   1 """
   2 """
   3 # import généraux
   4 import types,string,os,glob,imp,sys
   5 from repr import Repr
   6 from copy import copy,deepcopy
   7
   8 myrepr = Repr()
   9 myrepr.maxstring = 100
  10 myrepr.maxother = 100
  11
  12 class TreeItem:
  13
  14     """Abstract class representing tree items.
  15
  16     Methods should typically be overridden, otherwise a default action
  17     is used.
  18
  19     """
  20
  21     def __init__(self):
  22         """Constructor.  Do whatever you need to do."""
  23
  24     def GetText(self):
  25         """Return text string to display."""
  26
  27     def GetLabelText(self):
  28         """Return label text string to display in front of text (if any)."""
  29
  30     expandable = None
  31
  32     def _IsExpandable(self):
  33         """Do not override!  Called by TreeNode."""
  34         if self.expandable is None:
  35             self.expandable = self.IsExpandable()
  36         return self.expandable
  37
  38     def IsExpandable(self):
  39         """Return whether there are subitems."""
  40         return 1
  41
  42     def _GetSubList(self):
  43         """Do not override!  Called by TreeNode."""
  44         if not self.IsExpandable():
  45             return []
  46         sublist = self.GetSubList()
  47         if not sublist:
  48             self.expandable = 0
  49         return sublist
  50
  51     def IsEditable(self):
  52         """Return whether the item's text may be edited."""
  53
  54     def SetText(self, text):
  55         """Change the item's text (if it is editable)."""
  56
  57     def GetIconName(self):
  58         """Return name of icon to be displayed normally."""
  59
  60     def GetSelectedIconName(self):
  61         """Return name of icon to be displayed when selected."""
  62
  63     def GetSubList(self):
  64         """Return list of items forming sublist."""
  65
  66     def OnDoubleClick(self):
  67         """Called on a double-click on the item."""
  68
  69 class Delegate:
  70     def __init__(self, delegate=None):
  71         self.object = delegate
  72         self.__cache = {}
  73
  74     def setdelegate(self, delegate):
  75         self.resetcache()
  76         self.object = delegate
  77
  78     def getdelegate(self):
  79         return self.object
  80
  81     def __getattr__(self, name):
  82         attr = getattr(self.object, name) # May raise AttributeError
  83         setattr(self, name, attr)
  84         self.__cache[name] = attr
  85         return attr
  86
  87     def resetcache(self):
  88         for key in self.__cache.keys():
  89             try:
  90                 delattr(self, key)
  91             except AttributeError:
  92                 pass
  93         self.__cache.clear()
  94
  95     def cachereport(self):
  96         keys = self.__cache.keys()
  97         keys.sort()
  98         print keys
  99
 100
 101 class ObjectTreeItem(TreeItem,Delegate):
 102     def __init__(self, appli, labeltext, object, setfunction=None):
 103         self.labeltext = labeltext
 104         self.appli = appli
 105         Delegate.__init__(self,object)
 106         #self.object = object
 107         self.setfunction = setfunction
 108         self.expandable = 1
 109         self.init()
 110
 111     def init(self):
 112         return
 113
 114     def copy(self):
 115         """
 116         Crée un item copie de self
 117         """
 118         object = self.object.copy()
 119         appli = copy(self.appli)
 120         labeltext = copy(self.labeltext)
 121         fonction = deepcopy(self.setfunction)
 122         item = make_objecttreeitem(appli,labeltext,object,fonction)
 123         return item
 124
 125     def isactif(self):
 126         if hasattr(self.object,'actif'):
 127             return self.object.actif
 128         else:
 129             return 1
 130
 131     def GetLabelText(self):
 132         """ Retourne 3 valeurs :
 133         - le texte à afficher dans le noeud représentant l'item
 134         - la fonte dans laquelle afficher ce texte
 135         - la couleur du texte
 136         """
 137         # None --> fonte et couleur par défaut
 138         return self.labeltext,None,None
 139
 140     #def get_attribut(self,nom_attribut) :
 141     #    """
 142     #       Retourne l'attribut de nom nom_attribut de l'objet sur lequel
 143     #       pointe self s'il existe, None sinon
 144     #    """
 145     #    return self.object.get_attribut(nom_attribut)
 146
 147     def get_nature(self) :
 148         """
 149             Retourne la nature de l'item et de l'objet
 150         """
 151         return self.object.nature
 152
 153     def get_regles(self):
 154         """ retourne les règles de l'objet pointé par self """
 155         return self.object.get_regles()
 156
 157     def get_liste_mc_presents(self):
 158         """ Retourne la liste des mots-clés fils de l'objet pointé par self """
 159         return self.object.liste_mc_presents()
 160
 161     def get_val(self):
 162         """ Retourne le nom de la valeur de l'objet pointé par self dans le cas
 163             où celle-ci est un objet (ASSD) """
 164         return self.object.getval()
 165
 166     def get_definition(self):
 167         """
 168            Retourne l'objet definition de l'objet pointé par self
 169         """
 170         return self.object.definition
 171
 172     def get_liste_mc_ordonnee(self,liste,dico):
 173         """ retourne la liste ordonnée (suivant le catalogue) brute des mots-clés
 174             d'une entité composée dont le chemin complet est donné sous forme
 175             d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
 176             il faut encore réarranger cette liste (certains mots-clés déjà
 177             présents ne doivent plus être proposés, règles ...)"""
 178         return self.object.get_liste_mc_ordonnee(liste,dico)
 179
 180     def get_liste_mc_ordonnee_brute(self,liste,dico):
 181         """
 182         retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
 183         d'une entité composée dont le chemin complet est donné sous forme
 184         d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
 185         """
 186         return self.object.get_liste_mc_ordonnee_brute(liste,dico)
 187
 188     def get_genealogie(self):
 189         """
 190         Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
 191         de l'objet pointé par self
 192         """
 193         return self.object.get_genealogie()
 194
 195     def get_index_child(self,nom_fils):
 196         """
 197         Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
 198         Nécessaire pour savoir à quelle position dans la liste des fils il faut ajouter
 199         le nouveau mot-clé
 200         """
 201         liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),self.get_jdc().cata_ordonne_dico)
 202         liste_noms_mc_presents = self.object.liste_mc_presents()
 203         l=[]
 204         for nom in liste_noms_mc_ordonnee:
 205             if nom in liste_noms_mc_presents or nom == nom_fils:
 206                 l.append(nom)
 207         # l contient les anciens mots-clés + le nouveau dans l'ordre
 208         return l.index(nom_fils)
 209
 210     def get_nom_etape(self):
 211         """Retourne le nom de self """
 212         return self.object.get_nom_etape()
 213
 214     def get_copie_objet(self):
 215         """ Retourne une copie de l'objet pointé par self """
 216         return self.object.copy()
 217
 218     def get_position(self):
 219         """ Retourne la valeur de l'attribut position de l'objet pointé par self """
 220         definition = self.get_definition()
 221         try:
 222             return getattr(definition,'position')
 223         except AttributeError:
 224             return 'local'
 225
 226     def get_nom(self):
 227         """ Retourne le nom de l'objet pointé par self """
 228         return self.object.nom
 229
 230     def get_jdc(self):
 231         """ Retourne le jdc auquel appartient l'objet pointé par self """
 232         return self.object.jdc
 233         #return self.object.get_attribut('jdc')
 234
 235     def get_valeur(self):
 236         """ Retourne la valeur de l'objet pointé par self """
 237         return self.object.valeur
 238
 239     def get_cr(self):
 240         """ Retourne le compte-rendu CR de self """
 241         return self.object.report()
 242
 243     def get_objet_commentarise(self):
 244         """
 245         Cette méthode retourne un objet commentarisé
 246         représentatif de self.object
 247         --> à surcharger par les différents items
 248         """
 249         pass
 250
 251     def isvalid(self):
 252         """ Retourne 1 si l'objet pointé par self est valide, 0 sinon"""
 253         return self.object.isvalid()
 254
 255     def iscopiable(self):
 256         """
 257         Retourne 1 si l'objet est copiable, 0 sinon
 258         Par défaut retourne 0
 259         """
 260         return 0
 261
 262     def isMCList(self):
 263         """ Retourne 1 si l'objet pointé par self est une MClist, 0 sinon"""
 264         #if isinstance(self.object,MCList) :
 265         if self.object.__class__.__name__ == 'MCList':
 266             return 1
 267         else :
 268             return 0
 269
 270     def isCommande(self):
 271         """
 272         Retourne 1 si l'objet pointé par self est une Commande, 0 sinon
 273         """
 274         return 0
 275
 276     def isJdc(self):
 277         """
 278         Retourne 1 si l'objet pointé par self est un JDC, 0 sinon
 279         """
 280         return 0
 281
 282     def isMCFact(self):
 283         """
 284         Retourne 1 si l'objet pointé par self est un MCFact, 0 sinon
 285         """
 286         return 0
 287
 288     def get_mc_presents(self):
 289         """ Retourne le dictionnaire des mots-clés présents de l'objet pointé par self """
 290         return self.object.dict_mc_presents()
 291
 292     def verif_condition_regles(self,l_mc_presents):
 293         return self.object.verif_condition_regles(l_mc_presents)
 294
 295     def get_fr(self):
 296         """ Retourne le fr de l'objet pointé par self """
 297         try:
 298            return self.object.get_fr()
 299         except:
 300            return ''
 301
 302     def get_docu(self):
 303         """ Retourne la clé de doc de l'objet pointé par self """
 304         return self.object.get_docu()
 305
 306     def set_valeur(self,new_valeur,evaluation='oui'):
 307         """ Remplace la valeur de l'objet pointé par self par new_valeur """
 308         return self.object.set_valeur(new_valeur,evaluation=evaluation)
 309
 310     def GetText(self):
 311         return myrepr.repr(self.object)
 312
 313     def GetIconName(self):
 314         if not self.IsExpandable():
 315             return "python"
 316
 317     def IsEditable(self):
 318         return self.setfunction is not None
 319
 320     def SetText(self, text):
 321         try:
 322             value = eval(text)
 323             self.setfunction(value)
 324         except:
 325             pass
 326 # Modif de ma part CCar : je ne comprend pas a quoi ca sert
 327 # ca parait meme incorrect
 328       #  else:
 329       #      self.object = value
 330
 331     def IsExpandable(self):
 332         return 1
 333
 334     def GetSubList(self):
 335         keys = dir(self.object)
 336         sublist = []
 337         for key in keys:
 338             try:
 339                 value = getattr(self.object, key)
 340             except AttributeError:
 341                 continue
 342             item = make_objecttreeitem(
 343                 self.appli,
 344                 str(key) + " =",
 345                 value,
 346                 lambda value, key=key, object=self.object:
 347                     setattr(object, key, value))
 348             sublist.append(item)
 349         return sublist
 350
 351     def wait_fichier_init(self):
 352         """ Retourne 1 si l'object pointé par self attend un fichier d'initialisation
 353         (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
 354         return self.object.definition.fichier_ini
 355
 356     def make_objecttreeitem(self,appli,labeltext, object, setfunction=None):
 357         """
 358            Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
 359            de type item associé à l'object passé en argument.
 360         """
 361         c = gettreeitem(object)
 362         return c(appli,labeltext, object, setfunction)
 363
 364 class AtomicObjectTreeItem(ObjectTreeItem):
 365     def IsExpandable(self):
 366         return 0
 367
 368 class SequenceTreeItem(ObjectTreeItem):
 369     def IsExpandable(self):
 370         return len(self.object) > 0
 371
 372     def __len__(self) :
 373         return len(self.object)
 374
 375     def keys(self):
 376         return range(len(self.object))
 377
 378     def GetIconName(self):
 379         if self.object.isvalid():
 380           return "ast-green-los"
 381         elif self.object.isoblig():
 382           return "ast-red-los"
 383         else:
 384           return "ast-yel-los"
 385
 386     def ajout_possible(self):
 387         return self.object.ajout_possible()
 388
 389     def get_index(self,child):
 390         """ Retourne le numéro de child dans la liste des enfants de self """
 391         return self.object.get_index(child.object)
 392
 393     def GetText(self):
 394       return  "    "
 395
 396     def additem(self,obj,pos):
 397         # XXX Passer par addentite  de MCList ???
 398         self.object.insert(pos,obj)
 399         item = self.make_objecttreeitem(self.appli, obj.nom + ":", obj)
 400         return item
 401
 402     def suppitem(self,item):
 403         if not self.object.isMCList():return 1
 404         try :
 405             self.object.remove(item.object)
 406             # la liste peut être retournée vide !
 407             message = "Mot-clé " + item.object.nom + " supprimé"
 408             self.appli.affiche_infos(message)
 409             return 1
 410         except:
 411             return 0
 412
 413     def GetSubList(self):
 414         sublist = []
 415         for obj in self.object.data:
 416             def setfunction(value, object=obj):
 417                 object = value
 418             item = make_objecttreeitem(self.appli, obj.nom + ":", obj, setfunction)
 419             sublist.append(item)
 420         return sublist
 421
 422 def gettreeitem(object):
 423     """
 424        Cette fonction retourne la classe item associée à l'objet object.
 425        Cette classe item dépend bien sûr de la nature de object, d'où
 426        l'interrogation du dictionnaire composants
 427     """
 428     if type(object) == types.InstanceType:
 429       # On cherche d abord dans les composants (plugins)
 430       try:
 431         return composants[object.__class__]
 432       except:
 433         # On cherche une eventuelle classe heritee (aleatoire car sans ordre)
 434         for e in composants.keys():
 435           if isinstance(object,e):return composants[e]
 436     # On n'a rien trouve dans les composants
 437     return ObjectTreeItem
 438
 439 def charger_composants():
 440     """
 441         Cette fonction a pour but de charger tous les modules composants graphiques
 442         (fichiers compo*.py dans le même répertoire que ce module )
 443         et de remplir le dictionnaire composants utilisé par make_objecttreeitem
 444     """
 445     composants={}
 446     repertoire=os.path.dirname(__file__)
 447     listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
 448     for fichier in listfich:
 449         m= os.path.basename(fichier)[:-3]
 450         module=__import__(m,globals(),locals())
 451         composants[module.objet]=module.treeitem
 452     return composants
 453
 454 def make_objecttreeitem(appli,labeltext, object, setfunction=None):
 455     """
 456        Cette fonction permet de construire et de retourner un objet
 457        de type item associé à l'object passé en argument.
 458     """
 459     c = gettreeitem(object)
 460     return c(appli,labeltext, object, setfunction)
 461
 462 # Dictionnaire {object : item} permettant d'associer un item à un object
 463 # Ce dictionnaire est renseigné par la méthode charger_composants
 464 composants = charger_composants()
 465