KaptureControlGui/KCG/widgets/SingleReadWidget.py

# -*- coding: utf-8 -*-
"""
This Module is the SingleRead window.
"""
from PyQt4 import QtGui

from ..base import kcgwidget as kcgw
from ..base import backendinterface as bif
from ..base.groupedelements import Elements
from ..base.backend import board
from ..base.backend.board import  available_boards
from ..base.storage import storage
from ..base.globals import glob as global_objects
from .. import config
import time


tr = kcgw.tr

__widget_id__ = None


class SingleReadWidget(kcgw.KCGWidgets):
    """
    The actual single read window.
    """
    def __init__(self, unique_id, parent=None):
        """
        Initialise the single read widget
        :param unique_id: the id for this widget
        :param parent: parent object
        :return: -
        """
        super(SingleReadWidget, self).__init__()

        self.id = unique_id
        self.par = parent
        self.layout = QtGui.QGridLayout()
        self.outerLayout = QtGui.QVBoxLayout()

        self.setLayout(self.outerLayout)

        # ---------[ Create Labels and corresponding Fields ]---------
        self.single_read_button = self.createButton(tr("Button", "Single Acquisition"), connect=self.on_single_read)
        self.continuous_read_button = self.createButton(tr("Button", "Continuous Acquisition"),
                connect=lambda: self.on_continuous_read(available_boards[0]))
        self.single_read_input  = self.createInput()
        self.interval_spinbox = self.createSpinbox(0, 100000, start_value=1000)
        self.interval_spinbox.valueChanged.connect(self.set_interval)

        self.board_ticks = {board_id: self.createCheckbox(str(board_id), checked=True if board_id==0 else False) for board_id in available_boards}
        self.board_ticks_continuous_read = {
            board_id: self.createCheckbox(str(board_id),
                                          connect=lambda state, b_id=board_id:
                                          self.on_continuous_read(state, board_id=b_id))
            for board_id in available_boards
            }

        for board_id, tick in list(self.board_ticks_continuous_read.items()):
            Elements.addItem('acquireTrigger_{}'.format(board_id), tick)
            Elements.addItem(["acquire_{}".format(board_id), "no_board_{}".format(board_id)], tick)
            Elements.addItem('continuous_read_{}'.format(board_id), tick)
        for board_id, tick in self.board_ticks.items():
            Elements.addItem('acquireTrigger_{}'.format(board_id), tick)
            Elements.addItem(["acquire_{}".format(board_id), "no_board_{}".format(board_id)], tick)

        # --------[ Fill Grid ]----------------
        self.layout.addWidget(self.continuous_read_button, 0, 1)
        self.layout.addWidget(self.single_read_button, 1, 1)
        self.layout.addWidget(self.createLabel(tr("Label", "info:")), 2, 0)
        self.layout.addWidget(self.single_read_input, 2, 1)
        self.layout.addWidget(self.createLabel(tr("Label", "Interval:") + " (ms)"), 3, 0)
        self.layout.addWidget(self.interval_spinbox, 3, 1)
        self.setWindowTitle(tr("Heading", "Single and Continuous Read"))


        #01.04.2021 by Timo
        #We currently only support a single board.
        #However, this might change again in the future, so we only hide
        #the board selection checkbox until then, to avoid confusion
        '''
        self.tickLayout = QtGui.QHBoxLayout()
        self.tickLayout.addWidget(self.createLabel(
                tr("Label", "Boards"), tooltip=tr("Tooltip", "Check the board you want to select for single read"))
        )
        self.tickLayout.addStretch(1)
        for tick in list(self.board_ticks.values()):
            self.tickLayout.addWidget(tick)
        self.tickLayoutContinuousRead = QtGui.QHBoxLayout()
        self.tickLayoutContinuousRead.addWidget(self.createLabel(
                tr("Label", "Continuous Read"),
                tooltip=tr("Tooltip",
                           "Tick the board you want to continuously read."
                           "\nThe selected boards will continue reading until the checkbox is unticked.")
                )
        )
        self.tickLayoutContinuousRead.addStretch(1)
        for tick in list(self.board_ticks_continuous_read.values()):
            self.tickLayoutContinuousRead.addWidget(tick)
        self.outerLayout.addLayout(self.tickLayoutContinuousRead)
        self.outerLayout.addLayout(self.tickLayout)
        '''


        self.outerLayout.addLayout(self.layout)

        self.set_interval()

    def on_single_read(self):
        """
        Perform a single read on all boards which ticks are set
        :return:
        """
        for board_id, tick in self.board_ticks.items():
            if tick.isChecked() and tick.isEnabled():
                print(time.time(), 'on_single_read start')
                bif.bk_single_read(board_id, str(self.single_read_input.text()))
                print(time.time(), 'on_single_read stop')

    def on_continuous_read(self, board_id):
        """
        Toggle function to toggle continuous read when the corresponding button is pressed.
        :param bool state: True to activate and False to deactivate continuous read for board_id
        :param int? board_id: the id of the board to take action with
        :return: -
        """
        # if self.board_ticks_continuous_read[id].isChecked():
        self.set_interval()
        if not board.get_board_status(board_id).continuous_read:
            self.continuous_read_button.setText(tr("Button", "Stop Acquisition"))
            self.single_read_button.setEnabled(False)
            # self.continuous_read[id] = True
            # self.board_ticks_continuous_read[board_id].setStyleSheet("border-color: green; border-width: 3px;")
        else:
            self.continuous_read_button.setText(tr("Button", "Continuous Acquisition"))
            #self.board_ticks_continuous_read[board_id].setStyleSheet("")
            self.single_read_button.setEnabled(True)

        #Note:
        #bk_continuous_read is a toggle function.
        #Each call switches from off to on, and vice versa
        bif.bk_continuous_read(board_id)  # interval=self.interval_spinbox.value())


    def set_interval(self):
        """
        Set the interval between reads
        """
        storage.continuous_interval = self.interval_spinbox.value()


    def closeEvent(self, event):
        """
        Event handler to handle the event of closing this window and gracefully delete ids and such
        :param event: the event to process (gets passed by PyQt)
        """
        global __widget_id__
        __widget_id__ = None
        del self.par.widgets[self.id]
        Elements.removeItem(['no_board', 'acquire'],
                            [
                                self.single_read_button,
                                # self.continuous_read_button
                            ])
        for board_id, tick in list(self.board_ticks_continuous_read.items()):
            Elements.removeItem(
                [
                    "continuous_read_{}".format(board_id),
                    "acquireTrigger_{}".format(board_id),
                    "acquire_{}".format(board_id),
                    "no_board_{}".format(board_id)
                ], tick)

        for board_id, tick in self.board_ticks.items():
            Elements.removeItem(
                [
                    "acquireTrigger_{}".format(board_id),
                    "acquire_{}".format(board_id),
                    "no_board_{}".format(board_id)
                ], tick)

        super(SingleReadWidget, self).closeEvent(event)


def addSingleReadWidget():
    """
    Add this widget to the gui.
    This function will actually open the subwindow.
    :return: -
    """
    global __widget_id__
    if __widget_id__:
        global_objects.get_global('area').widgets[__widget_id__].setFocus()
    else:
        nid = kcgw.idg.genid()
        __widget_id__ = nid
        w = SingleReadWidget(nid, global_objects.get_global('area'))
        global_objects.get_global('area').newWidget(w, "Single and Continuous Read", nid, widget_type=4, minSize=True)  # TODO: proper type

kcgw.register_widget(QtGui.QIcon(config.icon_path(config.singleReadIcon)),
                     tr("Heading", "Single Read"),
                     addSingleReadWidget,
                     "Ctrl+i"
                     )