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 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 __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 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 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 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 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 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 is not None: if is_string(color): self['stroke'] = color else: self['stroke'] = color.get_paint_server() if width is not None: self['stroke-width'] = width if opacity is not None: self['stroke-opacity'] = opacity if linecap is not None: self['stroke-linecap'] = linecap if linejoin is not None: self['stroke-linejoin'] = linejoin if miterlimit is not None: self['stroke-miterlimit'] = miterlimit return self
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_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 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 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 split(value): if is_string(value): values = iterflatlist( (v.strip().split(' ') for v in value.split(','))) return (v for v in values if v) else: return iterflatlist(value)
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 fill(self, color=None, rule=None, opacity=None): """ Set SVG Properties **fill**, **fill-rule** and **fill-opacity**. """ if color is not None: if is_string(color): self['fill'] = color else: self['fill'] = color.get_paint_server() if rule is not None: self['fill-rule'] = rule if opacity is not None: 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 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_timing_value_list(self, value): if is_string(value): return is_valid_animation_timing(value) else: return False
def is_transform_list(self, value): if is_string(value): return is_valid_transferlist(value) else: return False
def is_path_data(self, value): if is_string(value): return is_valid_pathdata(value) else: return False
def split(value): if is_string(value): values = iterflatlist( (v.strip().split(' ') for v in value.split(',')) ) return (v for v in values if v) else: return iterflatlist(value)
def is_boolean(self, value): if isinstance(value, bool): return True if is_string(value): return value.strip().lower() in ('true', 'false') return False
def test_is_unicode(self): element = MockBase() self.assertTrue(is_string(element.value_to_string(10))) self.assertTrue(is_string(element.value_to_string('test')))
def is_path_data(self, value): if is_string(value): return PathDataParser.is_valid(value) else: return False
def is_timing_value_list(self, value): if is_string(value): return AnimationTimingParser.is_valid(value) else: return False
def is_transform_list(self, value): if is_string(value): return TransformListParser.is_valid(value) else: return False