Add scheduler GUI

b_asic/scheduler_gui/graphics_axes_item.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""B-ASIC Scheduler-gui Graphics Axes Item Module.
+
+Contains the scheduler-gui GraphicsAxesItem class for drawing and maintain the
+axes in a graph.
+"""
+from typing     import Union, Optional, List
+from math       import sin, pi
+
+# QGraphics and QPainter imports
+from qtpy.QtCore    import Qt, QPoint, QPointF
+from qtpy.QtGui     import QBrush, QPen, QPolygonF
+from qtpy.QtWidgets import (
+    QGraphicsItem, QGraphicsItemGroup, QGraphicsLineItem,
+    QGraphicsSimpleTextItem, QGraphicsPolygonItem)
+
+# B-ASIC
+from b_asic.scheduler_gui.graphics_timeline_item import GraphicsTimelineItem
+
+
+
+class GraphicsAxesItem(QGraphicsItemGroup):
+    """A class to represent axes in a graph."""
+    _scale:             float = 1.0
+    """Static, changed from MainWindow."""
+    _width:             int
+    _width_indent:      float
+    _width_padding:     float
+    _height:            int
+    _height_indent:     float
+    _height_padding:    float
+    _x_axis:            QGraphicsLineItem
+    _x_label:           QGraphicsSimpleTextItem
+    _x_arrow:           QGraphicsPolygonItem
+    _x_scale:           List[QGraphicsLineItem]
+    _x_scale_labels:    List[QGraphicsSimpleTextItem]
+    _x_ledger:          List[Union[QGraphicsLineItem, GraphicsTimelineItem]]
+    _x_label_offset:    float
+    _y_axis:            QGraphicsLineItem
+    _event_items:       List[QGraphicsItem]
+    _base_pen:          QPen
+    _ledger_pen:        QPen
+    _timeline_pen:      QPen
+
+
+    def __init__(self, width: int, height: int,
+                 width_indent: Optional[float]  = 0.2,
+                 height_indent: Optional[float] = 0.2,
+                 width_padding: Optional[float] = 0.6,
+                 height_padding: Optional[float] = 0.5,
+                 parent: Optional[QGraphicsItem] = None):
+        """
+        Constructs a GraphicsAxesItem.
+        *parent* is passed to QGraphicsItemGroup's constructor.
+        """
+        super().__init__(parent=parent)
+        assert width >= 0, f"'width' greater or equal to 0 expected, got: {width}."
+        assert height >= 0, f"'height' greater or equal to 0 expected, got: {height}."
+
+        self._width             = width
+        self._height            = height
+        self._width_indent      = width_indent
+        self._height_indent     = height_indent
+        self._width_padding     = width_padding
+        self._height_padding    = height_padding
+        self._x_axis            = QGraphicsLineItem()
+        self._x_label           = QGraphicsSimpleTextItem()
+        self._x_arrow           = QGraphicsPolygonItem()
+        self._x_scale           = []
+        self._x_scale_labels    = []
+        self._x_ledger          = []
+        self._x_label_offset    = 0.2
+        self._y_axis            = QGraphicsLineItem()
+        self._event_items       = []
+
+        self._base_pen          = QPen()
+        self._base_pen.setWidthF(2/self._scale)
+        self._base_pen.setJoinStyle(Qt.MiterJoin)
+        self._ledger_pen        = QPen(Qt.lightGray)
+        self._ledger_pen.setWidthF(0)         # 0 = cosmetic pen 1px width
+        self._timeline_pen      = QPen(Qt.black)
+        self._timeline_pen.setWidthF(2/self._scale)
+        self._timeline_pen.setStyle(Qt.DashLine)
+
+        self._make_base()
+
+
+    def clear(self) -> None:
+        """Sets all children's parent to 'None' and delete the axes."""
+        # TODO: update, needed?
+        # self._timeline.setParentItem(None)
+        self._event_items = []
+        keys = list(self._axes.keys())
+        for key in keys:
+            self._axes[key].setParentItem(None)
+            del self._axes[key]
+
+
+    @property
+    def width(self) -> int:
+        """Get or set the current x-axis width. Setting the width to a new
+        value will update the axes automatically."""
+        return self._width
+    # @width.setter
+    # def width(self, width: int) -> None:
+    #     if self._width != width:
+    #         self.update_axes(width = width)
+
+    @property
+    def height(self) -> int:
+        """Get or set the current y-axis height. Setting the height to a new
+        value will update the axes automatically."""
+        return self._height
+    # @height.setter
+    # def height(self, height: int) -> None:
+    #     if self._height != height:
+    #         self.update_axes(height = height)
+
+    # @property
+    # def width_indent(self) -> float:
+    #     """Get or set the current x-axis indent. Setting the indent to a new
+    #     value will update the axes automatically."""
+    #     return self._width_indent
+    # @width_indent.setter
+    # def width_indent(self, width_indent: float) -> None:
+    #     if self._width_indent != width_indent:
+    #         self.update_axes(width_indent = width_indent)
+
+    @property
+    def event_items(self) -> List[QGraphicsItem]:
+        """Returnes a list of objects, that receives events."""
+        return [self._x_ledger[-1]]
+
+    def _register_event_item(self, item: QGraphicsItem) -> None:
+        """Register an object that receives events."""
+        self._event_items.append(item)
+
+    def set_height(self, height: int) -> "GraphicsAxesItem":
+        # TODO: implement, docstring
+        raise NotImplementedError
+        return self
+
+    def set_width(self, width: int) -> "GraphicsAxesItem":
+        # TODO: docstring
+        assert width >= 0, f"'width' greater or equal to 0 expected, got: {width}."
+        delta_width = width - self._width
+
+        if delta_width > 0:
+            for _ in range(delta_width):
+                self._append_x_tick()
+                self._width += 1
+        elif delta_width < 0:
+            for _ in range(abs(delta_width)):
+                self._pop_x_tick()
+                self._width -= 1
+
+        return self
+
+    def _pop_x_tick(self) -> None:
+        # TODO: docstring
+
+        # remove the next to last x_scale, x_scale_labels and x_ledger
+        x_scale = self._x_scale.pop(-2)
+        x_scale_labels = self._x_scale_labels.pop(-2)
+        x_ledger = self._x_ledger.pop(-2)
+        x_scale.setParentItem(None)
+        x_scale_labels.setParentItem(None)
+        x_ledger.setParentItem(None)
+        del x_scale
+        del x_scale_labels
+        del x_ledger
+
+        # move timeline x_scale and x_scale_labels (timeline already moved by event)
+        self._x_scale[-1].setX(self._x_scale[-1].x() - 1)
+        self._x_scale_labels[-1].setX(self._x_scale_labels[-1].x() - 1)
+        self._x_scale_labels[-1].setText(str(len(self._x_scale) - 1))
+
+        # move arrow, x-axis label and decrease x-axis
+        self._x_arrow.setX(self._x_arrow.x() - 1)
+        self._x_label.setX(self._x_label.x() - 1)
+        self._x_axis.setLine(0, 0, self._width_indent + self._width-1 + self._width_padding, 0)
+
+
+
+    def _append_x_tick(self) -> None:
+        # TODO: docstring
+
+        index = len(self._x_scale)
+        is_timeline = True
+        if index != 0:
+            index -= 1
+            is_timeline = False
+
+        ## make a new x-tick
+        # x-axis scale line
+        self._x_scale.insert(index, QGraphicsLineItem(0, 0, 0, 0.05))
+        self._x_scale[index].setPen(self._base_pen)
+        pos = self.mapToScene(QPointF(self._width_indent + index, 0))
+        self._x_scale[index].setPos(pos)
+        self.addToGroup(self._x_scale[index])
+
+        # x-axis scale number
+        self._x_scale_labels.insert(index, QGraphicsSimpleTextItem(str(index)))
+        self._x_scale_labels[index].setScale(1 / self._scale)
+        x_pos = self._width_indent + index
+        x_pos -= self.mapRectFromItem(
+            self._x_scale_labels[index],
+            self._x_scale_labels[index].boundingRect()).width()/2
+        pos = self.mapToScene(QPointF(x_pos, self._x_label_offset))
+        self._x_scale_labels[index].setPos(pos)
+        self.addToGroup(self._x_scale_labels[index])
+
+        self._x_ledger.insert(
+            index, GraphicsTimelineItem(0, 0, 0, -(self._height_indent +
+                                                   self._height +
+                                                   self._height_padding)))
+        # x-axis vertical ledger
+        if is_timeline:  # last line is a timeline
+            self._x_ledger[index].setPen(self._timeline_pen)
+            self._x_ledger[index].set_text_scale(1.05/self._scale)
+            self._register_event_item(self._x_ledger[index])
+        else:
+            self._x_ledger[index].setPen(self._ledger_pen)
+        pos = self.mapToScene(QPointF(self._width_indent + index, 0))
+        self._x_ledger[index].setPos(pos)
+        self.addToGroup(self._x_ledger[index])
+        self._x_ledger[index].stackBefore(self._x_axis)
+
+        ## expand x-axis and move arrow,x-axis label, last x-scale, last x-scale-label
+        if not is_timeline:
+            # expand x-axis, move arrow and x-axis label
+            self._x_axis.setLine(0, 0, self._width_indent + index + 1 + self._width_padding, 0)
+            self._x_arrow.setX(self._x_arrow.x() + 1)
+            self._x_label.setX(self._x_label.x() + 1)
+            # move last x-scale and x-scale-label
+            self._x_scale_labels[index + 1].setX(self._x_scale_labels[index + 1].x() + 1)
+            self._x_scale_labels[index + 1].setText(str(index + 1))
+            self._x_scale[index + 1].setX(self._x_scale[index + 1].x() + 1)
+
+
+    def _make_base(self) -> None:
+
+        # x axis
+        self._x_axis.setLine(0, 0, self._width_indent + self._width_padding, 0)
+        self._x_axis.setPen(self._base_pen)
+        self.addToGroup(self._x_axis)
+
+        # x-axis arrow
+        arrow_size = 8/self._scale
+        point_0 = QPointF(0, sin(pi/6) * arrow_size)
+        point_1 = QPointF(arrow_size, 0)
+        point_2 = QPointF(0, -sin(pi/6) * arrow_size)
+        polygon = QPolygonF([point_0, point_1, point_2])
+        self._x_arrow.setPolygon(polygon)
+        self._x_arrow.setPen(self._base_pen)
+        self._x_arrow.setBrush(QBrush(Qt.SolidPattern))
+        self._x_arrow.setPos(self._width_indent + self._width_padding, 0)
+        self.addToGroup(self._x_arrow)
+
+        # x-axis label
+        self._x_label.setText('time')
+        self._x_label.setScale(1 / self._scale)
+        x_pos = self._width_indent + 0 + self._width_padding  # end of x-axis
+        x_pos += self.mapRectFromItem(self._x_arrow,
+                                      self._x_arrow.boundingRect()).width()/2  # + half arrow width
+        x_pos -= self.mapRectFromItem(self._x_label,
+                                      self._x_label.boundingRect()).width()/2  # - center of label
+        self._x_label.setPos(x_pos, self._x_label_offset)
+        self.addToGroup(self._x_label)
+
+        # x-axis timeline
+        self._append_x_tick()
+        for _ in range(self._width):
+            self._append_x_tick()
+        pos = self._x_ledger[-1].pos()
+        self._x_ledger[-1].setPos(pos + QPoint(self._width, 0))     # move timeline
+
+        # y-axis
+        self._y_axis.setLine(0, 0, 0,
+                             -(self._height_indent + self._height +
+                               self._height_padding + 0.05))
+        self._y_axis.setPen(self._base_pen)
+        self.addToGroup(self._y_axis)