def is_frequency(self, value):
     #frequency ::= number (~"Hz" | ~"kHz")
     if self.is_number(value):
         return True
     elif is_string(value):
         return pattern.frequency.match(value.strip()) is not None
     return False

 def is_percentage(self, value):
     #percentage ::= number "%"
     if self.is_number(value):
         return True
     elif is_string(value):
         return pattern.percentage.match(value.strip()) is not None
     return False

 def __init__(self, inherit=None, **extra):
     super(_AbstractGradient, self).__init__(**extra)
     if inherit is not None:
         if is_string(inherit):
             self.set_href(inherit)
         else:
             self.set_href(inherit.get_iri())

 def is_time(self, value):
     #time ::= <number> (~"ms" | ~"s")?
     if self.is_number(value):
         return True
     elif is_string(value):
         return pattern.time.match(value.strip()) is not None
     return False

 def split(value):
     #TODO: improve split function!!!!
     if isinstance(value, (int, float)):
         return (value, )
     if is_string(value):
         return iterflatlist(v.split(',') for v in value.split(' '))
     return value

    def set_markers(self, markers):
        """
        Set markers for line elements (line, polygon, polyline, path) to
        values specified by  `markers`.

        * if `markers` is a 3-tuple:

          * attribute 'marker-start' = markers[0]
          * attribute 'marker-mid' = markers[1]
          * attribute 'marker-end' = markers[2]

        * `markers` is a `string` or a `Marker` class:

          * attribute 'marker' = `FuncIRI` of markers

        """
        def get_funciri(value):
            if is_string(value):
                # strings has to be a valid reference including the '#'
                return 'url(%s)' % value
            else:
                # else create a reference to the object '#id'
                return 'url(#%s)' % value['id']

        if is_string(markers):
            self['marker'] = get_funciri(markers)
        else:
            try:
                markerstart, markermid, markerend = markers
                self['marker-start'] = get_funciri(markerstart)
                self['marker-mid'] = get_funciri(markermid)
                self['marker-end'] = get_funciri(markerend)
            except (TypeError, KeyError):
                self['marker'] = get_funciri(markers)

 def get_funciri(value):
     if is_string(value):
         # strings has to be a valid reference including the '#'
         return 'url(%s)' % value
     else:
         # else create a reference to the object '#id'
         return 'url(#%s)' % value['id']

    def __init__(self, start=None, size=None, resolution=None, inherit=None, **extra):
        """
        :param 2-tuple start: defines the start point of the filter effects region (**x**, **y**)
        :param 2-tuple size: defines the size of the filter effects region (**width**, **height**)
        :param resolution: takes the form ``'x-pixels [y-pixels]'``, and indicates
            the width and height of the intermediate images in pixels.
        :param inherit: inherits properties from Filter `inherit` see: **xlink:href**

        """
        super(Filter, self).__init__(**extra)
        if start is not None:
            self['x'] = start[0]
            self['y'] = start[1]
        if size is not None:
            self['width'] = size[0]
            self['height'] = size[1]
        if resolution is not None:
            if is_string(resolution):
                self['filterRes'] = resolution
            elif hasattr(resolution, '__iter__'):
                self['filterRes'] = strlist(resolution, ' ')
            else:
                self['filterRes'] = str(resolution)

        if inherit is not None:
            self.href = inherit
            self.update_id()

 def is_angle(self, value):
     #angle ::= number (~"deg" | ~"grad" | ~"rad")?
     if self.is_number(value):
         return True
     elif is_string(value):
         return pattern.angle.match(value.strip()) is not None
     return False

    def __init__(self, text, insert=None, x=[], y=[], dx=[], dy=[], rotate=[],
                 **extra):
        """
        :param string text: **tspan** content
        :param 2-tuple insert: The **insert** parameter is the absolute insert point
                               of the text, don't use this parameter in combination
                               with the **x** or the **y** parameter.
        :param list x: list of absolute x-axis values for characters
        :param list y: list of absolute y-axis values for characters
        :param list dx: list of relative x-axis values for characters
        :param list dy: list of relative y-axis values for characters
        :param list rotate: list of rotation-values for characters (in degrees)

        """
        super(TSpan, self).__init__(**extra)
        self.text = text
        if insert is not None:
            if is_string(insert):
                raise TypeError("'insert' should be a <tuple> or a <list>  with" \
                                " at least two elements.")
            if x or y:
                raise ValueError("Use 'insert' and 'x' or 'y' parameter not" \
                                 " at the same time!")
            x = [insert[0]]
            y = [insert[1]]

        if x: self['x'] = strlist(list(iterflatlist(x)), ' ')
        if y: self['y'] = strlist(list(iterflatlist(y)), ' ')
        if dx: self['dx'] = strlist(list(iterflatlist(dx)), ' ')
        if dy: self['dy'] = strlist(list(iterflatlist(dy)), ' ')
        if rotate: self['rotate'] = strlist(list(iterflatlist(rotate)), ' ')

 def update_id(self):
     if not hasattr(self, 'href'):
         return
     if is_string(self.href):
         idstr = self.href
     else:
         idstr = self.href.get_iri()
     self.attribs['xlink:href'] = idstr

