aswi2021vochomurka-gitlab/aswi2021vochomurka/view/main_view.py @ e402bc71

import logging

import matplotlib.pyplot as plt
from PyQt5 import QtCore
from PyQt5 import QtGui
from PyQt5.QtCore import QSize, QThread, QObject, pyqtSignal, QSettings
from PyQt5.QtWidgets import QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QScrollArea, QGridLayout
from PyQt5.QtWidgets import QMenuBar, QAction, QPushButton
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas

from aswi2021vochomurka.model.Message import Message
from aswi2021vochomurka.service.mqtt.mqtt_subscriber import MQTTSubscriber
from aswi2021vochomurka.service.subscriber import Subscriber
from aswi2021vochomurka.service.subscriber_callback import SubscriberCallback
from aswi2021vochomurka.service.subscriber_params import SubscriberParams, ConnectionParams
from aswi2021vochomurka.view.logger_view import LoggerView
from aswi2021vochomurka.view.settings import SettingsDialog, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_KEEPALIVE, \
    DEFAULT_ANONYMOUS, DEFAULT_USERNAME, DEFAULT_TIMEOUT, DEFAULT_TOPICS, get_settings


class Worker(QObject, SubscriberCallback):
    """
    Worker representing thread
    """
    connected = pyqtSignal()
    disconnected = pyqtSignal()
    error = pyqtSignal(Exception)
    newMessage = pyqtSignal(Message)
    closeTopic = pyqtSignal(str)
    subscriber: Subscriber = None
    params: SubscriberParams

    def __init__(self, params: SubscriberParams) -> None:
        """
        Constructor
        """
        super().__init__()
        self.params = params

    def start(self):
        """
        Start worker
        """
        self.subscriber = MQTTSubscriber(self, self.params)
        self.subscriber.start()

    def stop(self):
        """
        Stop worker
        """
        self.subscriber.stop()

    def onConnected(self):
        """
        Emit connection signal
        """
        self.connected.emit()

    def onDisconnected(self):
        """
        Emit disconnection signal
        """
        self.disconnected.emit()

    def onError(self):
        pass

    def onMessage(self, message: Message):
        """
        Emit message signal
        :param message: message
        """
        self.newMessage.emit(message)

    def onCloseTopic(self, topic: str):
        """
        Emit close topic signal
        :param topic: topic
        """
        print("Close topic")
        self.closeTopic.emit(topic)


