KaptureControlGui/KCG/base/controlwidget.py

"""
This module defines the Initial view of the gui
"""

from PyQt4 import QtGui, QtCore
import logging

import kcgwidget as kcgw
from kcgwidget import error
from backend import board
from backend.board import available_boards
from groupedelements import Checkboxes, Buttons, Elements
import backendinterface as bif
from loghandler import LogArea
import storage
from .. import config

tr = kcgw.tr


class LED(QtGui.QWidget):
    """
    Produces a graphical LED
    """
    def __init__(self, parent=None, status=1, height=10, width=10):
        """
        Initialize a LED
        :param parent: (QWidget) parent of this widget
        :param status: (int) (0=out, 1=off, 2=orange, 3=on) initial status of this LED
        :param height: (int) height of the LED
        :param width: (int) width of the LED
        :return: -
        """
        QtGui.QWidget.__init__(self, parent)
        colorRGB=(255, 0, 0)
        self.width = width
        self.height = height
        self.color = QtGui.QColor(colorRGB[0], colorRGB[1], colorRGB[2])
        self.center = QtCore.QPoint(width, height)
        self.setMinimumSize(2 * width, 2 * height)
        self.setMaximumSize(2 * width, 2 * height)
        if status == 3:
            self.set_on()
        elif status == 1:
            self.set_off()
        elif status == 0:
            self.set_out()
        elif status == 2:
            self.set_tri()
        self.status = status

    def paintEvent(self, event):
        paint = QtGui.QPainter()
        paint.begin(self)
        paint.setRenderHint(QtGui.QPainter.Antialiasing)

        # draw a grey 'socket' for the LED
        paint.setPen(QtGui.QColor(160, 160, 160))
        paint.setBrush(QtGui.QColor(180, 180, 180))
        paint.drawEllipse(self.center, self.width, self.height)

        # draw the body of the LED
        paint.setBrush(self.color)
        paint.drawEllipse(self.center, self.width*0.85, self.height*0.85)

    def set_on(self):
        """
        Set the LED to "on" state
        :return: -
        """
        self.color = QtGui.QColor(0, 255, 0)
        self.update()
        self.status = 3

    def set_off(self):
        """
        Set the LED to "off" state
        :return: -
        """
        self.color = QtGui.QColor(255, 0, 0)
        self.update()
        self.status = 1

    def set_out(self):
        """
        Set the LED to "OUT" state (that is like an LED without power)
        :return: -
        """
        self.color = QtGui.QColor(150, 150, 150)
        self.update()
        self.status = 0

    def set_tri(self):
        """
        Set the LED to "TRI" state (that is led is orange)
        :return: -
        """
        self.color = QtGui.QColor(255, 255, 0)
        self.update()
        self.status = 2

    def set_status(self, status):
        """
        Set the status of the led
        :param status: status (in 0, 1, 2, 3)
        """
        if status == 0:
            self.set_out()
        elif status == 1:
            self.set_off()
        elif status == 2:
            self.set_tri()
        elif status == 3:
            self.set_on()


class StatusLED(QtGui.QWidget):
    """
    Create a Status LED with Label next to it
    """
    def __init__(self, text, status=None):
        """
        Initialise StatusLED
        :param text: label text next to the LED
        :param status: initial status of the LED
        :return: -
        """
        super(StatusLED, self).__init__()
        self.layout = QtGui.QHBoxLayout()
        self.label = QtGui.QLabel(text)
        self.led = LED(status=status, width=9, height=9)
        self.layout.addWidget(self.led)
        self.layout.addWidget(self.label)
        self.setLayout(self.layout)

    def set_on(self):
        """ See set_on of LED Class """
        self.led.set_on()

    def set_off(self):
        """ See set_off of LED Class """
        self.led.set_off()

    def set_out(self):
        """ See set_out of LED Class """
        self.led.set_out()

    def set_tri(self):
        """ See set_tri of LED Class """
        self.led.set_tri()

    def set_status(self, status):
        """
        See set_status of LED Class
        :param status: the status to set the led to
        """
        self.led.set_status(status)


