Legend bar

python/lognplot/chart/__init__.py

@@ -1,5 +1,6 @@
 from .axis import Axis
 from .chart import Chart
 from .curve import Curve
+from .legend import Legend, LegendMode
 from .logbar import LogTrack, LogBar
 from .event_tracks import EventTracks

python/lognplot/chart/chart.py

@@ -1,6 +1,7 @@
 import math
 from .axis import Axis
 from .curve import Curve
+from .legend import Legend
 from ..utils import bench_it
 from ..time import TimeSpan
 from ..tsdb import Aggregation, Metrics
@@ -17,7 +18,9 @@ class Chart:
     def __init__(self, db):
         self.x_axis = Axis()
         self.y_axis = Axis()
+        self.legend = Legend()
         self.curves = []
+        self.activeCurve = None
         self.cursor = None
         self.db = db
 
@@ -31,9 +34,15 @@ def add_curve(self, name, color):
         if not self.has_curve(name):
             curve = Curve(self.db, name, color)
             self.curves.append(curve)
+            self.change_active_curve(curve)
 
     def clear_curves(self):
         self.curves.clear()
+        self.y_axis = Axis()
+
+    def change_active_curve(self, curve):
+        self.activeCurve = curve
+        self.y_axis = self.activeCurve.axis
 
     def info(self):
         print(f"Chart with {len(self.curves)} series")

python/lognplot/chart/curve.py

@@ -1,5 +1,5 @@
 from ..tsdb.aggregation import Aggregation
-
+from .axis import Axis
 
 class Curve:
     """ A curve is a view onto a signal in the database.
@@ -14,6 +14,12 @@ def __init__(self, db, name, color):
         self._db = db
         self.name = name
         self.color = color
+        # Corresponding handle (polygon area)
+        self.handle = []
+        # Corresponding legend segment (polygon area)
+        self.legend_segment = []
+        # Each curve has its own vertical axis
+        self.axis = Axis()
 
     def __repr__(self):
         return "Database proxy-curve"

python/lognplot/chart/legend.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+class LegendMode(Enum):
+    SIGNAL_NAMES = 0
+    CURSOR_VALUES = 1
+    Y_AXIS_SCALE = 2
+
+class Legend:
+
+    def __init__(self):
+        self.modes = [LegendMode.SIGNAL_NAMES,
+                      LegendMode.CURSOR_VALUES,
+                      LegendMode.Y_AXIS_SCALE]
+        self.active_mode = 0
+
+    def next_mode(self):
+        self.active_mode = (self.active_mode + 1) % len(self.modes)
+
+    @property
+    def mode(self) -> LegendMode:
+        return self.modes[self.active_mode] 

python/lognplot/qt/render/base.py

@@ -35,7 +35,7 @@ def calc_y_ticks(self, axis):
         y_ticks = axis.get_ticks(amount_y_ticks)
         return y_ticks
 
-    def draw_grid(self, x_ticks, y_ticks):
+    def draw_grid(self, y_axis, x_ticks, y_ticks):
         """ Render a grid on the given x and y tick markers. """
         pen = QtGui.QPen(Qt.gray)
         pen.setWidth(1)
@@ -46,7 +46,7 @@ def draw_grid(self, x_ticks, y_ticks):
             self.painter.drawLine(x, self.layout.chart_top, x, self.layout.chart_bottom)
 
         for value, _ in y_ticks:
-            y = self.to_y_pixel(value)
+            y = self.to_y_pixel(y_axis, value)
             self.painter.drawLine(self.layout.chart_left, y, self.layout.chart_right, y)
 
     def draw_x_axis(self, x_ticks):
@@ -69,15 +69,15 @@ def draw_x_axis(self, x_ticks):
             text_y = y + 10 - text_rect.y()
             self.painter.drawText(text_x, text_y, label)
 
-    def draw_y_axis(self, y_ticks):
+    def draw_y_axis(self, y_axis, y_ticks):
         """ Draw the Y-axis. """
         pen = QtGui.QPen(Qt.black)
         pen.setWidth(2)
         self.painter.setPen(pen)
         x = self.layout.chart_right + 5
         self.painter.drawLine(x, self.layout.chart_top, x, self.layout.chart_bottom)
         for value, label in y_ticks:
-            y = self.to_y_pixel(value)
+            y = self.to_y_pixel(y_axis, value)
 
             # Tick handle:
             self.painter.drawLine(x, y, x + 5, y)

python/lognplot/qt/render/chart.py

@@ -1,5 +1,5 @@
 from ..qtapi import QtGui, QtCore, Qt
-from ...chart import Chart
+from ...chart import Axis, Chart
 from ...utils import bench_it
 from ...tsdb import Aggregation
 from .layout import ChartLayout
@@ -25,16 +25,19 @@ def render(self):
         y_ticks = self.calc_y_ticks(self.chart.y_axis)
 
         if self.options.show_grid:
-            self.draw_grid(x_ticks, y_ticks)
+            self.draw_grid(self.chart.y_axis, x_ticks, y_ticks)
 
         self.draw_bouding_rect()
 
         if self.options.show_axis:
             self.draw_x_axis(x_ticks)
-            self.draw_y_axis(y_ticks)
+            self.draw_y_axis(self.chart.y_axis, y_ticks)
+
+        if self.options.show_handles:
+            self._draw_handles()
 
         self._draw_curves()
-        self._draw_legend()
+
         self._draw_cursor()
 
     def shade_region(self, region):
@@ -77,17 +80,17 @@ def _draw_curve(self, curve):
 
         if data:
             if isinstance(data[0], Aggregation):
-                self._draw_aggregations_as_shape(data, curve_color)
+                self._draw_aggregations_as_shape(curve.axis, data, curve_color)
             else:
-                self._draw_samples_as_lines(data, curve_color)
+                self._draw_samples_as_lines(curve.axis, data, curve_color)
 
-    def _draw_samples_as_lines(self, samples, curve_color: QtGui.QColor):
+    def _draw_samples_as_lines(self, y_axis: Axis, samples, curve_color: QtGui.QColor):
         """ Draw raw samples as lines! """
         pen = QtGui.QPen(curve_color)
         pen.setWidth(2)
         self.painter.setPen(pen)
         points = [
-            QtCore.QPoint(self.to_x_pixel(x), self.to_y_pixel(y)) for (x, y) in samples
+            QtCore.QPoint(self.to_x_pixel(x), self.to_y_pixel(y_axis, y)) for (x, y) in samples
         ]
         line = QtGui.QPolygon(points)
         self.painter.drawPolyline(line)
@@ -98,7 +101,7 @@ def _draw_samples_as_lines(self, samples, curve_color: QtGui.QColor):
             self.painter.drawEllipse(rect)
 
     def _draw_aggregations_as_shape(
-        self, aggregations: Aggregation, curve_color: QtGui.QColor
+        self, y_axis: Axis, aggregations: Aggregation, curve_color: QtGui.QColor
     ):
         """ Draw aggregates as polygon shapes.
 
