def textlinesize(self, string, font):
ttfont = ttfont_for(font)
if ttfont is None:
size = self.draw.textsize(string, font=None)
font_ratio = font.size * 1.0 / FontMap.BASE_FONTSIZE
size = Size(int(size[0] * font_ratio), int(size[1] * font_ratio))
else:
size = Size(*ttfont.getsize(string))
return size
def __init__(self, node1, node2):
super(DiagramEdge, self).__init__(node1, node2)
self.leftnote = None
self.leftnotesize = Size(0, 0)
self.rightnote = None
self.rightnotesize = Size(0, 0)
self.textwidth = 0
self.textheight = 0
self.order = 0
self.activate = True
self.asynchronous = False
self.diagonal = False
self.failed = False
self.return_label = ''
def _scale(cls, value, ratio):
if ratio == 1:
return value
klass = value.__class__
if klass == XY:
ret = XY(value.x * ratio, value.y * ratio)
elif klass == Size:
ret = Size(value.width * ratio, value.height * ratio)
elif klass == Box:
ret = Box(value[0] * ratio, value[1] * ratio,
value[2] * ratio, value[3] * ratio)
elif klass == tuple:
ret = tuple([cls.scale(x, ratio) for x in value])
elif klass == list:
ret = [cls.scale(x, ratio) for x in value]
elif klass == EdgeLines:
ret = EdgeLines()
ret.polylines = cls.scale(value.polylines, ratio)
elif klass == FontInfo:
ret = FontInfo(value.familyname, value.path, value.size * ratio)
elif klass == int:
ret = value * ratio
elif klass == str:
ret = value
else:
ret = cls(value, ratio)
return ret
def __init__(self, node, metrics=None):
super(Actor, self).__init__(node, metrics)
m = metrics.cell(node)
if node.label:
font = metrics.font_for(self.node)
textsize = metrics.textsize(node.label, font)
shortside = min(m.width, m.height - textsize.height)
else:
textsize = Size(0, 0)
shortside = min(m.width, m.height)
r = self.radius = shortside // 8 # radius of actor's head
self.center = metrics.cell(node).center
self.connectors[0] = XY(self.center.x, self.center.y - r * 9 // 2)
self.connectors[1] = XY(self.center.x + r * 4, self.center.y)
self.connectors[2] = XY(self.center.x,
self.center.y + r * 4 + textsize.height)
self.connectors[3] = XY(self.center.x - r * 4, self.center.y)
self.textbox = Box(m.left.x,
self.center.y + r * 4,
m.right.x,
self.connectors[2].y)
def textsize(string, font):
"""Measure rendering size (width and height) of line.
Returned size will not be exactly as rendered text size,
Because this method does not use fonts to measure size.
"""
width = (zenkaku_len(string) * font.size +
hankaku_len(string) * font.size * 0.55)
return Size(int(math.ceil(width)), font.size)
def textsize(self, text, scaled=False):
if isinstance(text, string_types):
textsize = self.drawer.textlinesize(text, self.font)
else:
if text:
size = [self.textsize(s) for s in text]
width = max(s.width for s in size)
height = (sum(s.height for s in size) + self.line_spacing *
(len(text) - 1))
textsize = Size(width, height)
else:
textsize = Size(0, 0)
if scaled:
textsize = Size(textsize.width * self.scale,
textsize.height * self.scale)
return textsize
def pagesize(self, width, height):
margin = self.metrics.page_margin
padding = self.metrics.page_padding
dummy = DiagramNode(None)
dummy.xy = XY(width - 1, height - 1)
x, y = self._node_bottomright(dummy, use_padding=False)
x_span = self.span_width[width]
y_span = self.span_height[height]
return Size(x + margin.x + padding[1] + x_span,
y + margin.y + padding[2] + y_span)
def __init__(self, filename, **kwargs):
self.filename = filename
self.transparency = kwargs.get('transparency')
self.bgcolor = kwargs.get('color', (256, 256, 256))
self._image = None
self.draw = None
if kwargs.get('parent'):
self.scale_ratio = kwargs.get('parent').scale_ratio
else:
self.scale_ratio = kwargs.get('scale_ratio', 1)
self.set_canvas_size(Size(1, 1)) # This line make textsize() workable
def func(self, *args, **kwargs):
args = list(args)
if kwargs.get('filter') not in ('blur', 'transp-blur'):
return fn(self, *args, **kwargs)
else:
box = get_shape_box(*args)
args[0] = get_abs_coordinate(box, *args)
size = Size(box.width + PADDING * 2, box.height + PADDING * 2)
shadow = create_shadow(self, size, *args, **kwargs)
xy = XY(box.x1 - PADDING, box.y1 - PADDING)
self.paste(shadow, xy, shadow)
def test_size_resize(self):
size = Size(10, 20)
resized = size.resize(width=50, height=50)
self.assertEqual((50, 50), resized)
resized = size.resize(width=50)
self.assertEqual((50, 100), resized)
resized = size.resize(height=50)
self.assertEqual((25, 50), resized)
resized = size.resize(scale=50)
self.assertEqual((5, 10), resized)
resized = size.resize(width=50, scale=50)
self.assertEqual((25, 50), resized)
resized = size.resize(height=50, scale=50)
self.assertEqual((12.5, 25), resized)
resized = size.resize(width=50, height=50, scale=50)
self.assertEqual((25, 25), resized)
def textlinesize(self, string, font, **kwargs):
return Size(len(string) * 15, 10)
def textlinesize(self, string, font, **kwargs):
s = self.drawer.textsize(string)
return Size(s[0], s[1])
def test_size_to_integer_point(self):
size = Size(1.5, 2.5)
self.assertEqual((1, 2), size.to_integer_point())
def textsize(self, text):
length = len(text)
return Size(CHAR_WIDTH * length, CHAR_HEIGHT)
def __init__(self, filename, **kwargs):
self.filename = filename
self.size = Size(0, 0)
self.buffer = []
def __init__(self, filename, **kwargs):
self.filename = filename
self.canvas = None
self.fonts = {}
self.set_canvas_size(Size(1, 1)) # This line make textsize() workable
def textlinesize(self, string, font):
self.set_font(font)
width = self.canvas.stringWidth(string, font.path, font.size)
return Size(int(math.ceil(width)), font.size)