class BoardControl(kcgw.KCGWidgets):
    def __init__(self, board_id, single=False):
        super(BoardControl, self).__init__()
        self.board_id = board_id
        self.layout = QtGui.QVBoxLayout()
        self.setLayout(self.layout)

        if not single:
            self.header_layout = QtGui.QHBoxLayout()
            left_line = QtGui.QFrame()
            left_line.setFrameShape(QtGui.QFrame.HLine)
            left_line.setFrameShadow(QtGui.QFrame.Sunken)
            right_line = QtGui.QFrame()
            right_line.setFrameShape(QtGui.QFrame.HLine)
            right_line.setFrameShadow(QtGui.QFrame.Sunken)
            self.header_layout.addWidget(left_line)
            header_label = self.createLabel("Board: {}".format(available_boards.get_board_name_from_id(board_id)))
            header_label.setFixedWidth(header_label.sizeHint().width())
            self.header_layout.addWidget(header_label)
            self.header_layout.addWidget(right_line)

            self.layout.addLayout(self.header_layout)

        self.mainControlLayout = QtGui.QHBoxLayout()
        self.subControlLayout = QtGui.QHBoxLayout()
        self.subControlWidget = QtGui.QWidget()
        self.subControlWidget.setLayout(self.subControlLayout)
        self.statusLayout = QtGui.QHBoxLayout()
        self.layout.addLayout(self.mainControlLayout)
        self.layout.addWidget(self.subControlWidget)
        self.layout.addLayout(self.statusLayout)

        # ----------[ LED Status ]---------------
        self.pipeline_led = StatusLED(tr("Label", "DataFlow Pipeline"))
        self.master_control_led = StatusLED(tr("Label", "Master Control"))
        self.data_check_led = StatusLED(tr("Label", "Data Check"))
        self.pll_ld_led = StatusLED(tr("Label", "PLL_LD"))
        self.statusLayout.addWidget(self.pipeline_led)
        self.statusLayout.addWidget(self.master_control_led)
        self.statusLayout.addWidget(self.data_check_led)
        self.statusLayout.addWidget(self.pll_ld_led)

        # -----------[ Buttons ]--------------
        self.all_in_one_button = self.createButton(text=tr("Button", "Prepare Board"), connect=self.all_in_one,
                                                   tooltip=tr("Tooltip", "Start, Calibrate, Synchronize and set Defaults\nCtrl+A"))
        self.toggleButton = self.createButton(text="", connect=self.toggle_sub_control)
        self.toggleButton.setIcon(QtGui.QIcon(config.install_path+"icons/chevron-bottom.svg"))
        self.toggleButton.setFixedWidth(50)
        # self.all_in_one_button.setShortcut("Ctrl+A")
        # self.all_in_one_button.setObjectName("all_in_one")

        self.skip_init_button = self.createButton(text=tr("Button", "Skip Initialisation"), connect=self.skip_init,
                                                  tooltip=tr("Tooltip", "Skip Initialisation and read values from board.\n"
                                                                        "NOTE: ONLY DO THIS IF BOARD WAS CALIBRATED AND SYNCHRONIZED BEFORE"))

        self.start_button = self.createButton(text=tr("Button", "Start Board"), connect=lambda x: bif.bk_start_board(board_id=board_id))
        self.calibrate_button = self.createButton(text=tr("Button", "Calibrate"), connect=lambda x: bif.bk_calibrate(board_id=board_id))
        self.syncronize_button = self.createButton(text=tr("Button", "Synchronize"), connect=lambda x: bif.bk_sync_board(board_id=board_id))
        self.set_default_button = self.createButton(text=tr("Button", "Set Defaults"), connect=lambda x: bif.bk_write_values(board_id=board_id, defaults=True))
        self.soft_reset_button = self.createButton(text=tr("Button", "Soft Reset"), connect=lambda x: bif.bk_soft_reset(board_id=board_id))
        self.off_button = self.createButton(text=tr("Button", "Board Off"), connect=lambda x: bif.bk_stop_board(board_id=board_id))
        self.off_button.setObjectName("off")
        self.check_status_button = self.createButton(text=tr("Button", "Check Status"), connect=lambda x: bif._bif_status_readout(board_id=board_id))

        Buttons.addButton('start_board_{}'.format(board_id), self.start_button)
        Buttons.addButton(['calibrate_{}'.format(board_id), 'after_start_{}'.format(board_id)], self.calibrate_button)
        Buttons.addButton(['synchronize_{}'.format(board_id), 'after_start_{}'.format(board_id)], self.syncronize_button)
        Buttons.addButton(['set_defaults_{}'.format(board_id), 'after_start_{}'.format(board_id)], self.set_default_button)
        Elements.addItem('no_board_{}'.format(board_id),
                         [
                             self.start_button,
                             self.calibrate_button,
                             self.syncronize_button,
                             self.set_default_button,
                             self.soft_reset_button,
                             self.off_button,
                             self.all_in_one_button
                         ])

        self.mainControlLayout.addWidget(self.skip_init_button)
        self.mainControlLayout.addWidget(self.all_in_one_button)
        self.mainControlLayout.addWidget(self.toggleButton)
        self.mainControlLayout.addWidget(self.soft_reset_button)
        self.mainControlLayout.addWidget(self.off_button)

        self.statusLayout.addWidget(self.check_status_button)

        self.subControlLayout.addWidget(self.start_button)
        self.subControlLayout.addWidget(self.calibrate_button)
        self.subControlLayout.addWidget(self.syncronize_button)
        self.subControlLayout.addWidget(self.set_default_button)

        # register the led updater function (used in backendinterface.bk_status_readout)
        storage.get_board_specific_storage(board_id).update_LED = self.on_check
        self.geo = self.saveGeometry()
        self.subControlWidget.hide()

    def toggle_sub_control(self):
        self.subControlWidget.setHidden(not self.subControlWidget.isHidden())
        if self.subControlWidget.isHidden():
            self.toggleButton.setIcon(QtGui.QIcon(config.install_path+"icons/chevron-bottom.svg"))
        else:
            self.toggleButton.setIcon(QtGui.QIcon(config.install_path+"icons/chevron-top.svg"))
        self.parent().adjustSize()

    def all_in_one(self):
        """
        Function that gets called when the Prepare Board Button is pressed.
        It Starts the board, syncs it and sets defaults.
        This is accomplished via the backendinterface module
        :return: -
        """
        if bif.bk_start_board(self.board_id) is not False:

            def do_the_rest(board_id):
                bif.bk_sync_board(board_id)
                bif.bk_write_values(board_id, defaults=True)
            bif.bk_calibrate(self.board_id, do_the_rest)

    def skip_init(self):
        board.get_board_config(self.board_id).read_from_board()
        board.get_board_status(self.board_id).calibrated = True
        board.get_board_status(self.board_id).synced = True
        board.get_board_status(self.board_id).defaults_set = True
        bif.bk_status_readout()

    def on_check(self):
        """
        This function is the handler for the status leds on the ControlWidget View.
        Parses the registers and sets the colors of the leds according.
        :return: -
        """
        try:
            status = bif.bk_get_status(self.board_id)
        except IndexError:
            error(0x002, "Pci returned not enough registers to update LEDs.")
            return

        for led, st in status.items():
            getattr(self, led.lower()+"_led").set_status(st)


