scheduler_event.py

#!/usr/bin/env python3
"""
B-ASIC Scheduler-GUI Graphics Scheduler Event Module.

Contains the scheduler_ui SchedulerEvent class containing event filters and
handlers for SchedulerItem objects.
"""
import math
from typing import List, Optional, overload

# QGraphics and QPainter imports
from qtpy.QtCore import QEvent, QObject, QPointF, Qt, Signal
from qtpy.QtWidgets import QGraphicsItem, QGraphicsSceneMouseEvent

from b_asic.schedule import Schedule
from b_asic.scheduler_gui._preferences import OPERATION_GAP, OPERATION_HEIGHT
from b_asic.scheduler_gui.axes_item import AxesItem
from b_asic.scheduler_gui.operation_item import OperationItem
from b_asic.scheduler_gui.timeline_item import TimelineItem


class SchedulerEvent:  # PyQt5
    """
    Event filter and handlers for SchedulerItem.

    Parameters
    ----------
    parent : QGraphicsItem, optional
        The parent QGraphicsItem.
    """

    class Signals(QObject):  # PyQt5
        """A class representing signals."""

        component_selected = Signal(str)
        schedule_time_changed = Signal()
        component_moved = Signal(str)
        redraw_all = Signal()
        reopen = Signal()
        execution_time_plot = Signal(str)

    _axes: Optional[AxesItem]
    _current_pos: QPointF
    _delta_time: int
    _signals: Signals  # PyQt5
    _schedule: Schedule
    _old_op_position: int = -1

    def __init__(self, parent: Optional[QGraphicsItem] = None):  # PyQt5
        super().__init__(parent=parent)
        self._signals = self.Signals()

    def is_component_valid_pos(self, item: OperationItem, pos: float) -> bool:
        raise NotImplementedError

    def is_valid_delta_time(self, delta_time: int) -> bool:
        raise NotImplementedError

    def change_schedule_time(self, delta_time: int) -> None:
        raise NotImplementedError

    def set_item_active(self, item: OperationItem) -> None:
        raise NotImplementedError

    def set_item_inactive(self, item: OperationItem) -> None:
        raise NotImplementedError

    ###########
    # Filters #
    ###########
    @overload
    def installSceneEventFilters(self, filterItems: QGraphicsItem) -> None: ...

    @overload
    def installSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None: ...

    def installSceneEventFilters(self, filterItems) -> None:
        """
        Install an event filter for *filterItems* on 'self'.

        This causes all events for *filterItems* to first pass through
        :meth:`sceneEventFilter`. *filterItems* can be one object or a list of objects.
        """
        item: OperationItem
        for item in filterItems:
            item.installSceneEventFilter(self)

    @overload
    def removeSceneEventFilters(self, filterItems: QGraphicsItem) -> None: ...

    @overload
    def removeSceneEventFilters(self, filterItems: List[QGraphicsItem]) -> None: ...

    def removeSceneEventFilters(self, filterItems) -> None:
        """
        Remove an event filter on *filterItems* from *self*.

        *filterItems* can be one object or a list of objects.
        """
        item: OperationItem
        for item in filterItems:
            item.removeSceneEventFilter(self)

    def sceneEventFilter(self, item: QGraphicsItem, event: QEvent) -> bool:
        """
        Return True if the event was filtered (i.e. stopped), otherwise False.

        If False is returned, the event is forwarded to the appropriate child in
        the event chain.
        """

        if isinstance(item, OperationItem):  # one component
            switch = {
                QEvent.GraphicsSceneMouseMove: self.operation_mouseMoveEvent,
                QEvent.GraphicsSceneMousePress: self.operation_mousePressEvent,
                QEvent.GraphicsSceneMouseRelease: self.operation_mouseReleaseEvent,
            }
            handler = switch.get(event.type())

        elif isinstance(item, TimelineItem):  # the timeline
            switch = {
                QEvent.GraphicsSceneMouseMove: self.timeline_mouseMoveEvent,
                QEvent.GraphicsSceneMousePress: self.timeline_mousePressEvent,
                QEvent.GraphicsSceneMouseRelease: self.timeline_mouseReleaseEvent,
            }
            handler = switch.get(event.type())

        else:
            raise TypeError(
                f"Received an unexpected event '{event.type()}' "
                f"from an '{type(item).__name__}' object."
            )

        if handler is not None:
            handler(event)
            return True
        return False

    #################################
    # Event Handlers: OperationItem #
    #################################

    def operation_mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """
        Set the position of the graphical element in the graphic scene.

        This translates coordinates of the cursor within the graphic element in the
        coordinate system of the parent object.
        """

        def update_pos(operation_item, dx, dy):
            pos_x = operation_item.x() + dx
            if self.is_component_valid_pos(operation_item, pos_x):
                pos_y = operation_item.y() + dy * (OPERATION_GAP + OPERATION_HEIGHT)
                operation_item.setX(pos_x)
                operation_item.setY(pos_y)
                self._current_pos.setX(self._current_pos.x() + dx)
                self._current_pos.setY(self._current_pos.y() + dy)
                self._redraw_lines(operation_item)
                gid = operation_item.operation.graph_id
                self._schedule.set_y_location(
                    gid, dy + self._schedule.get_y_location(gid)
                )

        item: OperationItem = self.scene().mouseGrabberItem()
        delta_x = (item.mapToParent(event.pos()) - self._current_pos).x()
        delta_y = (item.mapToParent(event.pos()) - self._current_pos).y()

        delta_y_steps = round(2 * delta_y / (OPERATION_GAP + OPERATION_HEIGHT)) / 2
        if delta_x > 0.505:
            update_pos(item, 1, delta_y_steps)
        elif delta_x < -0.505:
            update_pos(item, -1, delta_y_steps)
        elif delta_y_steps != 0:
            update_pos(item, 0, delta_y_steps)

    def operation_mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """
        Change the cursor to ClosedHandCursor or open context menu.

        This is used when grabbing an object and stores the current position in item's
        parent coordinates. *event* will by default be accepted, and this item is then
        the mouse grabber. This allows the item to receive future move, release and
        double-click events.
        """
        item: OperationItem = self.scene().mouseGrabberItem()
        if event.button() == Qt.MouseButton.LeftButton:
            self._old_op_position = self._schedule.get_y_location(
                item.operation.graph_id
            )
            self._signals.component_selected.emit(item.graph_id)
            self._current_pos = item.mapToParent(event.pos())
            self.set_item_active(item)
            event.accept()
        else:  # Right-button
            item._open_context_menu()
            self._signals.redraw_all.emit()

    def operation_mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """Change the cursor to OpenHandCursor when releasing an object."""
        if event.button() != Qt.MouseButton.LeftButton:
            return

        item: OperationItem = self.scene().mouseGrabberItem()
        self.set_new_start_time(item)
        self.set_item_inactive(item)
        pos_x = item.x()
        redraw = False
        if pos_x < 0:
            pos_x += self._schedule.schedule_time
            redraw = True
        if pos_x > self._schedule.schedule_time:
            # If zero execution time, keep operation at the edge
            if (
                pos_x > self._schedule.schedule_time + 1
                or item.operation.execution_time
            ):
                pos_x = pos_x % self._schedule.schedule_time
                redraw = True
        pos_y = self._schedule.get_y_location(item.operation.graph_id)
        # Check move in y-direction
        if pos_y != self._old_op_position:
            self._schedule.move_y_location(
                item.operation.graph_id,
                math.ceil(pos_y),
                (pos_y % 1) != 0,
            )
            print(
                f"schedule.move_y_location({item.operation.graph_id!r},"
                f" {math.ceil(pos_y)}, {(pos_y % 1) != 0})"
            )
            self._signals.redraw_all.emit()
        # Operation has been moved in x-direction
        if redraw:
            item.setX(pos_x)
            self._redraw_lines(item)
        self._signals.component_moved.emit(item.graph_id)

    ###################################
    # Event Handlers: GraphicsLineTem #
    ###################################
    def timeline_mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """
        Set the position of the graphical element in the graphic scene.

        This translates coordinates of the cursor within the graphic element in the
        coordinate system of the parent object. The object can only move
        horizontally in x-axis scale steps.
        """

        def update_pos(timeline_item, dx):
            pos = timeline_item.x() + dx
            if self.is_valid_delta_time(self._delta_time + dx):
                timeline_item.setX(pos)
                self._current_pos.setX(self._current_pos.x() + dx)
                self._delta_time += dx
                timeline_item.set_text(self._delta_time)

        item: TimelineItem = self.scene().mouseGrabberItem()
        delta_x = (item.mapToParent(event.pos()) - self._current_pos).x()
        if delta_x > 0.505:
            update_pos(item, 1)
        elif delta_x < -0.505:
            update_pos(item, -1)

    def timeline_mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """
        Store the current position in item's parent coordinates.

        *event* will by default be accepted, and this item is then the mouse grabber.
        This allows the item to receive future move, release and double-click events.
        """
        item: TimelineItem = self.scene().mouseGrabberItem()
        self._delta_time = 0
        item.set_text(self._delta_time)
        item.show_label()
        self._current_pos = item.mapToParent(event.pos())
        event.accept()

    def timeline_mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
        """Update the schedule time."""
        item: TimelineItem = self.scene().mouseGrabberItem()
        item.hide_label()
        if self._delta_time != 0:
            self.change_schedule_time(self._delta_time)
            self._signals.schedule_time_changed.emit()