def iterflatlist(values):
    """ Flatten nested *values*, returns an *iterator*. """
    for element in values:
        if hasattr(element, "__iter__") and not is_string(element):
            for item in iterflatlist(element):
                yield item
        else:
            yield element

 def is_IRI(self, value):
     # Internationalized Resource Identifiers
     # a more generalized complement to Uniform Resource Identifiers (URIs)
     # nearly everything can be a valid <IRI>
     # only a none-empty string ist a valid input
     if is_string(value):
         return bool(value.strip())
     else:
         return False

 def is_length(self, value):
     #length ::= number ("em" | "ex" | "px" | "in" | "cm" | "mm" | "pt" | "pc" | "%")?
     if value is None:
         return False
     if isinstance(value, (int, float)):
         return self.is_number(value)
     elif is_string(value):
         result = pattern.length.match(value.strip())
         if result:
             number, tmp, unit = result.groups()
             return self.is_number(number) # for tiny check!
     return False

    def fill(self, color=None, rule=None, opacity=None):
        """
        Set SVG Properties **fill**, **fill-rule** and **fill-opacity**.

        """
        if color:
            if is_string(color):
                self['fill'] = color
            else:
                self['fill'] = color.get_paint_server()
        if rule:
            self['fill-rule'] = rule
        if opacity:
            self['fill-opacity'] = opacity
        return self

 def is_number_optional_number(self, value):
     #number-optional-number ::= number
     #                           | number comma-wsp number
     if is_string(value):
         values = re.split(' *,? *', value.strip())
         if 0 < len(values) < 3: # 1 or 2 numbers
             for v in values:
                 if not self.is_number(v):
                     return False
             return True
     else:
         try: # is it a 2-tuple
             n1, n2 = value
             if self.is_number(n1) and \
                self.is_number(n2):
                 return True
         except TypeError: # just one value
             return self.is_number(value)
         except ValueError: # more than 2 values
             pass
     return False

    def __init__(self, insert=None, size=None, inherit=None, **extra):
        """
        :param 2-tuple insert: base point of the pattern (**x**, **y**)
        :param 2-tuple size: size of the pattern (**width**, **height**)
        :param inherit: pattern inherits properties from `inherit` see: **xlink:href**

        """
        super(Pattern, self).__init__(**extra)
        if insert is not None:
            self['x'] = insert[0]
            self['y'] = insert[1]
        if size is not None:
            self['width'] = size[0]
            self['height'] = size[1]
        if inherit is not None:
            if is_string(inherit):
                self.set_href(inherit)
            else:
                self.set_href(inherit.get_iri())

        if self.debug:
            self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)

    def set_value(self, values, calcMode=None, keyTimes=None, keySplines=None,
                  from_=None, to=None, by=None):
        """
        Set animation attributes :ref:`values`, :ref:`calcMode`, :ref:`keyTimes`,
        :ref:`keySplines`, :ref:`from`, :ref:`to` and :ref:`by`.
        """
        if values is not None:
            if not is_string(values):
                values = strlist(values, ';')
            self['values'] = values

        if calcMode is not None:
            self['calcMode'] = calcMode
        if keyTimes is not None:
            self['keyTimes'] = keyTimes
        if keySplines is not None:
            self['keySplines'] = keySplines
        if from_ is not None:
            self['from'] = from_
        if to is not None:
            self['to'] = to
        if by is not None:
            self['by'] = by

    def stroke(self, color=None, width=None, opacity=None, linecap=None,
               linejoin=None, miterlimit=None):
        """
        Set SVG Properties **stroke**, **stroke-width**, **stroke-opacity**,
        **stroke-linecap** and **stroke-miterlimit**.

        """

        if color:
            if is_string(color):
                self['stroke'] = color
            else:
                self['stroke'] = color.get_paint_server()
        if width:
            self['stroke-width'] = width
        if opacity:
            self['stroke-opacity'] = opacity
        if linecap:
            self['stroke-linecap'] = linecap
        if linejoin:
            self['stroke-linejoin'] = linejoin
        if miterlimit:
            self['stroke-miterlimit'] = miterlimit
        return self

 def is_transform_list(self, value):
     if is_string(value):
         return is_valid_transferlist(value)
     else:
         return False