graphics_axis_item.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from operator import contains
import os
import sys
from typing     import Any, Optional
from pprint     import pprint
from typing     import Any, AnyStr, Generic, Protocol, TypeVar, Union, Optional, overload, Final, final
# from typing_extensions import Self, Final, Literal, LiteralString, TypeAlias, final
import numpy    as np
from copy       import deepcopy
from math       import cos, sin, pi

import qtpy
from qtpy import QtCore
from qtpy import QtGui
from qtpy import QtWidgets

# QGraphics and QPainter imports
from qtpy.QtCore    import (
    Qt, QObject, QRect, QRectF, QPoint, QSize, QSizeF, QByteArray)
from qtpy.QtGui     import (
    QPaintEvent, QPainter, QPainterPath, QColor, QBrush, QPen, QFont, QPolygon, QIcon, QPixmap,
    QLinearGradient, QTransform, QPolygonF)
from qtpy.QtWidgets import (
    QGraphicsView, QGraphicsScene, QGraphicsWidget,
    QGraphicsLayout, QGraphicsLinearLayout, QGraphicsGridLayout, QGraphicsLayoutItem, QGraphicsAnchorLayout,
    QGraphicsItem, QGraphicsItemGroup, QGraphicsPathItem, QGraphicsLineItem, QGraphicsTextItem, QGraphicsRectItem,
    QStyleOptionGraphicsItem, QWidget, QGraphicsObject, QGraphicsSimpleTextItem, QGraphicsPolygonItem)
from qtpy.QtCore    import (
    QPoint, QPointF)

# B-ASIC
import logger
from graphics_graph_event   import GraphicsGraphEvent



class GraphicsAxisItem(QGraphicsItemGroup):

    _scale:     float = 1.0 # static, changed from MainWindow
    _width:     float
    _height:    float
    _dy_height: float
    _x_indent:  float
    _axis:      dict[str, QGraphicsItemGroup|QGraphicsLineItem]

    def __init__(self, width: float = 10.0, height: float = 10.0, x_indent: float = 2.0, parent: QGraphicsItem = None):
        super().__init__(parent)

        self._dy_height = 5/self._scale
        self._axis = {}
        # self.setFlag(QGraphicsItem.ItemIsMovable)
        # self.setFlag(QGraphicsItem.ItemIsSelectable)
        # self.setAcceptHoverEvents(True)

        self.update_(width, height, x_indent)
    

    @property
    def width(self) -> float:
        return self._axis['w']
    # @width.setter
    # def width(self, width: float) -> None:
    #     self._axis['w'] = width
    #     self.prepareGeometryChange()
    #     self._axis.clear()
    #     self._make_axis()

    @property
    def height(self) -> float:
        return self._axis['h']
    # @height.setter
    # def height(self, height: float) -> None:
    #     self._axis['h'] = height
    #     self.prepareGeometryChange()
    #     self._axis.clear()
    #     self._make_axis()

    # def _clear(self) -> None:
    #     for child in self._axis.values():
    #         del child

    def update_(self, width, height, x_indent) -> None:
        self._width = width
        self._height = height
        self._x_indent = x_indent
        
        # make sure the group is empty
        keys = list(self._axis.keys())
        for key in keys:
            self._axis[key].setParentItem(None)
            del self._axis[key]

        # define pencils
        pen = QPen()
        pen.setWidthF(2/self._scale)
        pen.setJoinStyle(Qt.MiterJoin)
        ledger_pen = QPen(Qt.lightGray)
        ledger_pen.setWidthF(0)         # 0 = cosmetic pen 1px width
        
        # x-axis
        self._axis['x'] = QGraphicsItemGroup()
        line = QGraphicsLineItem(0, 0, self._width, 0)
        line.setPen(pen)
        self._axis['x'].addToGroup(line)
        # x-axis arrow
        arrow_size = 8/self._scale
        p0 = QPointF(0, sin(pi/6) * arrow_size)
        p1 = QPointF(arrow_size, 0)
        p2 = QPointF(0, -sin(pi/6) * arrow_size)
        polygon = QPolygonF([p0, p1, p2])
        arrow = QGraphicsPolygonItem(polygon)
        arrow.setPen(pen)
        arrow.setBrush(QBrush(Qt.SolidPattern))
        arrow.setPos(self._width, 0)
        self._axis['x'].addToGroup(arrow)
        # x-axis scale
        x_scale = []
        x_scale_labels = []
        x_ledger = []
        self._axis['x_ledger'] = QGraphicsItemGroup()
        for i in range(int(self._width/10) + 1):
            # vertical x-scale
            x_scale.append(QGraphicsLineItem(0, 0, 0, 0.5))
            x_scale[i].setPen(pen)
            x_scale[i].setPos(self._x_indent + i*10, 0)
            self._axis['x'].addToGroup(x_scale[i])
            # numbers
            x_scale_labels.append(QGraphicsSimpleTextItem(str(i)))
            x_scale_labels[i].setScale(x_scale_labels[i].scale() / self._scale)
            half_width = x_scale_labels[i].boundingRect().width()/(2*self._scale)
            x_scale_labels[i].setPos(self._x_indent + i*10 - half_width, 0.8)
            self._axis['x'].addToGroup(x_scale_labels[i])
            # vertical x-ledger
            x_ledger.append(QGraphicsLineItem(0, 0, 0, self._height))
            if i == int(self._width/10):
                ledger_pen.setWidthF(2/self._scale)
                ledger_pen.setStyle(Qt.DashLine)
                ledger_pen.setColor(Qt.black)
            x_ledger[i].setPen(ledger_pen)
            x_ledger[i].setPos(self._x_indent + i*10, 0)
            self._axis['x_ledger'].addToGroup(x_ledger[i])
        # x-axis label
        label = QGraphicsSimpleTextItem('time')
        label.setScale(label.scale() / self._scale)
        half_width = label.boundingRect().width()/(2*self._scale)
        arrow_half_width = arrow_size/2
        label.setPos(self._width - half_width + arrow_half_width, 0.8)
        self._axis['x'].addToGroup(label)
        self._axis['x'].boundingRect()

        # y-axis
        self._axis['y'] = QGraphicsLineItem(0, 0, 0, self._height + self._dy_height)
        self._axis['y'].setPen(pen)
        
        # put it all together
        self._axis['x'].setPos(0, self._height + self._dy_height)
        self._axis['x_ledger'].setPos(0, self._dy_height)
        self.addToGroup(self._axis['x_ledger'])
        self.addToGroup(self._axis['x'])
        self.addToGroup(self._axis['y'])