class MainView(QMainWindow):
    """
    Main window of application.
    Displays all parts of the application.
    """
    worker: Worker = None
    workerThread: QThread = None

    def __init__(self):
        """
        Constructor - displays all parts of the application.
        """
        super(MainView, self).__init__()

        self.chartsNum = 0
        self.dataDict = {}
        self.canvasDict = {}
        self.figureDict = {}
        self.widgetDict = {}
        self.widgetList = []

        self.setMinimumSize(QSize(1200, 800))
        self.setWindowTitle("MQTT client")

        logger = self._createLoggerView()
        layout = QVBoxLayout()
        layout.addWidget(logger.widget)

        widget = QWidget()
        widget.setLayout(layout)
        self.setCentralWidget(widget)
        self._createMenuBar()

        scrollArea = QScrollArea(self)
        scrollArea.setWidgetResizable(True)
        scrollContent = QWidget()
        self.grid = QGridLayout(scrollContent)
        scrollArea.setWidget(scrollContent)
        layout.addWidget(scrollArea)

        self.init_subscriber()

    def _createLoggerView(self):
        """
        Create logger view
        """
        logger = LoggerView(self)
        formatter = logging.Formatter('%(asctime)s %(message)s', '%H:%M')
        logger.setFormatter(formatter)
        logger.setLevel(logging.INFO)
        logging.getLogger('').addHandler(logger)
        return logger

    def _createMenuBar(self):
        """
        Creates menu bar
        """
        menuBar = QMenuBar(self)
        settingsAction = QAction("&Settings", self)
        settingsAction.triggered.connect(self.settings)
        menuBar.addAction(settingsAction)
        self.setMenuBar(menuBar)

    def plot(self, message: Message):
        """
        Plots new charts or updates old ones
        :param message: message
        """
        if message.topic in self.dataDict:
            # topic already exists
            self.dataDict[message.topic].append(message.value)

            figure = self.figureDict[message.topic]
            figure.clear()

            figure = plt.figure(figure.number)
            figure.suptitle(message.topic)
            plt.plot(self.dataDict[message.topic])

            self.canvasDict[message.topic].draw()
        else:
            # new topic
            self.dataDict[message.topic] = [message.value]

            figure = plt.figure(figsize=[500, 500])
            canvas = FigureCanvas(figure)
            self.layout = QHBoxLayout()

            plt.plot(self.dataDict[message.topic])
            figure.suptitle(message.topic)

            self.canvasDict[message.topic] = canvas
            self.figureDict[message.topic] = figure

            widget = QWidget()
            self.widgetDict[message.topic] = widget
            self.widgetList.append(widget)
            widget.setLayout(self.layout)
            button = QPushButton(':')
            button.setFixedSize(QSize(40, 40))
            self.layout.addWidget(canvas)
            self.layout.addWidget(button)
            self.layout.setAlignment(button, QtCore.Qt.AlignTop)
            widget.setMinimumSize(QSize(500, 500))

            self.grid.addWidget(widget, int(self.chartsNum / 2), self.chartsNum % 2)

            self.chartsNum += 1

    def deletePlot(self, topic: str):
        """
        Deletes plot
        :param topic: topic
        """
        widget = self.widgetDict[topic]
        self.widgetList.remove(widget)
        widget.setParent(None)

        del self.widgetDict[topic]
        del self.canvasDict[topic]
        del self.figureDict[topic]
        del self.dataDict[topic]

        self.reorganizePlots()

    def reorganizePlots(self):
        """
        Reorganize plots
        """
        count = 0
        for widget in self.widgetList:
            self.grid.addWidget(widget, int(count / 2), count % 2)
            count += 1

        self.chartsNum -= 1

    def closeEvent(self, a0: QtGui.QCloseEvent) -> None:
        self.worker.stop()

    def settings(self):
        """
        Opens settings dialog
        """
        dialog = SettingsDialog()
        if dialog.exec_():
            self.reconnect()

    def disconnect(self):
        """
        Disconnect
        """
        self.worker.stop()
        self.workerThread.quit()
        self.workerThread.wait()

    def reconnect(self):
        """
        Reconnect
        """
        self.disconnect()
        self.worker.params = self.getConfigParams()
        self.workerThread.start()

    def init_subscriber(self):
        """
        Initialization of subscriber
        """
        self.workerThread = QThread()
        self.worker = Worker(self.getConfigParams())
        self.worker.moveToThread(self.workerThread)
        self.workerThread.started.connect(self.worker.start)
        self.worker.newMessage.connect(
            lambda message: self.plot(message)
        )
        self.worker.closeTopic.connect(
            lambda topic: self.deletePlot(topic)
        )
        self.worker.window = self
        self.workerThread.start()

    def getConfigParams(self) -> SubscriberParams:
        """
        Returns config parameters
        :return: config parameters
        """
        settings = get_settings()

        connection = ConnectionParams(
            settings.value("connection_host", DEFAULT_HOST, str),
            settings.value("connection_port", DEFAULT_PORT, int),
            settings.value("connection_keepalive", DEFAULT_KEEPALIVE, int)
        )

        params = SubscriberParams(
            settings.value("topics_items", DEFAULT_TOPICS),
            settings.value("topics_timeout", DEFAULT_TIMEOUT, int),
            connection,
            settings.value("connection_anonymous", DEFAULT_ANONYMOUS, bool),
            settings.value("connection_username", DEFAULT_USERNAME, str),
            settings.value("connection_password", DEFAULT_USERNAME, str),
        )

        return params