Beispiel #1
0
    def _layout_as_overlay(self, size=None, force=False):
        """ Lays out the label as an overlay on another component.
        """
        if self.component is not None:
            orientation = self.overlay_position
            outside = True
            if "inside" in orientation:
                tmp = orientation.split()
                tmp.remove("inside")
                orientation = tmp[0]
                outside = False
            elif "outside" in orientation:
                tmp = orientation.split()
                tmp.remove("outside")
                orientation = tmp[0]

            if orientation in ("left", "right"):
                self.y = self.component.y
                self.height = self.component.height
                if not outside:
                    gc = font_metrics_provider()
                    self.width = self._label.get_bounding_box(gc)[0]
                if orientation == "left":
                    if outside:
                        self.x = self.component.outer_x
                        self.width = self.component.padding_left
                    else:
                        self.outer_x = self.component.x
                elif orientation == "right":
                    if outside:
                        self.x = self.component.x2 + 1
                        self.width = self.component.padding_right
                    else:
                        self.x = self.component.x2 - self.outer_width
            elif orientation in ("bottom", "top"):
                self.x = self.component.x
                self.width = self.component.width
                if not outside:
                    gc = font_metrics_provider()
                    self.height = self._label.get_bounding_box(gc)[1]
                if orientation == "bottom":
                    if outside:
                        self.y = self.component.outer_y
                        self.height = self.component.padding_bottom
                    else:
                        self.outer_y = self.component.y
                elif orientation == "top":
                    if outside:
                        self.y = self.component.y2 + 1
                        self.height = self.component.padding_top
                    else:
                        self.y = self.component.y2 - self.outer_height
            else:
                # Leave the position alone
                pass
        return
Beispiel #2
0
    def _layout_as_overlay(self, size=None, force=False):
        """ Lays out the label as an overlay on another component.
        """
        if self.component is not None:
            orientation = self.overlay_position
            outside = True
            if "inside" in orientation:
                tmp = orientation.split()
                tmp.remove("inside")
                orientation = tmp[0]
                outside = False
            elif "outside" in orientation:
                tmp = orientation.split()
                tmp.remove("outside")
                orientation = tmp[0]

            if orientation in ("left", "right"):
                self.y = self.component.y
                self.height = self.component.height
                if not outside:
                    gc = font_metrics_provider()
                    self.width = self._label.get_bounding_box(gc)[0]
                if orientation == "left":
                    if outside:
                        self.x = self.component.outer_x
                        self.width = self.component.padding_left
                    else:
                        self.outer_x = self.component.x
                elif orientation == "right":
                    if outside:
                        self.x = self.component.x2 + 1
                        self.width = self.component.padding_right
                    else:
                        self.x = self.component.x2 - self.outer_width
            elif orientation in ("bottom", "top"):
                self.x = self.component.x
                self.width = self.component.width
                if not outside:
                    gc = font_metrics_provider()
                    self.height = self._label.get_bounding_box(gc)[1]
                if orientation == "bottom":
                    if outside:
                        self.y = self.component.outer_y
                        self.height = self.component.padding_bottom
                    else:
                        self.outer_y = self.component.y
                elif orientation == "top":
                    if outside:
                        self.y = self.component.y2 + 1
                        self.height = self.component.padding_top
                    else:
                        self.y = self.component.y2 - self.outer_height
            else:
                # Leave the position alone
                pass
        return
Beispiel #3
0
    def _get_plateau_label(self, x1, x2, y):

        if self.layout_needed or not self.plateau_label:
            p = self.plateau_label
        else:
            comp = self.component
            x = x1 + (x2 - x1) * 0.5

            dummy_gc = font_metrics_provider()
            l = Label(text=self.info_txt)
            w, h = l.get_bounding_box(dummy_gc)

            xa = x + w / 2.
            hjustify = 'center'
            if xa > comp.x2:
                d = xa - comp.x2
                x -= d
            elif x - w / 2. < comp.x:
                x = comp.x + 5
                hjustify = 'left'

            x = max(comp.x, x)
            p = PlotLabel(text=self.info_txt,
                          font=self.label_font,
                          # font='modern {}'.format(self.label_font_size),
                          color=self.line_color,
                          hjustify=hjustify,
                          border_visible=True,
                          bgcolor='white',
                          x=x,
                          y=y + 10)
            self.plateau_label = p

        return p
