KaptureControlGui/KCG/widgets/acquiresettings.py

"""
This Module Is the Acquiresettings subWindow.
"""
from PyQt4 import QtGui, QtCore
from collections import OrderedDict

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

__widget_id__ = None


class AcquireSettingsTab(kcgw.KCGWidgets):
    """
    A single tab in the acquire settings window
    """
    available_for_same_as = OrderedDict()

    def __init__(self, board_id, same_as_widgets, parent=None):
        super(AcquireSettingsTab, self).__init__()
        self.available_for_same_as[board_id] = True
        self.widgets = None  # IMPORTANT: THIS WIDGET NEEDS A LIST OF ALL THE OTHER WIDGETS
        self.same_as_widgets = same_as_widgets
        self.parent = parent
        self.board_id = board_id
        self.layout = QtGui.QGridLayout()
        self.outerLayout = QtGui.QVBoxLayout()
        self.outerLayout.addLayout(self.layout)
        self.outerLayout.addStretch(1)
        self.setLayout(self.outerLayout)

        self.sameAsLabel = self.createLabel("Same as")
        self.sameAsCombo = QtGui.QComboBox()
        self.sameAsTick = self.createCheckbox("", connect=self.same_as)
        self.sameAs = QtGui.QHBoxLayout()
        self.sameAs.addWidget(self.sameAsCombo)
        self.sameAs.addWidget(self.sameAsTick)
        if available_boards.multi_board:
            self.layout.addWidget(self.sameAsLabel, 0, 0)
            self.layout.addLayout(self.sameAs, 0, 1)
        else:
            self.sameAsLabel.hide()

        # ---------[ Create Labels and corresponding Fields ]---------
        self.numOfOrbitsLabel = self.createLabel(tr("Label", "Number of orbits to observe"))
        self.numOfSkipOrbitsLabel = self.createLabel(tr("Label", "Number of orbits to skip"))
        self.numOfOrbitsSpinbox = self.createSpinbox(1, 10000000, connect=self.on_number_of_orbits_changed)
        self.numOfSkipOrbitsSpinbox = self.createSpinbox(0, 100, connect=self.on_number_of_skipped_orbits_changed)
        self.countLabel = self.createLabel(tr("Label", "Number of acquisitions"))
        self.countSpinbox = self.createSpinbox(1, 10000000, start_value=10, connect=self.on_count_changed)
        self.waitLabel = self.createLabel(tr("Label", "Wait(s)"))
        self.waitSpinbox = self.createSpinbox(0, 60, start_value=15, connect=self.on_wait_changed)
        self.simulatePilotBunch = self.createCheckbox(tr("Button", "Simulate Pilot Bunch"),
                                                      connect=self.on_simulate_pilot_bunch_changed)
        self.buildSpectrogrammTickbox = self.createCheckbox(tr("Button", "Build Spectograms"),
                                                            connect=self.on_build_spectrograms_changed)

        # ----------[ Trigger part ]--------------------
        self.trigger_skip_label = self.createLabel(tr("Label", "Number of trigger signals to skip"))
        self.trigger_skip_signals = self.createSpinbox(0, 1000, 1, start_value=0,
                                                       connect=self.on_trigger_skip_signals_changed)
        self.timeout_label = self.createLabel(tr("Label", "Timeout (s)"))
        self.timeout = self.createSpinbox(0, 10000000, start_value=12, connect=self.on_trigger_timeout_changed)
        self.method_label = self.createLabel(tr("Label", "Method"))
        self.method = kcgw.Switch("1", "2")
        self.method.clicked.connect(self.on_trigger_method_changed)
        self.trigger_skip_label.hide()
        self.trigger_skip_signals.hide()
        self.timeout_label.hide()
        self.timeout.hide()
        self.method_label.hide()
        self.method.hide()

        self.trigger_tick = self.createCheckbox(tr("Label", "Use External Trigger"), connect=self.use_external_trigger)

        # -------[ register observers ]------
        board.get_board_config(board_id).observe(self.numOfOrbitsSpinbox,
                                                 lambda x: self.set_value_silent(self.numOfOrbitsSpinbox, x),
                                                 'orbits_observe')
        board.get_board_config(board_id).observe(self.numOfSkipOrbitsSpinbox,
                                                 lambda x: self.set_value_silent(self.numOfSkipOrbitsSpinbox, x),
                                                 'orbits_skip')
        board.get_board_config(board_id).observe(self.countSpinbox,
                                                 lambda x: self.set_value_silent(self.countSpinbox, x),
                                                 'acquisition_count')
        board.get_board_config(board_id).observe(self.waitSpinbox,
                                                 lambda x: self.set_value_silent(self.waitSpinbox, x),
                                                 'orbits_wait_time')
        board.get_board_config(board_id).observe(self.simulatePilotBunch,
                                                 lambda x: self.tick_silent(self.simulatePilotBunch, x),
                                                 'pilot_bunch')
        board.get_board_config(board_id).observe(self.buildSpectrogrammTickbox,
                                                 lambda x: self.tick_silent(self.buildSpectrogrammTickbox, x),
                                                 'build_spectrograms')
        board.get_board_config(board_id).observe(self.trigger_skip_signals,
                                                 lambda x: self.set_value_silent(self.trigger_skip_signals, x),
                                                 'trigger_skip')
        board.get_board_config(board_id).observe(self.timeout,
                                                 lambda x: self.set_value_silent(self.timeout, x), 'trigger_timeout')
        board.get_board_config(board_id).observe(self.trigger_tick, self.update_external_trigger, 'use_trigger')
        # -------[ register elements ]-------
        Elements.addItem(["acquire", "no_board", "acquire_"+str(board_id)],
                         [
                             self.numOfOrbitsSpinbox,
                             self.numOfSkipOrbitsSpinbox,
                             self.countSpinbox,
                             self.waitSpinbox,
                             self.buildSpectrogrammTickbox,
                             self.simulatePilotBunch,
                             self.trigger_skip_signals,
                             self.timeout,
                             self.method,
                             self.trigger_tick
                         ])

        # -------[ Add to grid ]-------------
        self.layout.addWidget(self.numOfOrbitsLabel, 1, 0)
        self.layout.addWidget(self.numOfOrbitsSpinbox, 1, 1)
        self.layout.addWidget(self.numOfSkipOrbitsLabel, 2, 0)
        self.layout.addWidget(self.numOfSkipOrbitsSpinbox, 2, 1)
        self.layout.addWidget(self.countLabel, 3, 0)
        self.layout.addWidget(self.countSpinbox, 3, 1)
        self.layout.addWidget(self.waitLabel, 4, 0)
        self.layout.addWidget(self.waitSpinbox, 4, 1)
        self.layout.addWidget(self.simulatePilotBunch, 9, 0)
        self.layout.addWidget(self.buildSpectrogrammTickbox, 9, 1)
        self.layout.addWidget(self.trigger_tick, 7, 0)
        line = QtGui.QFrame()
        line.setFrameShape(QtGui.QFrame.HLine)
        self.layout.addWidget(line, 8, 0, 1, 2)

    def build_same_as_list(self):
        """
        Build the list to show in the same-as drop down menu
        :return:
        """
        for wid_id, wid in self.widgets.iteritems():
            wid.sameAsCombo.clear()
            for key, value in self.available_for_same_as.iteritems():
                if value:
                    if key is not wid_id:
                        wid.sameAsCombo.addItem(available_boards.get_board_name_from_id(key))

    def same_as(self):
        """
        Toggle SameAs functionality
        :return: -
        """
        # This only does the ui
        bif._bif_enable_wait_cursor()
        QtGui.qApp.processEvents()
        c_t = available_boards.get_board_id_from_name(str(self.sameAsCombo.currentText()))
        if self.sameAsTick.isChecked():
            self.available_for_same_as[self.board_id] = False
            self.sameAsCombo.setEnabled(False)
            board.get_board_config(c_t).observe_all(
                board.get_board_config(self.board_id).update)
            self.widgets[c_t].sameAsTick.setEnabled(False)
            self.widgets[c_t].sameAsCombo.setEnabled(False)
            Elements.setEnabled('acquire_{}'.format(self.board_id), False)
            board.get_board_config(c_t).notify_all_observers()

        else:
            self.available_for_same_as[self.board_id] = True
            self.sameAsCombo.setEnabled(True)
            board.get_board_config(c_t).unobserve_all_observer(
                board.get_board_config(self.board_id).update)
            self.widgets[c_t].sameAsTick.setEnabled(True)
            self.widgets[c_t].sameAsCombo.setEnabled(True)
            Elements.setEnabled('acquire_{}'.format(self.board_id), True)
        # actual changes on board
        if c_t in self.same_as_widgets:
            self.same_as_widgets[c_t].append(self.board_id)
        else:
            self.same_as_widgets[c_t] = [self.board_id, ]

        self.build_same_as_list()
        bif._bif_disable_wait_cursor()

    def update_external_trigger(self, state):
        """
        Update the use external trigger tick
        :param state: the state to set the tick to
        """
        self.tick_silent(self.trigger_tick, state)
        self.use_external_trigger(state, update_config=False)

    def use_external_trigger(self, state, update_config=True):
        """
        Set use external trigger to state
        :param state: the state to set to
        :param update_config: true to update the board config
        """
        if state:
            if update_config:
                board.get_board_config(self.board_id).update('use_trigger', True)
            self.layout.removeWidget(self.waitLabel)
            self.layout.removeWidget(self.waitSpinbox)
            self.waitLabel.hide()
            self.waitSpinbox.hide()

            self.layout.addWidget(self.timeout_label, 4, 0)
            self.layout.addWidget(self.timeout, 4, 1)
            self.layout.addWidget(self.trigger_skip_label, 5, 0)
            self.layout.addWidget(self.trigger_skip_signals, 5, 1)
            self.layout.addWidget(self.method_label, 6, 0)
            self.layout.addWidget(self.method, 6, 1)
            self.timeout_label.show()
            self.timeout.show()
            self.trigger_skip_label.show()
            self.trigger_skip_signals.show()
            self.method_label.show()
            self.method.show()
        else:
            if update_config:
                board.get_board_config(self.board_id).update('use_trigger', False)
            self.layout.addWidget(self.waitLabel, 4, 0)
            self.layout.addWidget(self.waitSpinbox, 4, 1)
            self.waitLabel.show()
            self.waitSpinbox.show()

            self.layout.removeWidget(self.timeout_label)
            self.layout.removeWidget(self.timeout)
            self.layout.removeWidget(self.trigger_skip_label)
            self.layout.removeWidget(self.trigger_skip_signals)
            self.layout.removeWidget(self.method_label)
            self.layout.removeWidget(self.method)
            self.timeout_label.hide()
            self.timeout.hide()
            self.trigger_skip_label.hide()
            self.trigger_skip_signals.hide()
            self.method_label.hide()
            self.method.hide()
        QtCore.QCoreApplication.processEvents()
        try:
            self.parent.parent().adjustSize()
        except AttributeError:  # when widget is opened with external trigger activated parent.parent() is None
            pass

    def set_value_silent(self, element, value):
        """
        Set a Value silent without notifying observers
        :param element: what element
        :param value: set to what value
        :return: -
        """
        element.blockSignals(True)
        element.setValue(value)
        element.blockSignals(False)

    def tick_silent(self, element, state):
        """
        Tick a tickbox without notifying observers
        :param element: what tickbox
        :param state: (bool) to what state
        :return: -
        """
        element.blockSignals(True)
        element.setChecked(state)
        element.blockSignals(False)

    def set_values(self):
        """
        Set Initial Values when creating this Window.
        This will read the appropriate Values from the base.backend.board.BoardConfiguration instance used in the gui.
        :return: -
        """
        # bk_get_config has to be done for each widget seperately (get dientifier by widget.board_id)
        self.set_value_silent(self.numOfOrbitsSpinbox, bif.bk_get_config(self.board_id, 'orbits_observe'))
        self.set_value_silent(self.numOfSkipOrbitsSpinbox, bif.bk_get_config(self.board_id, 'orbits_skip'))
        self.set_value_silent(self.countSpinbox, bif.bk_get_config(self.board_id, 'acquisition_count'))
        self.set_value_silent(self.waitSpinbox, bif.bk_get_config(self.board_id, 'orbits_wait_time'))
        self.tick_silent(self.buildSpectrogrammTickbox, bif.bk_get_config(self.board_id, 'build_spectrograms'))
        self.tick_silent(self.simulatePilotBunch, bif.bk_get_config(self.board_id, 'pilot_bunch'))
        self.update_external_trigger(bif.bk_get_config(self.board_id, 'use_trigger'))

    # -----------------[ Value Change Handlers ]---------------------------
    def on_number_of_orbits_changed(self):
        """
        Handle the change of the number of orbits
        """
        bif.bk_change_num_of_orbits(self.board_id, self.numOfOrbitsSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_num_of_orbits(wid.board_id, wid.numOfOrbitsSpinbox.value())

    def on_number_of_skipped_orbits_changed(self):
        """
        Handle the change of the number of skipped orbits
        """
        bif.bk_change_num_of_skipped_orbits(self.board_id, self.numOfSkipOrbitsSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_num_of_skipped_orbits(wid.board_id, wid.numOfSkipOrbitsSpinbox.value())

    def on_count_changed(self):
        """
        Handle the change of the count value
        """
        bif.bk_change_count(self.board_id, self.countSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_count(wid.board_id, wid.countSpinbox.value())

    def on_wait_changed(self):
        """
        Handle the change of the wait time
        """
        bif.bk_change_wait(self.board_id, self.waitSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_wait(wid.board_id, wid.waitSpinbox.value())

    def on_build_spectrograms_changed(self):
        """
        Handle the change of the build_spectrograms checkbox
        """
        bif.bk_change_build_spectrograms(self.board_id, self.buildSpectrogrammTickbox.checkState())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_build_spectrograms(wid.board_id, wid.buildSpectrogrammTickbox.checkState())

    def on_simulate_pilot_bunch_changed(self):
        """
        Handle the change of the simulate_pilot_bunch checkbox
        """
        bif.bk_change_pilot_bunch(self.board_id, self.simulatePilotBunch.checkState())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_pilot_bunch(wid.board_id, wid.simulatePilotBunch.checkState())

    def on_trigger_skip_signals_changed(self, value):
        """
        Handle change of trigger skip signal spinbox
        :param int value: the value to set trigger_skip to (the number of trigger signals to skip between acquisitions
        """
        bif.bk_update_config(self.board_id, 'trigger_skip', value)
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_update_config(wid.board_id, 'trigger_skip', value)

    def on_trigger_method_changed(self):
        """
        Handle change of trigger method.
        """
        bif.bk_update_config(self.board_id, 'trigger_method', 2 if self.method.state() else 1)
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_update_config(wid.board_id, 'trigger_method', 2 if self.method.satate() else 1)

    def on_trigger_timeout_changed(self, value):
        """
        Handle change of trigger timeout spinbox
        :param int value: the value to set the trigger_timout to
        """
        bif.bk_update_config(self.board_id, 'trigger_timeout', value)
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_update_config(wid.board_id, 'trigger_timeout', value)

    def closeEvent(self, event):
        """
        Event handler to handle the event of closing this window and gracefully delete resources and such
        :param event: the event to handle (gets passed to by PyQt)
        """
        board.get_board_config(self.board_id).unobserve(self.numOfOrbitsSpinbox, 'orbits_observe')
        board.get_board_config(self.board_id).unobserve(self.numOfSkipOrbitsSpinbox, 'orbits_skip')
        board.get_board_config(self.board_id).unobserve(self.countSpinbox, 'acquisition_count')
        board.get_board_config(self.board_id).unobserve(self.waitSpinbox, 'orbits_wait_time')
        board.get_board_config(self.board_id).unobserve(self.simulatePilotBunch, 'pilot_bunch')
        board.get_board_config(self.board_id).unobserve(self.buildSpectrogrammTickbox, 'build_spectrograms')
        board.get_board_config(self.board_id).unobserve(self.trigger_skip_signals, 'trigger_skip')
        board.get_board_config(self.board_id).unobserve(self.timeout, 'trigger_timeout')
        board.get_board_config(self.board_id).unobserve(self.trigger_tick, 'use_trigger')
        Elements.removeItem(["acquire_{}".format(self.board_id), "no_board_{}".format(self.board_id)],
                            [
                                 self.numOfOrbitsSpinbox,
                                 self.numOfSkipOrbitsSpinbox,
                                 self.countSpinbox,
                                 self.waitSpinbox,
                                 self.buildSpectrogrammTickbox,
                                 self.simulatePilotBunch,
                                 self.trigger_skip_signals,
                                 self.timeout,
                                 self.method,
                                 self.trigger_tick
                             ]
                            )


class AcquireSettings(kcgw.KCGWidgets):
    """
    This is the actual Acquire Settings Window.
    """
    def __init__(self, unique_id, parent=None):
        """
        Initialise the acquire settings window
        :param unique_id: the id for thiw widget
        :param parent: parent object
        :return: -
        """
        super(AcquireSettings, self).__init__()

        self.id = unique_id
        self.par = parent
        self.layout = QtGui.QHBoxLayout()
        self.setLayout(self.layout)
        self.setWindowTitle(tr("Heading", "Acquire Settings"))
        self.same_as_widgets = {i: [] for i in available_boards}
        self.widgets = OrderedDict({i: AcquireSettingsTab(i, self.same_as_widgets, self) for i in available_boards})
        if available_boards.multi_board:
            self.tabs = QtGui.QTabWidget()
            self.layout.addWidget(self.tabs)

            for wid in self.widgets.values():
                self.tabs.addTab(wid, available_boards.get_board_name_from_id(wid.board_id))
                wid.sameAsCombo.addItems([available_boards.get_board_name_from_id(i) for i in available_boards if i != wid.board_id])
                wid.widgets = self.widgets
        else:
            self.single_widget = self.widgets.values()[0]
            self.layout.addWidget(self.single_widget)
        for wid in self.widgets.values():
            wid.set_values()

    def show_tab(self, board_id):
        """
        Show the tab for the given board
        :param board_id: the id of the board to show
        """
        if not available_boards.multi_board:
            return
        self.tabs.setCurrentIndex(self.widgets.keys().index(board_id))

    def closeEvent(self, event):
        global __widget_id__
        for wid in self.widgets.values():
            wid.closeEvent(event)
        __widget_id__ = None
        del self.par.widgets[self.id]
        super(AcquireSettings, self).closeEvent(event)


def add_acquire_settings_widget(board_id=None):
    """
    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()
        if board_id is not None:
            global_objects.get_global('area').widgets[__widget_id__].show_tab(board_id)
    else:
        nid = kcgw.idg.genid()
        __widget_id__ = nid
        w = AcquireSettings(nid, global_objects.get_global('area'))
        global_objects.get_global('area').newWidget(w, "Acquire", nid, widget_type=4, minSize=True)  # TODO: proper type
        if board_id is not None:
            global_objects.get_global('area').widgets[__widget_id__].show_tab(board_id)


def setValueSilent(key, value):
    """
    Set values without notifying observers
    :param key: the key
    :param value: the value to set
    :return: -
    """
    if not __widget_id__:
        return
    global_objects.get_global('area').widgets[__widget_id__].blockSignals(True)
    if key == "orbits_observe":
        global_objects.get_global('area').widgets[__widget_id__].numOfOrbitsSpinbox.setValue(value)
    if key == "orbits_skip":
        global_objects.get_global('area').widgets[__widget_id__].numOfSkipOrbitsSpinbox.setValue(value)
    global_objects.get_global('area').widgets[__widget_id__].blockSignals(False)


kcgw.register_widget(QtGui.QIcon(config.install_path + config.acquireSettingsIcon), tr("Heading", "Acquire Settings"), add_acquire_settings_widget, "Ctrl+A")