@@ -119,30 +122,30 @@ def _draw_aggregations_as_shape(
             # x2 = self.to_x_pixel(metric.x2)
 
             # max line:
-            y_max = self.to_y_pixel(aggregation.metrics.maximum)
+            y_max = self.to_y_pixel(y_axis, aggregation.metrics.maximum)
             max_points.append(QtCore.QPoint(x1, y_max))
             # max_points.append(QtCore.QPoint(x2, y_max))
 
             # min line:
-            y_min = self.to_y_pixel(aggregation.metrics.minimum)
+            y_min = self.to_y_pixel(y_axis, aggregation.metrics.minimum)
             min_points.append(QtCore.QPoint(x1, y_min))
             # min_points.append(QtCore.QPoint(x2, y_min))
 
             mean = aggregation.metrics.mean
             stddev = aggregation.metrics.stddev
 
             # Mean line:
-            y_mean = self.to_y_pixel(mean)
+            y_mean = self.to_y_pixel(y_axis, mean)
             mean_points.append(QtCore.QPoint(x1, y_mean))
             # mean_points.append(QtCore.QPoint(x2, y_mean))
 
             # stddev up line:
-            y_stddev_up = self.to_y_pixel(mean + stddev)
+            y_stddev_up = self.to_y_pixel(y_axis, mean + stddev)
             stddev_up_points.append(QtCore.QPoint(x1, y_stddev_up))
             # stddev_up_points.append(QtCore.QPoint(x2, y_stddev_up))
 
             # stddev down line:
-            y_stddev_down = self.to_y_pixel(mean - stddev)
+            y_stddev_down = self.to_y_pixel(y_axis, mean - stddev)
             stddev_down_points.append(QtCore.QPoint(x1, y_stddev_down))
             # stddev_down_points.append(QtCore.QPoint(x2, y_stddev_down))
 
@@ -188,31 +191,6 @@ def _draw_aggregations_as_shape(
             min_line = QtGui.QPolygon(min_points)
             self.painter.drawPolyline(min_line)
 
-    def _draw_legend(self):
-        """ Draw names / color of the curve next to eachother.
-        """
-        font_metrics = self.painter.fontMetrics()
-        x = self.layout.chart_left + 10
-        y = self.layout.chart_top + 10
-        text_height = font_metrics.height()
-        color_block_size = text_height * 0.8
-        for index, curve in enumerate(self.chart.curves):
-            color = QtGui.QColor(curve.color)
-            text = curve.name
-            text_rect = font_metrics.boundingRect(text)
-            legend_x = x
-            legend_y = y + index * text_height
-            text_x = legend_x + color_block_size + 3 - text_rect.x()
-            text_y = legend_y - text_rect.y() - text_rect.height() / 2
-            self.painter.drawText(text_x, text_y, text)
-            self.painter.fillRect(
-                x,
-                legend_y - color_block_size / 2,
-                color_block_size,
-                color_block_size,
-                color,
-            )
-
     def _draw_cursor(self):
         if self.chart.cursor:
             # Draw cursor line:
@@ -240,7 +218,7 @@ def _draw_cursor(self):
                 pen.setWidth(2)
                 self.painter.setPen(pen)
                 marker_x = self.to_x_pixel(curve_point_timestamp)
-                marker_y = self.to_y_pixel(curve_point_value)
+                marker_y = self.to_y_pixel(curve.axis, curve_point_value)
                 marker_size = 10
                 indicator_rect = QtCore.QRect(
                     marker_x - marker_size // 2,
@@ -251,27 +229,53 @@ def _draw_cursor(self):
                 self.painter.drawEllipse(indicator_rect)
 
                 # Legend:
-                text = "{} = {}".format(curve.name, curve_point_value)
-                text_rect = font_metrics.boundingRect(text)
-                # legend_y = y + index * text_height
-                legend_x = marker_x + 10
-                legend_y = marker_y
-                text_x = legend_x + color_block_size + 3 - text_rect.x()
-                text_y = legend_y - text_rect.y() - text_rect.height() / 2
-                self.painter.drawText(text_x, text_y, text)
-                self.painter.fillRect(
-                    legend_x,
-                    legend_y - color_block_size / 2,
-                    color_block_size,
-                    color_block_size,
-                    color,
-                )
+                if self.options.show_cursor_legend:
+                    text = "{} = {}".format(curve.name, curve_point_value)
+                    text_rect = font_metrics.boundingRect(text)
+                    # legend_y = y + index * text_height
+                    legend_x = marker_x + 10
+                    legend_y = marker_y
+                    text_x = legend_x + color_block_size + 3 - text_rect.x()
+                    text_y = legend_y - text_rect.y() - text_rect.height() / 2
+                    self.painter.drawText(text_x, text_y, text)
+                    self.painter.fillRect(
+                        legend_x,
+                        legend_y - color_block_size / 2,
+                        color_block_size,
+                        color_block_size,
+                        color,
+                    )
+
+    def _draw_handles(self):
+        x = self.layout.handles.left()
+
+        for _, curve in enumerate(self.chart.curves):
+            handle_y = self.to_y_pixel(curve.axis, 0)
+            x_full = self.options.handle_width
+            x_half = x_full / 2
+            y_half = self.options.handle_height / 2
+
+            curve.handle = [
+                QtCore.QPointF(x, handle_y - y_half),
+                QtCore.QPointF(x, handle_y - y_half),
+                QtCore.QPointF(x + x_half, handle_y - y_half),
+                QtCore.QPointF(x + x_full, handle_y),
+                QtCore.QPointF(x + x_half, handle_y + y_half),
+                QtCore.QPointF(x, handle_y + y_half)
+            ] 
+
+            polygon = QtGui.QPainterPath(curve.handle[0])
+            for p in curve.handle[1:]:
+                polygon.lineTo(p)
+
+            color = QtGui.QColor(curve.color)
+            self.painter.fillPath(polygon, QtGui.QBrush(color))
 
     def to_x_pixel(self, value):
         return transform.to_x_pixel(value, self.chart.x_axis, self.layout)
 
-    def to_y_pixel(self, value):
-        return transform.to_y_pixel(value, self.chart.y_axis, self.layout)
+    def to_y_pixel(self, y_axis, value):
+        return transform.to_y_pixel(value, y_axis, self.layout)
 
     def x_pixel_to_domain(self, pixel):
         axis = self.chart.x_axis

python/lognplot/qt/render/layout.py

@@ -18,15 +18,34 @@ def __init__(self, rect: QtCore.QRect, options):
     def do_layout(self):
         # self.right = self.rect.right()
         # self.bottom = self.rect.bottom()
-        self.chart_top = self.rect.top() + self.options.padding
-        self.chart_left = self.rect.left() + self.options.padding
         if self.options.show_axis:
             axis_height = self.axis_height
             axis_width = self.axis_width
         else:
             axis_height = 0
             axis_width = 0
 
+        if self.options.show_legend:
+            self.legend = QtCore.QRect(self.rect.left() + self.options.padding,
+                                       self.rect.top() + self.options.padding,
+                                       self.rect.right() - 2 * self.options.padding,
+                                       self.options.legend_height)
+
+            self.chart_top = self.legend.bottom() + 10
+        else:
+            self.chart_top = self.rect.top() + self.options.padding
+
+        self.handles = QtCore.QRect(self.rect.left() + self.options.padding,
+                                    self.rect.top(),
+                                    self.options.handle_width,
+                                    self.rect.height())
+
+        if self.options.show_handles:
+            self.chart_left = self.handles.right() + 3
+        else:
+            self.chart_left = self.rect.left() + self.options.padding
+
+
         self.chart_bottom = self.rect.bottom() - self.options.padding - axis_height
         self.chart_right = self.rect.right() - self.options.padding - axis_width
         self.chart_width = self.chart_right - self.chart_left