Beispiel #4
0
    def _get_plateau_label(self, x1, x2, y):

        if self.layout_needed or not self.plateau_label:
            p = self.plateau_label
        else:
            comp = self.component
            ox, oy = comp.map_screen([(0, self.y + self.label_offset)])[0]
            # print self.label_offset, self.y, oy, y
            # ox,oy=self.component.map_screen([self.y+self.label_offset])[0]
            # print oy, self.label_offset, y,self.y
            # oy=10

            x = x1 + (x2 - x1) * 0.5

            dummy_gc = font_metrics_provider()
            l = Label(text=self.info_txt)
            w, h = l.get_bounding_box(dummy_gc)

            xa = x + w / 2.
            hjustify = 'center'
            if xa > comp.x2:
                d = xa - comp.x2
                x -= d
            elif x - w / 2. < comp.x:
                x = comp.x + 5
                hjustify = 'left'

            p = PlotLabel(text=self.info_txt,
                          font='modern {}'.format(self.label_font_size),
                          hjustify=hjustify,
                          x=x,
                          y=oy + 15)
            self.plateau_label = p

        return p
    def _do_layout(self, component=None):
        if component is None:
            component = self.component

        if component is not None:
            self.x = component.x
            # FIXME: Adding 2 to the self.y because there is a tiny gap
            # at the top of the toolbar where components from the block
            # canvas show through.
            self.y = component.y2 - self.toolbar_height + 2
            self.height = self.toolbar_height
            self.width = component.width

        metrics = font_metrics_provider()
        if self.order == "right-to-left":
            last_button_position = self.width - self.button_spacing
            for b in self.components:
                x, y, w, h = metrics.get_text_extent(b.label)
                b.width = w + 2 * b.label_padding
                b.x = last_button_position - b.width
                b.y = self.button_vposition
                last_button_position -= b.width + self.button_spacing * 2
        else:
            last_button_position = 0
            for b in self.components:
                x, y, w, h = metrics.get_text_extent(b.label)
                b.width = w + 2 * b.label_padding
                b.x = self.button_spacing + last_button_position
                b.y = self.button_vposition
                last_button_position += b.width + self.button_spacing * 2
Beispiel #6
0
    def _get_plateau_label(self, x1, x2, y):

        if self.layout_needed or not self.plateau_label:
            p = self.plateau_label
        else:
            comp = self.component
            x = x1 + (x2 - x1) * 0.5

            dummy_gc = font_metrics_provider()
            l = Label(text=self.info_txt)
            w, h = l.get_bounding_box(dummy_gc)

            xa = x + w / 2.
            hjustify = 'center'
            if xa > comp.x2:
                d = xa - comp.x2
                x -= d
            elif x - w / 2. < comp.x:
                x = comp.x + 5
                hjustify = 'left'

            x = max(comp.x, x)
            p = PlotLabel(text=self.info_txt,
                          font=self.label_font,
                          # font='modern {}'.format(self.label_font_size),
                          color=self.line_color,
                          hjustify=hjustify,
                          border_visible=True,
                          bgcolor='white',
                          x=x,
                          y=y + 10)
            self.plateau_label = p

        return p
Beispiel #7
0
    def _do_layout(self, component=None):
        if component is None:
            component = self.component

        if component is not None:
            self.x = component.x
            # FIXME: Adding 2 to the self.y because there is a tiny gap
            # at the top of the toolbar where components from the block
            # canvas show through.
            self.y = component.y2 - self.toolbar_height + 2
            self.height = self.toolbar_height
            self.width = component.width

        metrics = font_metrics_provider()
        if self.order == "right-to-left":
            last_button_position = self.width - self.button_spacing
            for b in self.components:
                x, y, w, h = metrics.get_text_extent(b.label)
                b.width = w + 2*b.label_padding
                b.x = last_button_position - b.width
                b.y = self.button_vposition
                last_button_position -= b.width + self.button_spacing*2
        else:
            last_button_position = 0
            for b in self.components:
                x, y, w, h = metrics.get_text_extent(b.label)
                b.width = w + 2*b.label_padding
                b.x = self.button_spacing + last_button_position
                b.y = self.button_vposition
                last_button_position += b.width + self.button_spacing*2
Beispiel #8
0
    def get_preferred_size(self):
        """ Returns the label's preferred size.

        Overrides PlotComponent.
        """
        dummy_gc = font_metrics_provider()
        size = self._label.get_bounding_box(dummy_gc)
        return size
Beispiel #9
0
    def get_preferred_size(self):
        """ Returns the label's preferred size.

        Overrides PlotComponent.
        """
        dummy_gc = font_metrics_provider()
        size = self._label.get_bounding_box(dummy_gc)
        return size
