aswi2021vochomurka-gitlab/aswi2021vochomurka/view/main_view.py @ 7d3e8585

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):
    connected = pyqtSignal()
    disconnected = pyqtSignal()
    error = pyqtSignal(Exception)
    newMessage = pyqtSignal(Message)
    subscriber: Subscriber = None
    params: SubscriberParams

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

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

    def stop(self):
        self.subscriber.stop()

    def onConnected(self):
        self.connected.emit()

    def onDisconnected(self):
        self.disconnected.emit()

    def onError(self):
        pass

    def onMessage(self, message: Message):
        self.newMessage.emit(message)
        # self.window.plot(message)

    def onCloseTopic(self, topic: str):
        pass


class MainView(QMainWindow):
    worker: Worker = None
    workerThread: QThread = None

    def __init__(self):
        super(MainView, self).__init__()

        self.chartsNum = 0
        self.arrayData = []

        self.dataIndex = 0
        self.dataDict = {}

        self.canvasDict = {}
        self.figureDict = {}

        # self.toolbar = NavigationToolbar(self.canvas, self)

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

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

        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):
        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):
        menuBar = QMenuBar(self)
        settingsAction = QAction("&Settings", self)
        settingsAction.triggered.connect(self.settings)
        menuBar.addAction(settingsAction)
        self.setMenuBar(menuBar)

    def plot(self, message: Message):
        if message.topic in self.dataDict:
            self.dataDict[message.topic].append(message.value)

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

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

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

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

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

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

            widget = QWidget()
            widget.setLayout(layout)
            button = QPushButton(':')
            button.setFixedSize(QSize(40, 40))
            layout.addWidget(canvas)
            layout.addWidget(button)
            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 closeEvent(self, a0: QtGui.QCloseEvent) -> None:
        self.worker.stop()

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

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

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

    def init_subscriber(self):
        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.window = self
        self.workerThread.start()

    def getConfigParams(self) -> SubscriberParams:
        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