improved_main_window.py

"""@package docstring
B-ASIC GUI Module.
This python file is the main window of the GUI for B-ASIC.
"""

from os import getcwd, path
import sys

from drag_button import DragButton
from gui_interface import Ui_main_window
from arrow import Arrow
from port_button import PortButton

from b_asic import Operation
import b_asic.core_operations as c_oper
import b_asic.special_operations as s_oper
from utils import decorate_class, handle_error

from numpy import linspace

from PyQt5.QtWidgets import QApplication, QWidget, QMainWindow, QLabel, QAction,\
QStatusBar, QMenuBar, QLineEdit, QPushButton, QSlider, QScrollArea, QVBoxLayout,\
QHBoxLayout, QDockWidget, QToolBar, QMenu, QLayout, QSizePolicy, QListWidget,\
QListWidgetItem, QGraphicsView, QGraphicsScene, QShortcut
from PyQt5.QtCore import Qt, QSize
from PyQt5.QtGui import QIcon, QFont, QPainter, QPen, QBrush, QKeySequence


@decorate_class(handle_error)
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_main_window()
        self.ui.setupUi(self)
        self.setWindowTitle(" ")
        self.setWindowIcon(QIcon('small_logo.png'))
        self.scene = None
        self._operations_from_name = dict()
        self.zoom = 1
        self.operationList = []
        self.signalList = []
        self.pressed_button = []
        self.portList = []
        self.pressed_ports = []
        self.source = None
        self._window = self

        self.init_ui()
        self.add_operations_from_namespace(c_oper, self.ui.core_operations_list)
        self.add_operations_from_namespace(s_oper, self.ui.special_operations_list)

        self.shortcut_core = QShortcut(QKeySequence("Ctrl+R"), self.ui.operation_box)
        self.shortcut_core.activated.connect(self._refresh_operations_list_from_namespace)

    def init_ui(self):
        self.ui.core_operations_list.itemClicked.connect(self.on_list_widget_item_clicked)
        self.ui.special_operations_list.itemClicked.connect(self.on_list_widget_item_clicked)
        self.ui.exit_menu.triggered.connect(self.exit_app)
        self.create_graphics_view()

    def create_graphics_view(self):
        self.scene = QGraphicsScene()
        self.graphic_view = QGraphicsView(self.scene, self)
        self.graphic_view.setRenderHint(QPainter.Antialiasing)
        self.graphic_view.setGeometry(250, 40, 600, 520)
        self.graphic_view.setDragMode(QGraphicsView.ScrollHandDrag)

    def wheelEvent(self, event):
        old_zoom = self.zoom
        self.zoom += event.angleDelta().y()/2500
        self.graphic_view.scale(self.zoom, self.zoom)
        self.zoom = old_zoom

    def exit_app(self, checked):
        QApplication.quit()

    def _determine_port_distance(self, length, ports):
        """Determine the distance between each port on the side of an operation.
        The method returns the distance that each port should have from 0.
        """
        return [length / 2] if ports == 1 else linspace(0, length, ports)

    def _create_port(self, operation, output_port=True):
        text = ">" if output_port else "<"
        button = PortButton(text, operation, self)
        button.setStyleSheet("background-color: white")
        button.connectionRequested.connect(self.connectButton)
        return button

    def add_ports(self, operation):
        _output_ports_dist = self._determine_port_distance(50 - 15, operation.operation.output_count)
        _input_ports_dist = self._determine_port_distance(50 - 15, operation.operation.input_count)

        for dist in _input_ports_dist:
            port = self._create_port(operation)
            port.move(0, dist)
            port.show()

        for dist in _output_ports_dist:
            port = self._create_port(operation)
            port.move(50 - 15, dist)
            port.show()

    def get_operations_from_namespace(self, namespace):
        return [comp for comp in dir(namespace) if hasattr(getattr(namespace, comp), "type_name")]

    def add_operations_from_namespace(self, namespace, _list):
        for attr_name in self.get_operations_from_namespace(namespace):
            attr = getattr(namespace, attr_name)
            try:
                attr.type_name()
                item = QListWidgetItem(attr_name)
                _list.addItem(item)
                self._operations_from_name[attr_name] = attr
            except NotImplementedError:
                pass

    def _create_operation(self, item):
        try:
            attr_oper = self._operations_from_name[item.text()]()
            attr_button = DragButton(attr_oper.graph_id, attr_oper, attr_oper.type_name().lower(), self)
            attr_button.move(250, 100)
            attr_button.setFixedSize(50, 50)
            attr_button.setStyleSheet("background-color: white; border-style: solid;\
            border-color: black; border-width: 2px; border-radius: 10px")
            self.add_ports(attr_button)

            icon_path = path.join("operation_icons", f"{attr_oper.type_name().lower()}.png")
            if not path.exists(icon_path):
                icon_path = path.join("operation_icons", f"custom_operation.png")
            attr_button.setIcon(QIcon(icon_path))
            attr_button.setIconSize(QSize(50, 50))

            attr_button.setParent(None)
            self.scene.addWidget(attr_button)
            self.operationList.append(attr_button)
        except Exception as e:
            print("Unexpected error occured: ", e)

    def _refresh_operations_list_from_namespace(self):
        self.ui.core_operations_list.clear()
        self.ui.special_operations_list.clear()

        self.add_operations_from_namespace(c_oper, self.ui.core_operations_list)
        self.add_operations_from_namespace(s_oper, self.ui.special_operations_list)

    def print_input_port_1(self):
        print("Input port 1")

    def print_input_port_2(self):
        print("Input port 2")

    def print_output_port_1(self):
        print("Output port 1")

    def print_output_port_2(self):
        print("Output port 2")

    def on_list_widget_item_clicked(self, item):
        self._create_operation(item)

    def keyPressEvent(self, event):
        pressed_buttons = []
        for op in self.operationList:
            if op.pressed:
                pressed_buttons.append(op)
        if event.key() == Qt.Key_Delete:
            for pressed_op in pressed_buttons:
                self.operationList.remove(pressed_op)
                pressed_op.remove()
        super().keyPressEvent(event)

    def connectButton(self, button):
        if len(self.pressed_ports) < 2:
            return
        for i in range(len(self.pressed_ports) - 1):
            line = Arrow(self.pressed_ports[i], self.pressed_ports[i + 1], self)
            self.scene.addItem(line)
            self.signalList.append(line)

        self.update()

    def paintEvent(self, event):
        for signal in self.signalList:
            signal.moveLine()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())