Beispiel #10
0
    def __init__(self, *args, **kwargs):
        super(EditField, self).__init__(*args, **kwargs)

        if self.metrics is None:
            self.metrics = font_metrics_provider()

        # If no bounds have been set, make sure it is wide enough to
        # display the text
        if self.height == 0 and self.width == 0 and len(self._text) > 0:
            self.update_bounds()
Beispiel #11
0
    def __init__(self, *args, **kwargs):
        super(EditField, self).__init__(*args, **kwargs)

        if self.metrics is None:
            self.metrics = font_metrics_provider()

        # If no bounds have been set, make sure it is wide enough to
        # display the text
        if self.height == 0 and self.width == 0 and len(self._text) > 0:
            self.update_bounds()
Beispiel #12
0
    def __init__(self, *args, **kwargs):
        """ Override __init__ so that we can initialize bounds.
        """

        self._font_metrics_provider = font_metrics_provider()
        super(CanvasBox, self).__init__(*args, **kwargs)

        self.tools.append(BoxSelectionTool(self))
        self.move_tool = BoxMoveTool(self)
        self.tools.append(self.move_tool)
Beispiel #13
0
    def __init__(self, *args, **kwargs):
        """ Override __init__ so that we can initialize bounds.
        """

        self._font_metrics_provider = font_metrics_provider()
        super(CanvasBox, self).__init__(*args, **kwargs)

        self.tools.append(BoxSelectionTool(self))
        self.move_tool = BoxMoveTool(self)
        self.tools.append(self.move_tool)
Beispiel #14
0
 def get_ticks_and_labels(self, data_low, data_high, bounds_low, bounds_high,
                          orientation = "h"):
     # TODO: add support for Interval
     # TODO: add support for vertical labels
     metrics = font_metrics_provider()
     if self.font is not None and hasattr(metrics, "set_font"):
         metrics.set_font(self.font)
     test_str = "0123456789-+"
     charsize = metrics.get_full_text_extent(test_str)[0] / len(test_str)
     numchars = (bounds_high - bounds_low) / charsize
     tmp = zip(*self.scale.labels(data_low, data_high, numlabels=8, char_width=numchars))
     # Check to make sure we actually have labels/ticks to show before
     # unpacking the return tuple into (tick_array, labels).
     if len(tmp) == 0:
         return array([]), []
     else:
         return array(tmp[0]), tmp[1]
Beispiel #15
0
 def __font_metrics_provider_default(self):
     return font_metrics_provider()
Beispiel #16
0
 def _recompute_font_metrics(self):
     if self.label != "":
         metrics = font_metrics_provider()
         metrics.set_font(self.label_font)
         self._text_extents = metrics.get_text_extent(self.label)
Beispiel #17
0
    def get_preferred_size(self):
        """
        Computes the size and position of the legend based on the maximum size of
        the labels, the alignment, and position of the component to overlay.
        """
        # Gather the names of all the labels we will create
        if len(self.plots) == 0:
            return [0, 0]

        # plot_names, visible_plots = list(map(list, list(zip(*sorted(self.plots.items())))))
        plot_names, visible_plots = [
            list(a) for a in zip(*sorted(self.plots.items()))
        ]

        label_names, names = list(zip(*self.labels))
        if len(label_names) == 0:
            if len(self.plots) > 0:
                label_names = plot_names
            else:
                self._cached_labels = []
                self._cached_label_sizes = []
                self._cached_label_names = []
                self._cached_visible_plots = []
                self.outer_bounds = [0, 0]
                return [0, 0]

        if self.hide_invisible_plots:
            visible_labels = []
            visible_plots = []
            for key, name in self.labels:
                # If the user set self.labels, there might be a bad value,
                # so ensure that each name is actually in the plots dict.
                if key in self.plots:
                    val = self.plots[key]
                    # Rather than checking for a list/TraitListObject/etc., we just check
                    # for the attribute first
                    if hasattr(val, 'visible'):
                        if val.visible:
                            visible_labels.append(name)
                            visible_plots.append(val)
                    else:
                        # If we have a list of renderers, add the name if any of them are
                        # visible
                        for renderer in val:
                            if renderer.visible:
                                visible_labels.append(name)
                                visible_plots.append(val)
                                break
            label_names = visible_labels

        # Create the labels
        labels = [self._create_label(text) for text in label_names]

        # For the legend title
        if self.title_at_top:
            labels.insert(0, self._create_label(self.title))
            label_names.insert(0, 'Legend Label')
            visible_plots.insert(0, None)
        else:
            labels.append(self._create_label(self.title))
            label_names.append(self.title)
            visible_plots.append(None)

        # We need a dummy GC in order to get font metrics
        dummy_gc = font_metrics_provider()
        label_sizes = array(
            [label.get_width_height(dummy_gc) for label in labels])

        if len(label_sizes) > 0:
            max_label_width = max(label_sizes[:, 0])
            total_label_height = sum(
                label_sizes[:, 1]) + (len(label_sizes) - 1) * self.line_spacing
        else:
            max_label_width = 0
            total_label_height = 0

        legend_width = max_label_width + self.icon_spacing + self.icon_bounds[0] \
                       + self.hpadding + 2 * self.border_padding
        legend_height = total_label_height + self.vpadding + 2 * self.border_padding

        self._cached_labels = labels
        self._cached_label_sizes = label_sizes
        self._cached_label_positions = zeros_like(label_sizes)
        self._cached_label_names = label_names
        self._cached_visible_plots = visible_plots

        if "h" not in self.resizable:
            legend_width = self.outer_width
        if "v" not in self.resizable:
            legend_height = self.outer_height
        return [legend_width, legend_height]
