KaptureControlGui/KCG/widgets/AcquireSettingsWidget.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.CalibrationHandle import theCalibration
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.numOfTurnsLabel       = self.createLabel(tr("Label", "Number of turns to observe"))
        self.numOfSkipTurnsLabel   = self.createLabel(tr("Label", "Number of turns to skip"))
        self.numOfTurnsSpinbox     = self.createSpinbox(1, 10000000, connect=self.on_number_of_turns_changed)
        self.numOfSkipTurnsSpinbox = self.createSpinbox(0, 100, connect=self.on_number_of_skipped_turns_changed)
        self.fileSizeLabel          = self.createLabel(tr("Label", "Resulting file size"))
        self.fileSizeOutLabel       = self.createLabel(tr("Label", "??"))
        self.totalDurationLabel     = self.createLabel(tr("Label", "Total Duration"))
        self.totalDurationOutLabel  = self.createLabel(tr("Label", "??"))
        self.totalSizeLabel     = self.createLabel(tr("Label", "Total Size"))
        self.totalSizeOutLabel  = self.createLabel(tr("Label", "??"))
        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)

        self.shiftFMC2Label   = self.createLabel(tr("Label", "shift FMC2"))
        self.shiftFMC2Spinbox = self.createSpinbox(-20, 20, connect=self.on_shift_FMC2_changed)
        self.reloadCalibration = self.createButton('reload Calibration', connect=lambda : theCalibration.reload())

        # ----------[ 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.numOfTurnsSpinbox,
                                                 lambda x: self.set_value_silent(self.numOfTurnsSpinbox, x),
                                                 'turns_observe')
        board.get_board_config(board_id).observe(self.numOfSkipTurnsSpinbox,
                                                 lambda x: self.set_value_silent(self.numOfSkipTurnsSpinbox, x),
                                                 'turns_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),
                                                 'turns_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')
        board.get_board_config(board_id).observe(self.fileSizeOutLabel, self.set_filesize, 'turns_observe')
        board.get_board_config(board_id).observe(self.fileSizeOutLabel, self.set_filesize, 'turns_skip')
        # -------[ register elements ]-------
        Elements.addItem(["acquire", "no_board", "acquire_"+str(board_id)],
                         [
                             self.numOfTurnsSpinbox,
                             self.numOfSkipTurnsSpinbox,
                             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.numOfTurnsLabel, 1, 0)
        self.layout.addWidget(self.numOfTurnsSpinbox, 1, 1)
        self.layout.addWidget(self.numOfSkipTurnsLabel, 2, 0)
        self.layout.addWidget(self.numOfSkipTurnsSpinbox, 2, 1)
        self.layout.addWidget(self.fileSizeLabel, 3,0)
        self.layout.addWidget(self.fileSizeOutLabel, 3,1)
        line = QtGui.QFrame()
        line.setFrameShape(QtGui.QFrame.HLine)
        self.layout.addWidget(line, 4, 0, 1, 2)
        self.layout.addWidget(self.countLabel, 5, 0)
        self.layout.addWidget(self.countSpinbox, 5, 1)
        self.layout.addWidget(self.waitLabel, 6, 0)
        self.layout.addWidget(self.waitSpinbox, 6, 1)
        self.layout.addWidget(self.simulatePilotBunch, 11, 0)
        self.layout.addWidget(self.buildSpectrogrammTickbox, 11, 1)
        self.layout.addWidget(self.trigger_tick, 9, 0)
        line = QtGui.QFrame()
        line.setFrameShape(QtGui.QFrame.HLine)
        self.layout.addWidget(line, 10, 0, 1, 2)
        self.layout.addWidget(self.shiftFMC2Label, 12, 0)
        self.layout.addWidget(self.shiftFMC2Spinbox, 12, 1)
        self.layout.addWidget(self.reloadCalibration, 13, 0)
        self.layout.addWidget(self.totalDurationLabel, 14, 0)
        self.layout.addWidget(self.totalDurationOutLabel, 14, 1)
        self.layout.addWidget(self.totalSizeLabel, 15, 0)
        self.layout.addWidget(self.totalSizeOutLabel, 15, 1)


    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.items():
            wid.sameAsCombo.clear()
            for key, value in self.available_for_same_as.items():
                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, 6, 0)
            self.layout.addWidget(self.timeout, 6, 1)
            self.layout.addWidget(self.trigger_skip_label, 7, 0)
            self.layout.addWidget(self.trigger_skip_signals, 7, 1)
            self.layout.addWidget(self.method_label, 8, 0)
            self.layout.addWidget(self.method, 8, 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, 6, 0)
            self.layout.addWidget(self.waitSpinbox, 6, 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 set_filesize(self, state):
        turns = bif.bk_get_config(self.board_id, 'turns_observe')
        turns_skip = bif.bk_get_config(self.board_id, 'turns_skip')        
        bunches = bif.bk_get_config(self.board_id, 'bunches_per_turn')
        adc = bif.bk_get_config(self.board_id, 'adc_number')
        header = bif.bk_get_config(self.board_id, 'header')
        size = turns//(turns_skip+1)*bunches/2.0*adc
        if header: size += 8.0
        size *= 4.0
        size += 0x180
        
        pagesize = 4*1024
        overhead = (size%pagesize)
        if overhead > 0:
            overhead = pagesize-overhead
            size = (size//pagesize + 1)*pagesize
        size = size/(1024.0*1024.0)


        self.fileSizeOutLabel.setText("{:.3f} MB, {:} B overhead".format(size, int(overhead)))


        ac = 1.0*bif.bk_get_config(self.board_id, 'acquisition_count')
        wt = 1.0*bif.bk_get_config(self.board_id, 'turns_wait_time')

        sec = ac*wt
        h = ac*wt/(60.0*60.0)

        totalsize = size *ac/(1024.0)

        self.totalDurationOutLabel.setText("{:.2f} h".format(h))
        self.totalSizeOutLabel.setText("{:.2f} GB".format(totalsize))

    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.numOfTurnsSpinbox, bif.bk_get_config(self.board_id, 'turns_observe'))
        self.set_value_silent(self.numOfSkipTurnsSpinbox, bif.bk_get_config(self.board_id, 'turns_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, 'turns_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_turns_changed(self):
        """
        Handle the change of the number of turns
        """
        bif.bk_change_num_of_turns(self.board_id, self.numOfTurnsSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_num_of_turns(wid.board_id, wid.numOfTurnsSpinbox.value())

    def on_number_of_skipped_turns_changed(self):
        """
        Handle the change of the number of skipped turns
        """
        bif.bk_change_num_of_skipped_turns(self.board_id, self.numOfSkipTurnsSpinbox.value())
        for b_id in self.same_as_widgets[self.board_id]:
            wid = self.widgets[b_id]
            bif.bk_change_num_of_skipped_turns(wid.board_id, wid.numOfSkipTurnsSpinbox.value())

    def on_count_changed(self):
        """
        Handle the change of the count value
        """
        self.set_filesize(0)
        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
        """
        self.set_filesize(0)
        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 on_shift_FMC2_changed(self, value):
        config.shiftFMC2 = 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.numOfTurnsSpinbox, 'turns_observe')
        board.get_board_config(self.board_id).unobserve(self.numOfSkipTurnsSpinbox, 'turns_skip')
        board.get_board_config(self.board_id).unobserve(self.countSpinbox, 'acquisition_count')
        board.get_board_config(self.board_id).unobserve(self.waitSpinbox, 'turns_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')
        board.get_board_config(self.board_id).unobserve(self.fileSizeOutLabel, 'turns_observe')
        board.get_board_config(self.board_id).unobserve(self.fileSizeOutLabel, 'turns_skip')
        
        Elements.removeItem(["acquire_{}".format(self.board_id), "no_board_{}".format(self.board_id)],
                            [
                                 self.numOfTurnsSpinbox,
                                 self.numOfSkipTurnsSpinbox,
                                 self.countSpinbox,
                                 self.waitSpinbox,
                                 self.buildSpectrogrammTickbox,
                                 self.simulatePilotBunch,
                                 self.trigger_skip_signals,
                                 self.timeout,
                                 self.method,
                                 self.trigger_tick
                             ]
                            )



#        d8888                            d8b                   .d8888b.           888    888    d8b
#       d88888                            Y8P                  d88P  Y88b          888    888    Y8P
#      d88P888                                                 Y88b.               888    888
#     d88P 888  .d8888b  .d88888 888  888 888 888d888  .d88b.   "Y888b.    .d88b.  888888 888888 888 88888b.   .d88b.  .d8888b
#    d88P  888 d88P"    d88" 888 888  888 888 888P"   d8P  Y8b     "Y88b. d8P  Y8b 888    888    888 888 "88b d88P"88b 88K
#   d88P   888 888      888  888 888  888 888 888     88888888       "888 88888888 888    888    888 888  888 888  888 "Y8888b.
#  d8888888888 Y88b.    Y88b 888 Y88b 888 888 888     Y8b.     Y88b  d88P Y8b.     Y88b.  Y88b.  888 888  888 Y88b 888      X88
# d88P     888  "Y8888P  "Y88888  "Y88888 888 888      "Y8888   "Y8888P"   "Y8888   "Y888  "Y888 888 888  888  "Y88888  88888P'
#                            888                                                                                   888
#                            888                                                                              Y8b d88P
#                            888                                                                               "Y88P"

class AcquireSettingsWidget(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(AcquireSettingsWidget, 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 list(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 = list(self.widgets.values())[0]
            self.layout.addWidget(self.single_widget)
        for wid in list(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(list(self.widgets.keys()).index(board_id))

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


def addAcquireSettingsWidget(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 = AcquireSettingsWidget(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)




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