class ControlWidget(kcgw.KCGWidgets):
    """
    Main Widget that is shown at start of gui.
    """
    def __init__(self):
        super(ControlWidget, self).__init__()

        self.overlayout = QtGui.QVBoxLayout()
        self.setLayout(self.overlayout)

        self.splitter = QtGui.QSplitter(QtCore.Qt.Vertical)
        self.overlayout.addWidget(self.splitter)


        self.board_control_list = {i: BoardControl(i, not available_boards.multi_board) for i in available_boards}
        self.board_widget = QtGui.QWidget()
        self.board_widget_layout = QtGui.QVBoxLayout()
        self.board_widget.setLayout(self.board_widget_layout)
        for bc in self.board_control_list.values():
            self.board_widget_layout.addWidget(bc)
        self.board_widget_layout.addStretch(1)

        if available_boards.multi_board:
            self.scroll_widget = QtGui.QScrollArea()
            # self.scroll_widget.setMaximumWidth(1.1 * self.board_control_list.values()[0].minimumSizeHint().width())
            self.scroll_widget.setWidgetResizable(True)
            self.scroll_widget.setWidget(self.board_widget)
            self.scroll_widget_container = QtGui.QWidget()
            self.scroll_widget_layout = QtGui.QHBoxLayout()
            self.scroll_widget_layout.addWidget(self.scroll_widget)
            self.scroll_widget_layout.setAlignment(QtCore.Qt.AlignLeft)
            self.scroll_widget_container.setLayout(self.scroll_widget_layout)
            self.splitter.addWidget(self.scroll_widget_container)
        else:
            self.splitter.addWidget(self.board_widget)

        # self.log_area = QtGui.QTextEdit()
        self.log_area = LogArea()
        self.log_area.setReadOnly(True)
        self.splitter.addWidget(self.log_area)
        self.log_area.init_logging()
        self.log_area.setKeywords([
            "Activating Board",
            "Started Board Calibration",
            "Synchronize PLLs",
            "Setting default Values",
            "Updating Values"
        ])

        # self.setTabOrder(self.soft_reset_button, self.check_status_button)
        # self.setTabOrder(self.check_status_button, self.off_button)

        # ------------------[ Logging ]----------------------
        # log_handler = LogHandler(self.log_area)
        # self.logger = logging.getLogger()
        # self.logger.addHandler(log_handler)
        # self.logger.setLevel(config.log_level)
        # logging.logger = self.logger
        # logging.logger.addHandler(log_handler)