Beispiel #18
0
    def get_preferred_size(self):
        """
        Computes the size and position of the legend based on the maximum size of
        the labels, the alignment, and position of the component to overlay.
        """
        # Gather the names of all the labels we will create
        if len(self.plots) == 0:
            return [0, 0]

        plot_names, visible_plots = map(list, zip(*sorted(self.plots.items())))
        label_names = self.labels
        if len(label_names) == 0:
            if len(self.plots) > 0:
                label_names = plot_names
            else:
                self._cached_labels = []
                self._cached_label_sizes = []
                self._cached_label_names = []
                self._cached_visible_plots = []
                self.outer_bounds = [0, 0]
                return [0, 0]

        if self.hide_invisible_plots:
            visible_labels = []
            visible_plots = []
            for i, name in enumerate(label_names):
                val = self.plots[plot_names[i]]
                # Rather than checking for a list/TraitListObject/etc., we just check
                # for the attribute first
                if hasattr(val, 'visible'):
                    if val.visible:
                        visible_labels.append(name)
                        visible_plots.append(val)
                else:
                    # If we have a list of renderers, add the name if any of them are
                    # visible
                    for renderer in val:
                        if renderer.visible:
                            visible_labels.append(name)
                            visible_plots.append(val)
                            break
            label_names = visible_labels

        # Create the labels
        labels = [self._create_label(text) for text in label_names]

        # For the legend title
        if self.title_at_top:
            labels.insert(0, self._create_label(self.title))
            label_names.insert(0, 'Legend Label')
            visible_plots.insert(0, None)
        else:
            labels.append(self._create_label(self.title))
            label_names.append(self.title)
            visible_plots.append(None)

        # We need a dummy GC in order to get font metrics
        dummy_gc = font_metrics_provider()
        label_sizes = array([label.get_width_height(dummy_gc) for label in labels])

        if len(label_sizes) > 0:
            max_label_width = max(label_sizes[:, 0])
            total_label_height = sum(label_sizes[:, 1]) + (len(label_sizes)-1)*self.line_spacing
        else:
            max_label_width = 0
            total_label_height = 0

        legend_width = max_label_width + self.icon_spacing + self.icon_bounds[0] \
                        + self.hpadding + 2*self.border_padding
        legend_height = total_label_height + self.vpadding + 2*self.border_padding

        self._cached_labels = labels
        self._cached_label_sizes = label_sizes
        self._cached_label_positions = zeros_like(label_sizes)
        self._cached_label_names = label_names
        self._cached_visible_plots = visible_plots

        if "h" not in self.resizable:
            legend_width = self.outer_width
        if "v" not in self.resizable:
            legend_height = self.outer_height
        return [legend_width, legend_height]
Beispiel #19
0
 def _recompute_font_metrics(self):
     if self.label != "":
         metrics = font_metrics_provider()
         metrics.set_font(self.label_font)
         self._text_extents = metrics.get_text_extent(self.label)
    def __init__(self, *args, **kwargs):
        super(FontMetricsCache, self).__init__(*args, **kwargs)

        if self.metrics is None:
            self.metrics = font_metrics_provider()
Beispiel #21
0
 def __font_metrics_provider_default(self):
     return font_metrics_provider()
    def __init__(self, *args, **kwargs):
        super(FontMetricsCache, self).__init__(*args, **kwargs)

        if self.metrics is None:
            self.metrics = font_metrics_provider()