/usr/lib/python2.7/dist-packages/chaco/label.py is in python-chaco 4.4.1-1.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 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 | """ Defines the Label class.
"""
from __future__ import with_statement
# Major library imports
from math import cos, sin, pi
from numpy import array, dot
# Enthought library imports
from enable.api import black_color_trait, transparent_color_trait
from kiva.constants import FILL
from kiva.trait_defs.kiva_font_trait import KivaFont
from traits.api import (Any, Bool, Float, HasTraits, Int, List, Str,
on_trait_change)
class Label(HasTraits):
""" A label used by overlays.
Label is not a Component; it's just an object encapsulating text settings
and appearance attributes. It can be used by components that need text
labels to store state, perform layout, and render the text.
"""
# The anchor point is the position on the label that is placed at the
# label's position. The label is also rotated relative to this point.
# "Left" refers to the left edge of the text's bounding box (including
# margin), while "center" refers to the horizontal and vertical center
# of the bounding box.
# TODO: Implement this and test thoroughly
#anchor = Enum("left", "right", "top", "bottom", "center",
# "top left", "top right", "bottom left", "bottom right")
# The label text. Carriage returns (\n) are always connverted into
# line breaks.
text = Str
# The angle of rotation of the label.
rotate_angle = Float(0)
# The color of the label text.
color = black_color_trait
# The background color of the label.
bgcolor = transparent_color_trait
# The width of the label border. If it is 0, then it is not shown.
border_width = Int(0)
# The color of the border.
border_color = black_color_trait
# Whether or not the border is visible
border_visible = Bool(True)
# The font of the label text.
font = KivaFont("modern 10")
# Number of pixels of margin around the label, for both X and Y dimensions.
margin = Int(2)
# Number of pixels of spacing between lines of text.
line_spacing = Int(5)
# Number of pixels to limit the width of the label to. Lines which are
# too long will be broken to fit on word boundaries. Line width is
# calculated without considering the value of `margin`.
# A `max_width` of 0.0 means that lines will not be broken.
max_width = Float(0.0)
#------------------------------------------------------------------------
# Private traits
#------------------------------------------------------------------------
_bounding_box = List()
_position_cache_valid = Bool(False)
_text_needs_fitting = Bool(False)
_line_xpos = Any()
_line_ypos = Any()
_rot_matrix = Any()
def __init__(self, **traits):
super(Label, self).__init__(**traits)
self._bounding_box = [0, 0]
return
def get_width_height(self, gc):
""" Returns the width and height of the label, in the rotated frame of
reference.
"""
self._fit_text_to_max_width(gc)
self._calc_line_positions(gc)
width, height = self._bounding_box
return width, height
def get_bounding_box(self, gc):
""" Returns a rectangular bounding box for the Label as (width,height).
"""
width, height = self.get_width_height(gc)
if self.rotate_angle in (90.0, 270.0):
return (height, width)
elif self.rotate_angle in (0.0, 180.0):
return (width, height)
else:
angle = self.rotate_angle
return (abs(width*cos(angle))+abs(height*sin(angle)),
abs(height*sin(angle))+abs(width*cos(angle)))
def get_bounding_poly(self, gc):
""" Returns a list [(x0,y0), (x1,y1),...] of tuples representing a
polygon that bounds the label.
"""
width, height = self.get_width_height(gc)
offset = array(self.get_bounding_box(gc))/2.
# unrotated points relative to centre
base_points = [
array([[-width/2.], [-height/2.]]),
array([[-width/2.], [height/2.]]),
array([[width/2.], [height/2.]]),
array([[width/2.], [-height/2.]]),
array([[-width/2.], [-height/2.]]),
]
# rotate about centre, and offset to bounding box coords
points = [dot(self.get_rotation_matrix(), point).transpose()[0]+offset
for point in base_points]
return points
def get_rotation_matrix(self):
return array([[cos(self.rotate_angle), -sin(self.rotate_angle)],
[sin(self.rotate_angle), cos(self.rotate_angle)]])
def draw(self, gc):
""" Draws the label.
This method assumes the graphics context has been translated to the
correct position such that the origin is at the lower left-hand corner
of this text label's box.
"""
# Make sure `max_width` is respected
self._fit_text_to_max_width(gc)
# For this version we're not supporting rotated text.
self._calc_line_positions(gc)
with gc:
bb_width, bb_height = self.get_bounding_box(gc)
# Rotate label about center of bounding box
width, height = self._bounding_box
gc.translate_ctm(bb_width/2.0, bb_height/2.0)
gc.rotate_ctm(pi/180.0*self.rotate_angle)
gc.translate_ctm(-width/2.0, -height/2.0)
# Draw border and fill background
if self.bgcolor != "transparent":
gc.set_fill_color(self.bgcolor_)
gc.draw_rect((0, 0, width, height), FILL)
if self.border_visible and self.border_width > 0:
gc.set_stroke_color(self.border_color_)
gc.set_line_width(self.border_width)
border_offset = (self.border_width-1)/2.0
gc.rect(border_offset, border_offset,
width-2*border_offset, height-2*border_offset)
gc.stroke_path()
gc.set_fill_color(self.color_)
gc.set_stroke_color(self.color_)
gc.set_font(self.font)
if self.font.size <= 8.0:
gc.set_antialias(0)
else:
gc.set_antialias(1)
lines = self.text.split("\n")
if self.border_visible:
gc.translate_ctm(self.border_width, self.border_width)
width, height = self.get_width_height(gc)
for i, line in enumerate(lines):
if line == "":
continue
x_offset = round(self._line_xpos[i])
y_offset = round(self._line_ypos[i])
gc.set_text_position(x_offset, y_offset)
gc.show_text(line)
#------------------------------------------------------------------------
# Trait handlers
#------------------------------------------------------------------------
def _text_changed(self):
self._text_needs_fitting = (self.max_width > 0.0)
@on_trait_change("font,margin,text,rotate_angle")
def _invalidate_position_cache(self):
self._position_cache_valid = False
#------------------------------------------------------------------------
# Private methods
#------------------------------------------------------------------------
def _fit_text_to_max_width(self, gc):
""" Break the text into lines whose width is no greater than
`max_width`.
"""
if self._text_needs_fitting:
lines = []
with gc:
gc.set_font(self.font)
for line in self.text.split('\n'):
if line == "":
lines.append(line)
continue
width = gc.get_full_text_extent(line)[0]
if width > self.max_width:
line_words = []
for word in line.split():
line_words.append(word)
test_line = ' '.join(line_words)
width = gc.get_full_text_extent(test_line)[0]
if width > self.max_width:
if len(line_words) > 1:
lines.append(' '.join(line_words[:-1]))
line_words = [word]
else:
lines.append(word)
line_words = []
if len(line_words) > 0:
lines.append(' '.join(line_words))
else:
lines.append(line)
self.trait_setq(text='\n'.join(lines))
self._text_needs_fitting = False
def _calc_line_positions(self, gc):
if not self._position_cache_valid:
with gc:
gc.set_font(self.font)
# The bottommost line starts at postion (0, 0).
x_pos = []
y_pos = []
self._bounding_box = [0, 0]
margin = self.margin
prev_y_pos = margin
prev_y_height = -self.line_spacing
max_width = 0
for line in self.text.split("\n")[::-1]:
if line != "":
(width, height, descent, leading) = \
gc.get_full_text_extent(line)
ascent = height - abs(descent)
if width > max_width:
max_width = width
new_y_pos = prev_y_pos + prev_y_height \
+ self.line_spacing
else:
# For blank lines, we use the height of the previous
# line, if there is one. The width is 0.
leading = 0
if prev_y_height != -self.line_spacing:
new_y_pos = prev_y_pos + prev_y_height \
+ self.line_spacing
ascent = prev_y_height
else:
new_y_pos = prev_y_pos
ascent = 0
x_pos.append(-leading + margin)
y_pos.append(new_y_pos)
prev_y_pos = new_y_pos
prev_y_height = ascent
self._line_xpos = x_pos[::-1]
self._line_ypos = y_pos[::-1]
border_width = self.border_width if self.border_visible else 0
self._bounding_box[0] = max_width + 2*margin + 2*border_width
self._bounding_box[1] = prev_y_pos + prev_y_height + margin \
+ 2*border_width
self._position_cache_valid = True
return
|