/usr/lib/python2.7/dist-packages/svgwrite/text.py is in python-svgwrite 1.1.8-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 | #!/usr/bin/env python
#coding:utf-8
# Author: mozman --<mozman@gmx.at>
# Purpose: text objects
# Created: 20.09.2010
# Copyright (C) 2010, Manfred Moitzi
# License: MIT License
"""
Text that is to be rendered as part of an SVG document fragment is specified
using the **text** element. The characters to be drawn are expressed as XML
character data inside the **text** element.
"""
from svgwrite.base import BaseElement
from svgwrite.mixins import Presentation, Transform, XLink
from svgwrite.utils import iterflatlist, strlist, is_string, to_unicode
class TSpan(BaseElement, Presentation):
"""
Within a **Text** element, text and font properties
and the current text position can be adjusted with absolute or relative
coordinate values by using the **TSpan** element.
The characters to be drawn are expressed as XML character data inside the
**TSpan** element.
"""
elementname = 'tspan'
def __init__(self, text, insert=None, x=None, y=None, dx=None, dy=None, rotate=None,
**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 is not None:
self['x'] = strlist(list(iterflatlist(x)), ' ')
if y is not None:
self['y'] = strlist(list(iterflatlist(y)), ' ')
if dx is not None:
self['dx'] = strlist(list(iterflatlist(dx)), ' ')
if dy is not None:
self['dy'] = strlist(list(iterflatlist(dy)), ' ')
if rotate is not None:
self['rotate'] = strlist(list(iterflatlist(rotate)), ' ')
def get_xml(self):
xml = super(TSpan, self).get_xml()
xml.text = to_unicode(self.text)
return xml
class Text(TSpan, Transform):
"""
The **Text** element defines a graphics element consisting of text.
The characters to be drawn are expressed as XML character data inside the
**Text** element.
"""
elementname = 'text'
class TRef(BaseElement, XLink, Presentation):
"""
The textual content for a **Text** can be either character data directly
embedded within the <text> element or the character data content of a
referenced element, where the referencing is specified with a **TRef**
element.
"""
elementname = 'tref'
def __init__(self, element, **extra):
"""
:param element: create a reference this element, if element is a \
`string` its the **id** name of the referenced element, \
if element is a :class:`~svgwrite.base.BaseElement` \
the **id** SVG Attribute is used to create the reference.
"""
super(TRef, self).__init__(**extra)
self.set_href(element)
def get_xml(self):
self.update_id() # if href is an object - 'id' - attribute may be changed!
return super(TRef, self).get_xml()
class TextPath(BaseElement, XLink, Presentation):
"""
In addition to text drawn in a straight line, SVG also includes the
ability to place text along the shape of a **path** element. To specify that
a block of text is to be rendered along the shape of a **path**, include
the given text within a **textPath** element which includes an **xlink:href**
attribute with a IRI reference to a **path** element.
"""
elementname = 'textPath'
def __init__(self, path, text, startOffset=None, method='align', spacing='exact',
**extra):
"""
:param path: link to **path**, **id** string or **Path** object
:param string text: **textPath** content
:param number startOffset: text starts with offset from begin of path.
:param string method: ``align|stretch``
:param string spacing: ``exact|auto``
"""
super(TextPath, self).__init__(**extra)
self.text = text
if method == 'stretch':
self['method'] = method
if spacing == 'auto':
self['spacing'] = spacing
if startOffset is not None:
self['startOffset'] = startOffset
self.set_href(path)
def get_xml(self):
self.update_id() # if href is an object - 'id' - attribute may be changed!
xml = super(TextPath, self).get_xml()
xml.text = to_unicode(self.text)
return xml
class TBreak(BaseElement):
elementname = 'tbreak'
def __init__(self, **extra):
super(TBreak, self).__init__(**extra)
def __getitem__(self, key):
raise NotImplementedError("__getitem__() not supported by TBreak class.")
def __setitem__(self, key, value):
raise NotImplementedError("__setitem__() not supported by TBreak class.")
def add(self, element):
raise NotImplementedError("add() not supported by TBreak class.")
class TextArea(BaseElement, Transform, Presentation):
"""
At this time **textArea** is only available for SVG 1.2 Tiny profile.
The **textArea** element allows simplistic wrapping of text content within a
given region. The `tiny` profile of SVG specifies a single rectangular region.
Other profiles may allow a sequence of arbitrary shapes.
Text wrapping via the **textArea** element is available as a lightweight and
convenient facility for simple text wrapping where a complete box model layout
engine is not required.
The layout of wrapped text is user agent dependent; thus, content developers
need to be aware that there might be different results, particularly with
regard to where line breaks occur.
The TextArea class wraps every text added by write() or writeline() as
**tspan** element.
"""
elementname = 'textArea'
def __init__(self, text=None, insert=None, size=None, **extra):
super(TextArea, self).__init__(**extra)
if text is not None:
self.write(text)
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]
def line_increment(self, value):
""" Set the line-spacing to *value*. """
self['line-increment'] = value
def write(self, text, **extra):
"""
Add text as **tspan** elements, with extra-params for the **tspan** element.
Use the '\\\\n' character for line breaks.
"""
if '\n' not in text:
self.add(TSpan(text, **extra))
else:
lines = text.split('\n')
for line in lines[:-1]:
if line: # no text between '\n'+
self.add(TSpan(line, **extra))
self.add(TBreak())
# case "text\n" : last element is ''
# case "texta\ntextb : last element is 'textb'
if lines[-1]:
self.add(TSpan(lines[-1], **extra))
|