""" 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