"""
B-ASIC Signal Flow Graph Editor Module.
This file opens the main SFG editor window of the GUI for B-ASIC when run.
"""
import importlib.util
import logging
import os
import sys
import webbrowser
from collections import deque
from types import ModuleType
from typing import TYPE_CHECKING, Deque, Dict, List, Optional, Sequence, Tuple, cast
from qtpy.QtCore import QCoreApplication, QFileInfo, QSettings, QSize, Qt, QThread, Slot
from qtpy.QtGui import QCursor, QIcon, QKeySequence, QPainter
from qtpy.QtWidgets import (
QAction,
QApplication,
QFileDialog,
QGraphicsItem,
QGraphicsScene,
QGraphicsTextItem,
QGraphicsView,
QInputDialog,
QLineEdit,
QListWidget,
QListWidgetItem,
QMainWindow,
QShortcut,
QStatusBar,
)
import b_asic.core_operations
import b_asic.special_operations
from b_asic._version import __version__
from b_asic.GUI._preferences import GAP, GRID, MINBUTTONSIZE, PORTHEIGHT
from b_asic.GUI.arrow import Arrow
from b_asic.GUI.drag_button import DragButton
from b_asic.GUI.gui_interface import Ui_main_window
from b_asic.GUI.port_button import PortButton
from b_asic.GUI.precedence_graph_window import PrecedenceGraphWindow
from b_asic.GUI.select_sfg_window import SelectSFGWindow
from b_asic.GUI.simulate_sfg_window import SimulateSFGWindow
from b_asic.GUI.simulation_worker import SimulationWorker
from b_asic.GUI.util_dialogs import FaqWindow, KeybindingsWindow
from b_asic.gui_utils.about_window import AboutWindow
from b_asic.gui_utils.decorators import decorate_class, handle_error
from b_asic.gui_utils.icons import get_icon
from b_asic.gui_utils.plot_window import PlotWindow
from b_asic.operation import Operation
from b_asic.port import InputPort, OutputPort
from b_asic.save_load_structure import python_to_sfg, sfg_to_python
from b_asic.signal import Signal
from b_asic.signal_flow_graph import SFG
from b_asic.simulation import Simulation
from b_asic.special_operations import Input, Output
if TYPE_CHECKING:
from qtpy.QtWidgets import QGraphicsProxyWidget
logging.basicConfig(level=logging.INFO)
QCoreApplication.setOrganizationName("Linköping University")
QCoreApplication.setOrganizationDomain("liu.se")
QCoreApplication.setApplicationName("B-ASIC SFG GUI")
QCoreApplication.setApplicationVersion(__version__)
@decorate_class(handle_error)
class SFGMainWindow(QMainWindow):
def __init__(self):
super().__init__()
self._logger = logging.getLogger(__name__)
self._window = self
self._ui = Ui_main_window()
self._ui.setupUi(self)
self.setWindowIcon(QIcon("small_logo.png"))
self._scene = QGraphicsScene(self._ui.splitter)
self._operations_from_name: Dict[str, Operation] = {}
self._zoom = 1
self._drag_operation_scenes: Dict[DragButton, "QGraphicsProxyWidget"] = {}
self._drag_buttons: Dict[Operation, DragButton] = {}
self._mouse_pressed = False
self._mouse_dragging = False
self._starting_port = None
self._pressed_operations: List[DragButton] = []
self._arrow_ports: Dict[Arrow, List[Tuple[PortButton, PortButton]]] = {}
self._operation_to_sfg: Dict[DragButton, SFG] = {}
self._pressed_ports: List[PortButton] = []
self._sfg_dict: Dict[str, SFG] = {}
self._plot: Dict[Simulation, PlotWindow] = {}
self._ports: Dict[DragButton, List[PortButton]] = {}
# Create Graphics View
self._graphics_view = QGraphicsView(self._scene, self._ui.splitter)
self._graphics_view.setRenderHint(QPainter.Antialiasing)
self._graphics_view.setGeometry(
self._ui.operation_box.width(), 20, self.width(), self.height()
)
self._graphics_view.setDragMode(QGraphicsView.RubberBandDrag)
# Create toolbar
self._toolbar = self.addToolBar("Toolbar")
self._toolbar.addAction(get_icon('open'), "Load SFG", self.load_work)
self._toolbar.addAction(get_icon('save'), "Save SFG", self.save_work)
self._toolbar.addSeparator()
self._toolbar.addAction(
get_icon('new-sfg'), "Create SFG", self.create_sfg_from_toolbar
)
self._toolbar.addAction(
get_icon('close'), "Clear workspace", self._clear_workspace
)
# Create status bar
self._statusbar = QStatusBar(self)
self.setStatusBar(self._statusbar)
# Add operations
self._max_recent_files = 4
self._recent_files_actions: List[QAction] = []
self._recent_files_paths: Deque[str] = deque(maxlen=self._max_recent_files)
self.add_operations_from_namespace(
b_asic.core_operations, self._ui.core_operations_list
)
self.add_operations_from_namespace(
b_asic.special_operations, self._ui.special_operations_list
)
self._shortcut_refresh_operations = QShortcut(
QKeySequence("Ctrl+R"), self._ui.operation_box
)
self._shortcut_refresh_operations.activated.connect(
self._refresh_operations_list_from_namespace
)
self._scene.selectionChanged.connect(self._select_operations)
self.move_button_index = 0
self._ui.actionShowPC.triggered.connect(self._show_precedence_graph)
self._ui.actionSimulateSFG.triggered.connect(self.simulate_sfg)
self._ui.actionSimulateSFG.setIcon(get_icon('sim'))
# About menu
self._ui.faqBASIC.triggered.connect(self.display_faq_page)
self._ui.faqBASIC.setShortcut(QKeySequence("Ctrl+?"))
self._ui.faqBASIC.setIcon(get_icon('faq'))
self._ui.aboutBASIC.triggered.connect(self.display_about_page)
self._ui.aboutBASIC.setIcon(get_icon('about'))
self._ui.keybindsBASIC.triggered.connect(self.display_keybindings_page)
self._ui.keybindsBASIC.setIcon(get_icon('keys'))
self._ui.documentationBASIC.triggered.connect(self._open_documentation)
self._ui.documentationBASIC.setIcon(get_icon('docs'))
# Operation lists
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.custom_operations_list.itemClicked.connect(
self._on_list_widget_item_clicked
)
self._ui.save_menu.triggered.connect(self.save_work)
self._ui.save_menu.setIcon(get_icon('save'))
self._ui.save_menu.setShortcut(QKeySequence("Ctrl+S"))
self._ui.load_menu.triggered.connect(self.load_work)
self._ui.load_menu.setIcon(get_icon('open'))
self._ui.load_menu.setShortcut(QKeySequence("Ctrl+O"))
self._ui.load_operations.triggered.connect(self.add_namespace)
self._ui.load_operations.setIcon(get_icon('add-operations'))
self._ui.exit_menu.triggered.connect(self.exit_app)
self._ui.exit_menu.setIcon(get_icon('quit'))
self._ui.select_all.triggered.connect(self._select_all)
self._ui.select_all.setShortcut(QKeySequence("Ctrl+A"))
self._ui.select_all.setIcon(get_icon('all'))
self._ui.unselect_all.triggered.connect(self._unselect_all)
self._ui.unselect_all.setIcon(get_icon('none'))
self._shortcut_signal = QShortcut(QKeySequence(Qt.Key_Space), self)
self._shortcut_signal.activated.connect(self._connect_callback)
self._create_recent_file_actions_and_menus()
# View menu
# Operation names
self._show_names = True
self._check_show_names = QAction("&Operation names")
self._check_show_names.triggered.connect(self.view_operation_names)
self._check_show_names.setCheckable(True)
self._check_show_names.setChecked(True)
self._ui.view_menu.addAction(self._check_show_names)
self._ui.view_menu.addSeparator()
# Toggle toolbar
self._ui.view_menu.addAction(self._toolbar.toggleViewAction())
# Toggle status bar
self._statusbar_visible = QAction("&Status bar")
self._statusbar_visible.setCheckable(True)
self._statusbar_visible.setChecked(True)
self._statusbar_visible.triggered.connect(self._toggle_statusbar)
self._ui.view_menu.addAction(self._statusbar_visible)
# Zoom to fit
self._ui.view_menu.addSeparator()
self._zoom_to_fit_action = QAction(get_icon('zoom-to-fit'), "Zoom to &fit")
self._zoom_to_fit_action.triggered.connect(self._zoom_to_fit)
self._ui.view_menu.addAction(self._zoom_to_fit_action)
# Toggle full screen
self._fullscreen_action = QAction(
get_icon('full-screen'), "Toggle f&ull screen"
)
self._fullscreen_action.setCheckable(True)
self._fullscreen_action.triggered.connect(self._toggle_fullscreen)
self._fullscreen_action.setShortcut(QKeySequence("F11"))
self._ui.view_menu.addAction(self._fullscreen_action)
# Non-modal dialogs
self._keybindings_page = None
self._about_page = None
self._faq_page = None
self._logger.info("Finished setting up GUI")
self._logger.info(
"For questions please refer to 'Ctrl+?', or visit the 'Help' "
"section on the _toolbar."
)
self.cursor = QCursor()
def resizeEvent(self, event) -> None:
ui_width = self._ui.operation_box.width()
self._ui.operation_box.setGeometry(10, 10, ui_width, self.height())
self._graphics_view.setGeometry(
ui_width + 20,
60,
self.width() - ui_width - 20,
self.height() - 30,
)
super().resizeEvent(event)
def wheelEvent(self, event) -> None:
if event.modifiers() == Qt.KeyboardModifier.ControlModifier:
old_zoom = self._zoom
self._zoom += event.angleDelta().y() / 2500
self._graphics_view.scale(self._zoom, self._zoom)
self._zoom = old_zoom
def view_operation_names(self, event=None) -> None:
self._show_names = self._check_show_names.isChecked()
for operation in self._drag_operation_scenes:
operation.label.setOpacity(self._show_names)
operation.show_name = self._show_names
def _save_work(self) -> None:
if not self.sfg_widget.sfg:
self.update_statusbar("No SFG selected - saving cancelled")
sfg = cast(SFG, self.sfg_widget.sfg)
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix(".py")
module, accepted = file_dialog.getSaveFileName()
if not accepted:
return
self._logger.info("Saving SFG to path: " + str(module))
operation_positions = {}
for op_drag, op_scene in self._drag_operation_scenes.items():
operation_positions[op_drag.operation.graph_id] = (
int(op_scene.x()),
int(op_scene.y()),
op_drag.is_flipped(),
)
try:
with open(module, "w+") as file_obj:
file_obj.write(
sfg_to_python(sfg, suffix=f"positions = {operation_positions}")
)
except Exception as e:
self._logger.error(
f"Failed to save SFG to path: {module}, with error: {e}."
)
return
self._logger.info("Saved SFG to path: " + str(module))
self.update_statusbar("Saved SFG to path: " + str(module))
def save_work(self, event=None) -> None:
if not self._sfg_dict:
self.update_statusbar("No SFG to save")
return
self.sfg_widget = SelectSFGWindow(self)
self.sfg_widget.show()
# Wait for input to dialog.
self.sfg_widget.ok.connect(self._save_work)
def load_work(self, event=None) -> None:
module, accepted = QFileDialog().getOpenFileName()
if not accepted:
return
self._load_from_file(module)
def _load_from_file(self, module) -> None:
self._logger.info("Loading SFG from path: " + str(module))
try:
sfg, positions = python_to_sfg(module)
except ImportError as e:
self._logger.error(
f"Failed to load module: {module} with the following error: {e}."
)
return
self._add_recent_file(module)
while sfg.name in self._sfg_dict:
self._logger.warning(
f"Duplicate SFG with name: {sfg.name} detected. "
"Please choose a new name."
)
name, accepted = QInputDialog.getText(
self, "Change SFG Name", "Name: ", QLineEdit.Normal
)
if not accepted:
return
sfg.name = name
self._load_sfg(sfg, positions)
self._logger.info("Loaded SFG from path: " + str(module))
self.update_statusbar(f"Loaded SFG from {module}")
def _load_sfg(self, sfg: SFG, positions=None) -> None:
if positions is None:
positions = {}
for op in sfg.split():
self.add_operation(
op,
positions[op.graph_id][0:2] if op.graph_id in positions else None,
positions[op.graph_id][-1] if op.graph_id in positions else None,
)
def connect_ports(ports: Sequence[InputPort]):
for port in ports:
for signal in port.signals:
sources = [
source
for source in self._drag_buttons[
signal.source_operation
].port_list
if source.port is signal.source
]
destinations = [
destination
for destination in self._drag_buttons[
signal.destination.operation
].port_list
if destination.port is signal.destination
]
if sources and destinations:
self._connect_button(sources[0], destinations[0])
for pressed_port in self._pressed_ports:
pressed_port.select_port()
for op in sfg.split():
connect_ports(op.inputs)
for op in sfg.split():
self._drag_buttons[op].setToolTip(sfg.name)
self._operation_to_sfg[self._drag_buttons[op]] = sfg
self._sfg_dict[sfg.name] = sfg
self.update()
def _create_recent_file_actions_and_menus(self):
for i in range(self._max_recent_files):
recent_file_action = QAction(self._ui.recent_sfg)
recent_file_action.setVisible(False)
recent_file_action.triggered.connect(
lambda b=0, x=recent_file_action: self._open_recent_file(x)
)
self._recent_files_actions.append(recent_file_action)
self._ui.recent_sfg.addAction(recent_file_action)
self._update_recent_file_list()
def _toggle_fullscreen(self, event=None):
"""Callback for toggling full screen mode."""
if self.isFullScreen():
self.showNormal()
self._fullscreen_action.setIcon(get_icon('full-screen'))
else:
self.showFullScreen()
self._fullscreen_action.setIcon(get_icon('full-screen-exit'))
def _update_recent_file_list(self):
settings = QSettings()
rfp = cast(deque, settings.value("SFG/recentFiles"))
# print(rfp)
if rfp:
dequelen = len(rfp)
if dequelen > 0:
for i in range(dequelen):
action = self._recent_files_actions[i]
action.setText(rfp[i])
action.setData(QFileInfo(rfp[i]))
action.setVisible(True)
for i in range(dequelen, self._max_recent_files):
self._recent_files_actions[i].setVisible(False)
def _open_recent_file(self, action):
self._load_from_file(action.data().filePath())
def _add_recent_file(self, module):
settings = QSettings()
rfp = cast(deque, settings.value("SFG/recentFiles"))
if rfp:
if module not in rfp:
rfp.append(module)
else:
rfp = deque(maxlen=self._max_recent_files)
rfp.append(module)
settings.setValue("SFG/recentFiles", rfp)
self._update_recent_file_list()
def exit_app(self, event=None) -> None:
"""Exit the application."""
self._logger.info("Exiting the application.")
QApplication.quit()
def update_statusbar(self, msg: str) -> None:
"""
Write *msg* to the statusbar with temporarily policy.
Parameters
----------
msg : str
The message to write.
"""
self._statusbar.showMessage(msg)
def _clear_workspace(self) -> None:
self._logger.info("Clearing workspace from operations and SFGs.")
self._pressed_operations.clear()
self._pressed_ports.clear()
self._drag_buttons.clear()
self._drag_operation_scenes.clear()
self._arrow_ports.clear()
self._ports.clear()
self._sfg_dict.clear()
self._scene.clear()
self._logger.info("Workspace cleared.")
self.update_statusbar("Workspace cleared.")
def create_sfg_from_toolbar(self) -> None:
"""Callback to create an SFG."""
inputs = []
outputs = []
for pressed_op in self._pressed_operations:
if isinstance(pressed_op.operation, Input):
inputs.append(pressed_op.operation)
elif isinstance(pressed_op.operation, Output):
outputs.append(pressed_op.operation)
name, accepted = QInputDialog.getText(
self, "Create SFG", "Name: ", QLineEdit.Normal
)
if not accepted:
return
if not name:
self._logger.warning("Failed to initialize SFG with empty name.")
return
self._logger.info("Creating SFG with name: %s from selected operations." % name)
sfg = SFG(inputs=inputs, outputs=outputs, name=name)
self._logger.info("Created SFG with name: %s from selected operations." % name)
self.update_statusbar(f"Created SFG: {name}")
def check_equality(signal: Signal, signal_2: Signal) -> bool:
source_operation = cast(Operation, signal.source_operation)
source_operation2 = cast(Operation, signal_2.source_operation)
dest_operation = cast(Operation, signal.destination_operation)
dest_operation2 = cast(Operation, signal_2.destination_operation)
if not (
source_operation.type_name() == source_operation2.type_name()
and dest_operation.type_name() == dest_operation2.type_name()
):
return False
if (
hasattr(source_operation, "value")
and hasattr(source_operation2, "value")
and hasattr(dest_operation, "value")
and hasattr(dest_operation2, "value")
):
if not (
source_operation.value == source_operation2.value
and dest_operation.value == dest_operation2.value
):
return False
if (
hasattr(source_operation, "name")
and hasattr(source_operation2, "name")
and hasattr(dest_operation, "name")
and hasattr(dest_operation2, "name")
):
if not (
source_operation.name == source_operation2.name
and dest_operation.name == dest_operation2.name
):
return False
try:
signal_source_index = [
source_operation.outputs.index(port)
for port in source_operation.outputs
if signal in port.signals
]
signal_2_source_index = [
source_operation2.outputs.index(port)
for port in source_operation2.outputs
if signal_2 in port.signals
]
except ValueError:
return False # Signal output connections not matching
try:
signal_destination_index = [
dest_operation.inputs.index(port)
for port in dest_operation.inputs
if signal in port.signals
]
signal_2_destination_index = [
dest_operation2.inputs.index(port)
for port in dest_operation2.inputs
if signal_2 in port.signals
]
except ValueError:
return False # Signal input connections not matching
return (
signal_source_index == signal_2_source_index
and signal_destination_index == signal_2_destination_index
)
for _pressed_op in self._pressed_operations:
for operation in sfg.operations:
for input_ in operation.inputs:
for signal in input_.signals:
for arrow in self._arrow_ports:
if check_equality(arrow.signal, signal):
arrow.set_source_operation(signal.source_operation)
arrow.set_destination_operation(
signal.destination_operation
)
for output_ in operation.outputs:
for signal in output_.signals:
for arrow in self._arrow_ports:
if check_equality(arrow.signal, signal):
arrow.set_source_operation(signal.source_operation)
arrow.set_destination_operation(
signal.destination_operation
)
for pressed_op in self._pressed_operations:
pressed_op.setToolTip(sfg.name)
self._operation_to_sfg[pressed_op] = sfg
self._sfg_dict[sfg.name] = sfg
def _show_precedence_graph(self, event=None) -> None:
"""Callback for showing precedence graph."""
if not self._sfg_dict:
self.update_statusbar("No SFG to show")
return
self._precedence_graph_dialog = PrecedenceGraphWindow(self)
self._precedence_graph_dialog.add_sfg_to_dialog()
self._precedence_graph_dialog.show()
def _toggle_statusbar(self, event=None) -> None:
"""Callback for toggling the status bar."""
self._statusbar.setVisible(self._statusbar_visible.isChecked())
def get_operations_from_namespace(self, namespace: ModuleType) -> List[str]:
"""
Return a list of all operations defined in a namespace (module).
Parameters
----------
namespace : module
A loaded Python module containing operations.
Returns
-------
list
A list of names of all the operations in the module.
"""
self._logger.info(
"Fetching operations from namespace: " + str(namespace.__name__)
)
return [
comp
for comp in dir(namespace)
if hasattr(getattr(namespace, comp), "type_name")
]
def add_operations_from_namespace(
self, namespace: ModuleType, list_widget: QListWidget
) -> None:
"""
Add operations from namespace (module) to a list widget.
Parameters
----------
namespace : module
A loaded Python module containing operations.
list_widget : QListWidget
The widget to add operations to.
"""
for attr_name in self.get_operations_from_namespace(namespace):
attr = getattr(namespace, attr_name)
try:
attr.type_name()
item = QListWidgetItem(attr_name)
list_widget.addItem(item)
self._operations_from_name[attr_name] = attr
except NotImplementedError:
pass
self._logger.info("Added operations from namespace: " + str(namespace.__name__))
def add_namespace(self, event=None) -> None:
"""Callback for adding namespace."""
module, accepted = QFileDialog().getOpenFileName()
if not accepted:
return
self._add_namespace(module)
def _add_namespace(self, module: str):
spec = importlib.util.spec_from_file_location(
f"{QFileInfo(module).fileName()}", module
)
namespace = importlib.util.module_from_spec(spec)
spec.loader.exec_module(namespace)
self.add_operations_from_namespace(namespace, self._ui.custom_operations_list)
def _update(self):
self._scene.update()
self._graphics_view.update()
def add_operation(
self,
op: Operation,
position: Optional[Tuple[float, float]] = None,
is_flipped: bool = False,
) -> None:
"""
Add operation to GUI.
Parameters
----------
op : Operation
The operation to add.
position : (float, float), optional
(x, y)-position for operation.
is_flipped : bool, default: False
Whether the operation is flipped.
"""
try:
if op in self._drag_buttons:
self._logger.warning("Multiple instances of operation with same name")
return
attr_button = DragButton(op, True, window=self)
if position is None:
attr_button.move(GRID * 3, GRID * 2)
else:
attr_button.move(*position)
max_ports = max(op.input_count, op.output_count)
button_height = max(
MINBUTTONSIZE, max_ports * PORTHEIGHT + (max_ports - 1) * GAP
)
attr_button.setFixedSize(MINBUTTONSIZE, button_height)
attr_button.setStyleSheet(
"background-color: white; border-style: solid;"
"border-color: black; border-width: 2px"
)
attr_button.add_ports()
self._ports[attr_button] = attr_button.port_list
icon_path = os.path.join(
os.path.dirname(__file__),
"operation_icons",
f"{op.type_name().lower()}.png",
)
if not os.path.exists(icon_path):
icon_path = os.path.join(
os.path.dirname(__file__),
"operation_icons",
"custom_operation.png",
)
attr_button.setIcon(QIcon(icon_path))
attr_button.setIconSize(QSize(MINBUTTONSIZE, MINBUTTONSIZE))
attr_button.setToolTip("No SFG")
attr_button.setStyleSheet(
"QToolTip { background-color: white; color: black }"
)
attr_button.setParent(None)
attr_button_scene = self._scene.addWidget(attr_button)
if position is None:
attr_button_scene.moveBy(
int(self._scene.width() / 4), int(self._scene.height() / 4)
)
attr_button_scene.setFlag(QGraphicsItem.ItemIsSelectable, True)
operation_label = QGraphicsTextItem(op.name, attr_button_scene)
if not self._show_names:
operation_label.setOpacity(0)
operation_label.setTransformOriginPoint(
operation_label.boundingRect().center()
)
operation_label.moveBy(10, -20)
attr_button.add_label(operation_label)
if isinstance(is_flipped, bool):
if is_flipped:
attr_button._flip()
self._drag_buttons[op] = attr_button
self._drag_operation_scenes[attr_button] = attr_button_scene
except Exception as e:
self._logger.error(
"Unexpected error occurred while creating operation: " + str(e)
)
def _create_operation_item(self, item) -> None:
self._logger.info("Creating operation of type: %s" % str(item.text()))
try:
attr_operation = self._operations_from_name[item.text()]()
self.add_operation(attr_operation)
self.update_statusbar(f"{item.text()} added.")
except Exception as e:
self._logger.error(
"Unexpected error occurred while creating operation: " + str(e)
)
def _refresh_operations_list_from_namespace(self) -> None:
self._logger.info("Refreshing operation list.")
self._ui.core_operations_list.clear()
self._ui.special_operations_list.clear()
self.add_operations_from_namespace(
b_asic.core_operations, self._ui.core_operations_list
)
self.add_operations_from_namespace(
b_asic.special_operations, self._ui.special_operations_list
)
self._logger.info("Finished refreshing operation list.")
def _on_list_widget_item_clicked(self, item) -> None:
self._create_operation_item(item)
def keyPressEvent(self, event) -> None:
if event.key() == Qt.Key.Key_Delete:
for pressed_op in self._pressed_operations:
pressed_op.remove()
self.move_button_index -= 1
self._pressed_operations.clear()
super().keyPressEvent(event)
def _connect_callback(self, *event) -> None:
"""Callback for connecting operation buttons."""
if len(self._pressed_ports) < 2:
self._logger.warning(
"Cannot connect less than two ports. Please select at least two."
)
return
pressed_op_inports = [
pressed
for pressed in self._pressed_ports
if isinstance(pressed.port, InputPort)
]
pressed_op_outports = [
pressed
for pressed in self._pressed_ports
if isinstance(pressed.port, OutputPort)
]
if len(pressed_op_outports) != 1:
raise ValueError("Exactly one output port must be selected!")
pressed_op_outport = pressed_op_outports[0]
for pressed_op_input_port in pressed_op_inports:
self._connect_button(pressed_op_outport, pressed_op_input_port)
for port in self._pressed_ports:
port.select_port()
def _connect_button(self, source: PortButton, destination: PortButton) -> None:
"""
Connect two PortButtons with an Arrow.
Parameters
----------
source : PortButton
The PortButton to start the signal at.
destination : PortButton
The PortButton to end the signal at.
Returns
-------
None.
"""
signal_exists = (
signal
for signal in source.port.signals
if signal.destination is destination.port
)
self._logger.info(
"Connecting: %s -> %s."
% (
source.operation.type_name(),
destination.operation.type_name(),
)
)
try:
arrow = Arrow(source, destination, self, signal=next(signal_exists))
except StopIteration:
arrow = Arrow(source, destination, self)
if arrow not in self._arrow_ports:
self._arrow_ports[arrow] = []
self._arrow_ports[arrow].append((source, destination))
self._scene.addItem(arrow)
self.update()
def paintEvent(self, event) -> None:
for arrow in self._arrow_ports:
arrow.update_arrow()
def _select_operations(self) -> None:
"""Select an operation button."""
selected = [button.widget() for button in self._scene.selectedItems()]
for button in selected:
button._toggle_button(pressed=False)
for button in self._pressed_operations:
if button not in selected:
button._toggle_button(pressed=True)
self._pressed_operations = selected
def _select_all(self, event=None) -> None:
"""Callback for selecting all operation buttons."""
if not self._drag_buttons:
self.update_statusbar("No operations to select")
return
for operation in self._drag_buttons.values():
operation._toggle_button(pressed=False)
self.update_statusbar("Selected all operations")
def _unselect_all(self, event=None) -> None:
"""Callback for unselecting all operation buttons."""
if not self._drag_buttons:
self.update_statusbar("No operations to unselect")
return
for operation in self._drag_buttons.values():
operation._toggle_button(pressed=True)
self.update_statusbar("Unselected all operations")
def _zoom_to_fit(self, event=None):
"""Callback for zoom to fit SFGs in window."""
self._graphics_view.fitInView(
self._scene.sceneRect(), Qt.AspectRatioMode.KeepAspectRatio
)
def _simulate_sfg(self) -> None:
"""Callback for simulating SFGs in separate threads."""
self._thread = dict()
self._sim_worker = dict()
for sfg, properties in self._simulation_dialog._properties.items():
self._logger.info("Simulating SFG with name: %s" % str(sfg.name))
self._sim_worker[sfg] = SimulationWorker(sfg, properties)
self._thread[sfg] = QThread()
self._sim_worker[sfg].moveToThread(self._thread[sfg])
self._thread[sfg].started.connect(self._sim_worker[sfg].start_simulation)
self._sim_worker[sfg].finished.connect(self._thread[sfg].quit)
self._sim_worker[sfg].finished.connect(self._show_plot_window)
self._sim_worker[sfg].finished.connect(self._sim_worker[sfg].deleteLater)
self._thread[sfg].finished.connect(self._thread[sfg].deleteLater)
self._thread[sfg].start()
def _show_plot_window(self, sim: Simulation):
"""Callback for displaying simulation results window."""
self._plot[sim] = PlotWindow(sim.results, sfg_name=sim.sfg.name)
self._plot[sim].show()
def simulate_sfg(self, event=None) -> None:
"""Callback for showing simulation dialog."""
if not self._sfg_dict:
self.update_statusbar("No SFG to simulate")
return
self._simulation_dialog = SimulateSFGWindow(self)
for _, sfg in self._sfg_dict.items():
self._simulation_dialog.add_sfg_to_dialog(sfg)
self._simulation_dialog.show()
# Wait for input to dialog.
# Kinda buggy because of the separate window in the same thread.
self._simulation_dialog.simulate.connect(self._simulate_sfg)
@Slot()
def _open_documentation(self, event=None) -> None:
"""Callback to open documentation web page."""
webbrowser.open_new_tab("https://da.gitlab-pages.liu.se/B-ASIC/")
def display_faq_page(self, event=None) -> None:
"""Callback for displaying FAQ dialog."""
if self._faq_page is None:
self._faq_page = FaqWindow(self)
self._faq_page._scroll_area.show()
def display_about_page(self, event=None) -> None:
"""Callback for displaying about dialog."""
if self._about_page is None:
self._about_page = AboutWindow(self)
self._about_page.show()
def display_keybindings_page(self, event=None) -> None:
"""Callback for displaying keybindings dialog."""
if self._keybindings_page is None:
self._keybindings_page = KeybindingsWindow(self)
self._keybindings_page.show()
def start_editor(sfg: Optional[SFG] = None) -> Dict[str, SFG]:
"""
Start the SFG editor.
Parameters
----------
sfg : SFG, optional
The SFG to start the editor with.
Returns
-------
dict
All SFGs currently in the editor.
"""
if not QApplication.instance():
app = QApplication(sys.argv)
else:
app = QApplication.instance()
window = SFGMainWindow()
if sfg:
window._load_sfg(sfg)
window.show()
app.exec_()
return window._sfg_dict
if __name__ == "__main__":
start_editor()