pyx/attr.py

   1 #!/usr/bin/env python
   2 # -*- coding: ISO-8859-1 -*-
   3 #
   4 #
   5 # Copyright (C) 2003-2004 Jörg Lehmann <joergl@users.sourceforge.net>
   6 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
   7 # Copyright (C) 2003-2004 André Wobst <wobsta@users.sourceforge.net>
   8 #
   9 # This file is part of PyX (http://pyx.sourceforge.net/).
  10 #
  11 # PyX is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # PyX is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with PyX; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24
  25 # check for an isinstance which accepts both a class and a sequence of classes
  26 # as second argument and emulate this behaviour if necessary
  27 try:
  28     isinstance(1, (int, float))
  29 except TypeError:
  30     # workaround for Python 2.1
  31     _isinstance = isinstance
  32     def isinstance(instance, clsarg):
  33         # we explicitely check for clsarg being a sequence, because
  34         # a Leap Before Look pattern, i.e., just trying out
  35         # _isinstance(instance, clsarg) within an try/except
  36         # block, may mask a TypeError occuring when clsarg is
  37         # not a class
  38         import helper
  39         if not helper.issequence(clsarg):
  40             return _isinstance(instance, clsarg)
  41         else:
  42             for cls in clsarg:
  43                 if _isinstance(instance, cls):
  44                     return 1
  45             return 0
  46
  47 #
  48 # some helper functions for the attribute handling
  49 #
  50
  51 def mergeattrs(attrs):
  52     """perform merging of the attribute list attrs as defined by the
  53     merge methods of the attributes"""
  54     newattrs = []
  55     for a in attrs:
  56         # XXX Do we really need this test?
  57         if isinstance(a, attr):
  58             newattrs = a.merge(newattrs)
  59         else:
  60             raise TypeError("only instances of class attr.attr are allowed")
  61     return newattrs
  62
  63
  64 def getattrs(attrs, getclasses):
  65     """return all attributes in the attribute list attrs, which are
  66     instances of one of the classes in getclasses"""
  67     return [attr for attr in attrs if isinstance(attr, tuple(getclasses))]
  68
  69
  70 def checkattrs(attrs, allowedclasses):
  71     """check whether only attributes which are instances of classes in
  72     allowedclasses are present in the attribute list attrs; if not it
  73     raises a TypeError"""
  74     if len(attrs) != len(getattrs(attrs, allowedclasses)):
  75         for attr1, attr2 in zip(attrs, getattrs(attrs, allowedclasses)):
  76             if attr1 is not attr2:
  77                 raise TypeError("instance %r not allowed" % attr1)
  78         else:
  79             raise TypeError("instance %r not allowed" % attrs[len(getattrs(attrs, allowedclasses))])
  80
  81 #
  82 # attr class and simple descendants
  83 #
  84
  85 class attr:
  86
  87     """ attr is the base class of all attributes, i.e., colors, decorators,
  88     styles, text attributes and trafos"""
  89
  90     def merge(self, attrs):
  91         """merge self into list of attrs
  92
  93         self may either be appended to attrs or inserted at a proper position
  94         immediately before a dependent attribute. Attributes of the same type
  95         should be removed, if redundant. Note that it is safe to modify
  96         attrs."""
  97
  98         attrs.append(self)
  99         return attrs
 100
 101
 102 class exclusiveattr(attr):
 103
 104     """an attribute which swallows all but the last of the same type (specified
 105     by the exlusiveclass argument to the constructor) in an attribute list"""
 106
 107     def __init__(self, exclusiveclass):
 108         self.exclusiveclass = exclusiveclass
 109
 110     def merge(self, attrs):
 111         attrs = [attr for attr in attrs if not isinstance(attr, self.exclusiveclass)]
 112         attrs.append(self)
 113         return attrs
 114
 115
 116 class sortbeforeattr(attr):
 117
 118     """an attribute which places itself previous to all attributes given
 119     in the beforetheclasses argument to the constructor"""
 120
 121     def __init__(self, beforetheclasses):
 122         self.beforetheclasses = tuple(beforetheclasses)
 123
 124     def merge(self, attrs):
 125         first = 1
 126         result = []
 127         for attr in attrs:
 128             if first and isinstance(attr, self.beforetheclasses):
 129                 result.append(self)
 130                 first = 0
 131             result.append(attr)
 132         if first:
 133             result.append(self)
 134         return result
 135
 136
 137 class sortbeforeexclusiveattr(attr):
 138
 139     """an attribute which swallows all but the last of the same type (specified
 140     by the exlusiveclass argument to the constructor) in an attribute list and
 141     places itself previous to all attributes given in the beforetheclasses
 142     argument to the constructor"""
 143
 144     def __init__(self, exclusiveclass, beforetheclasses):
 145         self.exclusiveclass = exclusiveclass
 146         self.beforetheclasses = tuple(beforetheclasses)
 147
 148     def merge(self, attrs):
 149         first = 1
 150         result = []
 151         for attr in attrs:
 152             if first and isinstance(attr, self.beforetheclasses):
 153                 result.append(self)
 154                 first = 0
 155             if not isinstance(attr, self.exclusiveclass):
 156                 result.append(attr)
 157         if first:
 158             result.append(self)
 159         return result
 160
 161
 162 class clearclass(attr):
 163
 164     """a special attribute which allows to remove all predecessing attributes of
 165     the same type in an attribute list"""
 166
 167     def __init__(self, clearclass):
 168         self.clearclass = clearclass
 169
 170     def merge(self, attrs):
 171         return [attr for attr in attrs if not isinstance(attr, self.clearclass)]
 172
 173
 174 class _clear(attr):
 175
 176     """a special attribute which removes all predecessing attributes
 177     in an attribute list"""
 178
 179     def merge(self, attrs):
 180         return []
 181
 182 # we define the attribute "clear", an instance of "_clear",
 183 # which can be used to remove all predecessing attributes
 184 # in an attribute list
 185
 186 clear = _clear()
 187
 188 #
 189 # changeable attrs
 190 #
 191
 192 def selectattrs(attrs, index, total):
 193     """performs select calls for all changeable attributes and
 194     returns the resulting attribute list
 195     - attrs should be a list containing attributes and changeable
 196       attributes
 197     - index should be an unsigned integer
 198     - total should be a positive number
 199     - valid sections fullfill 0<=index<total
 200     - returns None, when attrs is None
 201     - returns None, when a changeable attribute returns None"""
 202     if attrs is None:
 203         return None
 204     result = []
 205     for a in attrs:
 206         if isinstance(a, changeattr):
 207             select = a.select(index, total)
 208             if select is None:
 209                 return None
 210             result.append(select)
 211         else:
 212             result.append(a)
 213     return result
 214
 215
 216 def selectattr(attr, index, total):
 217     """as select, but for a single attribute"""
 218     if isinstance(attr, changeattr):
 219         select = attr.select(index, total)
 220         if select is None:
 221             return None
 222         return select
 223     else:
 224         return attr
 225
 226
 227 class changeattr:
 228
 229     """changeattr is the base class of all changeable attributes"""
 230
 231     def select(self, index, total):
 232         """returns an attribute for a given index out of a total number
 233         if attributes to be provided
 234         - index should be an unsigned integer
 235         - total should be a positive number
 236         - valid selections fullfill 0 <= index < total
 237         - the select method may raise a ValueError, when the
 238           changeable attribute does not allow for a requested
 239           selection"""
 240
 241         raise RuntimeError("not implemented")
 242
 243
 244 class changelist(changeattr):
 245
 246     """a changeable attribute over a list of attribute choises"""
 247
 248     def __init__(self, attrs, cyclic=1):
 249         """initializes the instance
 250         - attrs is a list of attributes to cycle
 251         - If cyclic is set, we restart from the beginning after
 252           the end of the list has been reached; otherwise
 253           selecting beyond the end of the list returns None"""
 254         self.attrs = attrs
 255         self.cyclic = cyclic
 256
 257     def select(self, index, total):
 258         if self.cyclic:
 259             return self.attrs[index % len(self.attrs)]
 260         elif index < len(self.attrs):
 261             return self.attrs[index]
 262