KaptureControlGui/KCG/widgets/TimingWidget.py

"""
This Module Is the Timingsettings subWindow.
"""
import logging

from PyQt4 import QtGui, QtCore
import pyqtgraph as pg
import numpy as np
import h5py

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 ..base.globals import glob as global_objects
from .. import config
from ..base import storage
from ..base.backend.CalibrationHandle import theCalibration

tr = kcgw.tr
import os


__widget_id__ = None
__timing_plot_widget_id__ = {}
__timing_plot_widget__ = None

BUNCHES_PER_TURN = config.bunches_per_turn



# 88888888888d8b             d8b                8888888b.                888
#     888    Y8P             Y8P                888   Y88b               888
#     888                                       888    888               888
#     888    88888888b.d88b. 88888888b.  .d88b. 888   d88P 8888b. 888d888888888
#     888    888888 "888 "88b888888 "88bd88P"88b8888888P"     "88b888P"  888
#     888    888888  888  888888888  888888  888888       .d888888888    888
#     888    888888  888  888888888  888Y88b 888888       888  888888    Y88b.
#     888    888888  888  888888888  888 "Y88888888       "Y888888888     "Y888
#                                            888
#                                       Y8b d88P
#                                        "Y88P"

class TimingPart(kcgw.KCGWidgets):
    """
    The actual timing settings window
    """
    def __init__(self, board_id, parent=None):
        """
        Initialise the timing settings window
        :param unique_id:
        :param parent:
        :return:
        """
        super(TimingPart, self).__init__()

        if __timing_plot_widget__:
            self.plotWidget = __timing_plot_widget__
        self.parent = parent
        self.board_id = board_id
        self.board_config =  board.get_board_config(board_id)
        self.coarseLayout = QtGui.QGridLayout()
        self.fineLayout = QtGui.QGridLayout()
        self.layout = QtGui.QVBoxLayout()
        self.layout.addLayout(self.coarseLayout)
        self.layout.addLayout(self.fineLayout)
        self.outerLayout = QtGui.QVBoxLayout()
        self.outerLayout.addLayout(self.layout)
        self.setLayout(self.outerLayout)


        #  --------[ Create Labels and corresponding Fields ]---------

        def update_delay(which, spinbox):
            '''update the delays on the board'''
            val = getattr(self, spinbox).value()
            self.board_config.update(which, val)


        self.adc_number = self.board_config.get('adc_number')
        self.delayLabel = self.createLabel(tr("Label", "T/H Coarse Delays"))
        self.thdelayLabel = self.createLabel(tr("Label", "FMC 1"))


        if self.adc_number > 4:
            self.thdelayLabel_2 = self.createLabel("FMC 2")
        self.coarseLabel = self.createLabel(tr("Label", "330ps"))
        self.coarseLabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        #Coarse delay settings for FMC2 might have to be replicated from FMC1, so we need a run the update of the FMC1 spinbox through a helper-function,
        #instead directly through update_delay
        self.coarseInputTh   = self.createSpinbox(0, self.board_config.get('delay_330_max'), connect=self.linkFMCCoarseDelay)

        Elements.addItem(["timing_{}".format(self.board_id), "no_board_{}".format(self.board_id), "acquire_{}".format(self.board_id)],
                         [
                            #self.coarseInputFpga,
                            #self.coarseInputAdc,
                            self.coarseInputTh
                         ]
                         )

        self.expertSwitch = self.createCheckbox(tr("Label", "Expert Settings"), connect=self.toggleExpert)

        if self.board_config.is_KAPTURE2():
            self.coarse2Label = self.createLabel(tr("Label", "25ps"))
            self.coarse2Label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
            self.coarse2InputTh   = self.createSpinbox(0, self.board_config.get('delay_25_max'), connect=lambda: update_delay("delay_25_th", "coarse2InputTh"))

            Elements.addItem(["timing_{}".format(self.board_id), "no_board_{}".format(self.board_id), "acquire_{}".format(self.board_id)],
                         [
                            #self.coarse2InputAdc,
                            #self.coarse2InputFpga,
                            self.coarse2InputTh
                         ]
                         )

            if self.adc_number > 4:
                self.linkTHSwitch = self.createCheckbox(tr("Label", "Link to FMC 1"), connect=self.toggleFMC2IndividualDelay)
                self.linkTHSwitch.setCheckState(QtCore.Qt.Checked)

                self.coarseInputTh_2   = self.createSpinbox(0, self.board_config.get('delay_330_max'), connect=lambda: update_delay("delay_330_th_2", "coarseInputTh_2"))
                self.coarse2InputTh_2   = self.createSpinbox(0, self.board_config.get('delay_25_max'), connect=lambda: update_delay("delay_25_th_2", "coarse2InputTh_2"))

                Elements.addItem(["timing_{}".format(self.board_id), "no_board_{}".format(self.board_id), "acquire_{}".format(self.board_id)],
                             [
                                #self.coarseInputFpga,
                                #self.coarseInputAdc,
                                #self.coarseInputTh_2,
                                #self.coarse2InputAdc,
                                #self.coarse2InputFpga,
                                self.coarse2InputTh_2,
                                self.linkTHSwitch
                             ]
                             )


            #Controls for Expert mode
            self.labelFpgaDelay = self.createLabel("FPGA Delay")
            self.labelADCDelay = self.createLabel("FMC 1 ADC Delays")
            self.coarse330Adc  = self.createSpinbox(0, self.board_config.get('delay_330_max'), connect=lambda: update_delay("delay_330_adc", "coarse330Adc"))
            self.coarse330Fpga = self.createSpinbox(0, self.board_config.get('delay_330_max'), connect=lambda: update_delay("delay_330_fpga", "coarse330Fpga"))
            self.coarse25Adc  = self.createSpinbox(0, self.board_config.get('delay_25_max'), connect=lambda: update_delay("delay_25_adc", "coarse25Adc"))
            self.coarse25Fpga = self.createSpinbox(0, self.board_config.get('delay_25_max'), connect=lambda: update_delay("delay_25_fpga", "coarse25Fpga"))

            if self.adc_number > 4:
                self.labelADCDelay_2 = self.createLabel("FMC 2 ADC Delays")
                self.coarse330Adc_2  = self.createSpinbox(0, self.board_config.get('delay_330_max'), connect=lambda: update_delay("delay_330_adc_2", "coarse330Adc_2"))
                self.coarse25Adc_2  = self.createSpinbox(0, self.board_config.get('delay_25_max'), connect=lambda: update_delay("delay_25_adc_2", "coarse25Adc_2"))




        self.fineLabel = self.createLabel(tr("Label", "Fine Delay"))

        self.fineAdcInput = []
        for i in range(self.adc_number):
            self.fineAdcInput.append(self.createSpinbox(0, 31, connect=self.on_adc_delay_changed))

        Elements.addItem(["timing_{}".format(self.board_id),
            "no_board_{}".format(self.board_id),
            "acquire_{}".format(self.board_id)
            ], self.fineAdcInput
            )

        self.bunchShiftLabel = self.createLabel(tr("Label", "Bunch Shift"))

        self.bunchShiftInput = []
        for i in range(self.adc_number):
            self.bunchShiftInput.append(self.createSpinbox(-2, 2, connect=self.on_bunch_shift_changed))

        Elements.addItem(["timing_{}".format(self.board_id),
            "no_board_{}".format(self.board_id),
            "acquire_{}".format(self.board_id)
            ], self.bunchShiftInput
            )


        #---------[ End ]---------




        def setValueSilent(value, spinbox, adc):
            '''set values silent to not trigger signals'''
            spinbox.blockSignals(True)
            if adc is None:
                spinbox.setValue(value)
            else:
                spinbox.setValue(value[adc])
            spinbox.blockSignals(False)


        #Bunch Shift values are encoded 0x0 - 0x4 in Hardware
        #but displayed as -2 to +2 in the GUI, so we need to offset
        #the received register value by -2 when receiving an update
        #Values is passed in fro the callback and is expected to be
        #a list with values for each ADC
        def setBunchShiftValueSilent(values, adc):
            self.bunchShiftInput[adc].blockSignals(True)
            self.bunchShiftInput[adc].setValue(values[adc]-2)
            self.bunchShiftInput[adc].blockSignals(False)


        # --------[ Set observers ]------------
        def obs(who, what, adc=None):
            '''observe something'''
            board.get_board_config(board_id).observe(
                who,
                lambda value=None: setValueSilent(value=value, spinbox=who, adc=adc),
                what
            )
        for i, item in enumerate(self.fineAdcInput):
            obs(item, 'chip_delay', i)

        obs(self.coarseInputTh, 'delay_330_th')
        obs(self.coarse330Adc, 'delay_330_adc')
        obs(self.coarse330Fpga, 'delay_330_fpga')

        if self.board_config.is_KAPTURE2():
            obs(self.coarse2InputTh, 'delay_25_th')
            obs(self.coarse25Adc, 'delay_25_adc')
            obs(self.coarse25Fpga, 'delay_25_fpga')

            if self.adc_number > 4:
                obs(self.coarseInputTh_2, 'delay_330_th_2')
                obs(self.coarse330Adc_2, 'delay_330_adc_2')
                obs(self.coarse2InputTh_2, 'delay_25_th_2')
                obs(self.coarse25Adc_2, 'delay_25_adc_2')


        #Observers need to be set on individual control elements
        #But the callback will be fed with a list of values,
        #one entry for each ADC
        for i, item in enumerate(self.bunchShiftInput):
            board.get_board_config(board_id).observe(
                    item,
                    lambda values: setBunchShiftValueSilent(values, i),
                    'bunch_shift'
                    )


        # -------[ Create outputs ]---------------
        self.totalLabel = self.createLabel(tr("Label", "Total Delay"))
        self.totalAdcBox = []
        for i in range(self.adc_number):
            self.totalAdcBox.append(self.createInput("", read_only=True))
        self.totalAdcBoxCalib = []
        for i in range(self.adc_number):
            self.totalAdcBoxCalib.append(self.createInput("", read_only=True))

        self.board_config.observe(self.totalAdcBox[0], self.delay_observer, 'chip_delay')
        self.board_config.observe(self.totalAdcBox[0], self.delay_observer, 'delay_330_th')
        if self.board_config.is_KAPTURE2():
            self.board_config.observe(self.totalAdcBox[0], self.delay_observer, 'delay_25_th')
            if self.adc_number > 4:
                self.board_config.observe(self.totalAdcBox[0], self.delay_observer, 'delay_330_th_2')
                self.board_config.observe(self.totalAdcBox[0], self.delay_observer, 'delay_25_th_2')

        #--------[ Fill Grid ]----------------
        self.coarseLayout.addWidget(self.delayLabel, 0, 0)
        self.coarseLayout.addWidget(self.thdelayLabel, 0, 1)
        if self.board_config.is_KAPTURE2():
            self.coarseLayout.addWidget(self.expertSwitch, 0, 8,1,2)
            if self.adc_number > 4:
                self.coarseLayout.addWidget(self.thdelayLabel_2, 0, 2)

        self.coarseLayout.addWidget(self.coarseLabel, 1, 0)
        self.coarseLayout.addWidget(self.coarseInputTh, 1, 1)

        if self.board_config.is_KAPTURE2():
            self.coarseLayout.addWidget(self.coarse2Label, 2, 0)
            self.coarseLayout.addWidget(self.coarse2InputTh, 2, 1)

            if self.adc_number > 4:
                self.coarseLayout.addWidget(self.coarseInputTh_2, 1, 2)
                self.coarseLayout.addWidget(self.linkTHSwitch, 1, 3)
                self.coarseLayout.addWidget(self.coarse2InputTh_2, 2, 2)


            #Controls for Expert mode
            self.coarseLayout.addWidget(self.labelFpgaDelay, 0, 7)
            self.coarseLayout.addWidget(self.labelADCDelay, 0, 6)

            self.coarseLayout.addWidget(self.coarse330Fpga, 1, 7)
            self.coarseLayout.addWidget(self.coarse330Adc, 1, 6)

            self.coarseLayout.addWidget(self.coarse25Fpga, 2, 7)
            self.coarseLayout.addWidget(self.coarse25Adc, 2, 6)

            if self.adc_number > 4:
                self.coarseLayout.addWidget(self.labelADCDelay_2, 0, 5)
                self.coarseLayout.addWidget(self.coarse330Adc_2, 1, 5)
                self.coarseLayout.addWidget(self.coarse25Adc_2, 2, 5)



        # Leave some rows free for additional things (empty rows will not be shown)
        self.fineLayout.addItem(QtGui.QSpacerItem(10, 15), 0, 1)
        self.fineLayout.addItem(QtGui.QSpacerItem(10, 15), 1, 1)

        ### FINE DELAYS ###
        for i in range(self.adc_number):
            self.fineLayout.addWidget(self.createLabel("ADC "+str(i+1)), 2, i+1)
        self.fineLayout.addWidget(self.fineLabel, 3, 0)
        for i, item in enumerate(self.fineAdcInput):
            self.fineLayout.addWidget(item, 3, i+1)
        self.fineLayout.addWidget(self.bunchShiftLabel, 4, 0)
        for i, item in enumerate(self.bunchShiftInput):
            self.fineLayout.addWidget(item, 4, i+1)

        self.fineLayout.addItem(QtGui.QSpacerItem(10, 15), 4, 1)
        line = QtGui.QFrame()
        line.setFrameStyle(QtGui.QFrame.HLine)
        self.fineLayout.addWidget(line, 5, 0, 1, 0)
        self.fineLayout.addItem(QtGui.QSpacerItem(10, 15), 6, 1)
        self.fineLayout.addWidget(self.totalLabel, 7, 0)
        for i, item in enumerate(self.totalAdcBox):
            self.fineLayout.addWidget(item, 7, i+1)
            item.setFocusPolicy(QtCore.Qt.ClickFocus)
        self.fineLayout.addWidget(self.createLabel('Calibrated (ps)'), 8, 0)
        for i, item in enumerate(self.totalAdcBoxCalib):
            self.fineLayout.addWidget(item, 8, i+1)
        self.fineLayout.addItem(QtGui.QSpacerItem(10, 15), 8, 1)


        self.board_config.notify_all_observers()
        self.toggleExpert()
        self.toggleFMC2IndividualDelay()
        self.setWindowTitle(tr("Heading", "Timing"))


    def delay_observer(self, x):
        d330 = ['delay_330_th', 'delay_330_th']
        d25  = ['delay_25_th', 'delay_25_th']

        for i, item in enumerate(self.totalAdcBox):
            if self.board_config.is_KAPTURE2():
                string = '%i + %i + %i' % (self.board_config.get(d330[i//4])    * self.board_config.get('delay_330_factor'),
                                               self.board_config.get(d25[i//4])     * self.board_config.get('delay_25_factor'),
                                               (self.board_config.get('chip_delay')[i]) * self.board_config.get('chip_delay_factor'))
                if i < 4:
                    string += "+ {:d}".format(self.board_config.get("delay_330_th_2")    * self.board_config.get('delay_330_factor')
                                            + (self.board_config.get("delay_25_th_2")- self.board_config.get("default_25_th_2"))    * self.board_config.get('delay_25_factor'))
                item.setText(string)

                val = self.board_config.get(d25[i//4]) * self.board_config.get('delay_25_factor')+self.board_config.get('chip_delay')[i] * self.board_config.get('chip_delay_factor')
                if val == self.board_config.get('delay_330_factor'):
                    item.setStyleSheet("color: rgb(120, 80, 0);")
                elif val > self.board_config.get('delay_330_factor'):
                    item.setStyleSheet("color: rgb(200, 80, 0);")
                else:
                    item.setStyleSheet("color: rgb(0, 0, 0);")

            else:
                item.setText('%i  + %i' % (self.board_config.get('delay_330_th')  * self.board_config.get('delay_330_factor'),
                                           self.board_config.get('chip_delay')[i] * self.board_config.get('chip_delay_factor')))
        if self.board_config.is_KAPTURE2():
            for i, item in enumerate(self.totalAdcBoxCalib):

                #Calibration throws errors when opening the Timing Widget
                #without a calibration file existing. 
                #I am muting this error for now
                try:
                    value = theCalibration.calibrateX(i, self.board_config.get('delay_330_th'), self.board_config.get('delay_25_th'), self.board_config.get('chip_delay')[i], self.board_config.get("delay_25_th_2"))
                    item.setText('{}'.format(np.round(value*1e12,1)))
                except:
                    pass #TODO: Create an exception type for 'No Calibration File' and handle accordingly

            """
            if self.fileHandle is not None:
                for i, item in enumerate(self.totalAdcBoxCalib):
                    item.setText('{:.1f}'.format(self.board_config.get(d330[i//4]) * self.xcalib['d330'][()] + self.xcalib[str(i)]['33'][int(self.board_config.get(d330[i//4]))] +
                                                 self.board_config.get(d25[i//4])  * self.xcalib['d25'][()]  + self.xcalib[str(i)]['25'][int(self.board_config.get(d25[i//4]))]  +
                                                 self.board_config.get('chip_delay')[i]* self.xcalib['d3'][()]   + self.xcalib[str(i)]['3'][int(self.board_config.get('chip_delay')[i])] -
                                                 float(self.fileHandle['x'][str(i)]['offset'][()])*1e12
                                              ))
            else:
                for i, item in enumerate(self.totalAdcBoxCalib):
                    value = (self.board_config.get(d330[i//4])    * self.board_config.get('delay_330_factor')
                            + self.board_config.get(d25[i//4])   * self.board_config.get('delay_25_factor')
                            + (self.board_config.get('chip_delay')[i]) * self.board_config.get('chip_delay_factor'))
                    if i>=4:
                        value -= (self.board_config.get("delay_330_th_2")  * self.board_config.get('delay_330_factor')
                                 + self.board_config.get("delay_25_th_2") * self.board_config.get('delay_25_factor'))
                    item.setText(str(value))
            """

    def toggleExpert(self):
        if self.expertSwitch.checkState():
            self.labelFpgaDelay.setVisible(True)
            self.coarse330Fpga.setVisible(True)
            self.coarse25Fpga.setVisible(True)
            self.labelADCDelay.setVisible(True)
            self.coarse330Adc.setVisible(True)
            self.coarse25Adc.setVisible(True)
            if self.adc_number > 4:
                self.labelADCDelay_2.setVisible(True)
                self.coarse330Adc_2.setVisible(True)
                self.coarse25Adc_2.setVisible(True)
        else:
            self.labelFpgaDelay.setVisible(False)
            self.coarse330Fpga.setVisible(False)
            self.coarse25Fpga.setVisible(False)
            self.labelADCDelay.setVisible(False)
            self.coarse330Adc.setVisible(False)
            self.coarse25Adc.setVisible(False)
            if self.adc_number > 4:
                self.labelADCDelay_2.setVisible(False)
                self.coarse330Adc_2.setVisible(False)
                self.coarse25Adc_2.setVisible(False)


    def toggleFMC2IndividualDelay(self):
        """
        Toggle to use an individual delay for FMC2 or not
        :return: -
        """
        self.coarseInputTh_2.setEnabled(not self.linkTHSwitch.checkState())

        if self.linkTHSwitch.checkState():
            self.coarseInputTh_2.setValue(self.coarseInputTh.value())


    def linkFMCCoarseDelay(self, value):
        """
        Check if FMC2 is linked to FMC1 and replicate the value accordingly
        :value: The value from the FMC1 SpinBox Update
        :return: -
        """

        if self.linkTHSwitch.checkState():
            self.coarseInputTh_2.setValue(value)

        self.board_config.update("delay_330_th", value)


    def setValueSilent(self, element, value):
        """
        Set Values to inputs without notifying observers
        :param element: the input
        :param value: the value
        :return: -
        """
        element.blockSignals(True)
        element.setValue(value)
        element.blockSignals(False)


    def closeEvent(self, event):
        """
        Event handler when this window is closed
        """

        self.board_config.unobserve(self.totalAdcBox[0], 'chip_delay')
        if self.board_config.is_KAPTURE2():
            self.board_config.unobserve(self.totalAdcBox[0], 'delay_25_th')
            if self.adc_number > 4:
                self.board_config.unobserve(self.totalAdcBox[0], 'delay_330_th_2')
                self.board_config.unobserve(self.totalAdcBox[0], 'delay_25_th_2')

        self.board_config.unobserve(self.totalAdcBox[0], 'delay_330_th')

        for i, item in enumerate(self.fineAdcInput):
            self.board_config.unobserve(item, 'chip_delay')

        for i, item in enumerate(self.bunchShiftInput):
            self.board_config.unobserve(item,'bunch_shift')


        self.board_config.unobserve(self.coarseInputTh, 'delay_330_th')
        self.board_config.unobserve(self.coarse330Adc, 'delay_330_adc')
        self.board_config.unobserve(self.coarse330Fpga, 'delay_330_fpga')

        if self.board_config.is_KAPTURE2():
            self.board_config.unobserve(self.coarse2InputTh, 'delay_25_th')
            self.board_config.unobserve(self.coarse25Adc, 'delay_25_adc')
            self.board_config.unobserve(self.coarse25Fpga, 'delay_25_fpga')
            if self.adc_number > 4:
                self.board_config.unobserve(self.coarseInputTh_2, 'delay_330_th_2')
                self.board_config.unobserve(self.coarse330Adc_2, 'delay_330_adc_2')

                self.board_config.unobserve(self.coarse2InputTh_2, 'delay_25_th_2')
                self.board_config.unobserve(self.coarse25Adc_2, 'delay_25_adc_2')


        Elements.emptyGroup('timing_{}'.format(self.board_id))
        Elements.removeItem(None, self.fineAdcInput)
        Elements.removeItem(None, self.bunchShiftInput)
        Elements.removeItem(None, [
                                    self.coarseInputTh,
                                    #self.coarseInputAdc,
                                    #self.coarseInputFpga
                                  ]
                            )
        if self.board_config.is_KAPTURE2():
            Elements.removeItem(None, [
                                        self.coarse2InputTh,
                                        #self.coarse2InputAdc,
                                        #self.coarse2InputFpga
                                      ]
                                )
            if self.adc_number > 4:
                Elements.removeItem(None, [
                                            #self.coarseInputTh_2,
                                            #self.coarseInputAdc_2,
                                            #self.coarseInputFpga_2,
                                            self.linkTHSwitch,
                                            self.coarse2InputTh_2,
                                            #self.coarse2InputAdc_2,
                                            #self.coarse2InputFpga_2
                                          ]
                                    )



        super(TimingPart, self).closeEvent(event)

    def on_adc_delay_changed(self):
        """
        Handler that gets called when an adc delay gets changed
        """
        try:
            factors = []
            for item in self.fineAdcInput:
                factors.extend([item.value()])

            self.board_config.update('chip_delay', factors)
        except board.BoardError as e:
            logging.error("ADC fine delay failed: {}".format(str(e)))
            bif.bk_status_readout(self.board_id)
            return



    def on_bunch_shift_changed(self):
        """
        Handler that gets called when a bunch shift setting gets changed
        """
        try:
            factors = []
            for item in self.bunchShiftInput:
                #Bunch Shifts are encoded 0x0 - 0x4 in Hardware
                #but shown as -2 to +2 in GUI, so we need a +2 offset
                factors.extend([item.value()+2])

            self.board_config.update('bunch_shift', factors)
        except board.BoardError as e:
            logging.error("ADC bunch shift failed: {}".format(str(e)))
            bif.bk_status_readout(self.board_id)
            return




# 888   d8b             d8b                888       888d8b     888                888
# 888   Y8P             Y8P                888   o   888Y8P     888                888
# 888                                      888  d8b  888        888                888
# 88888888888888b.d88b. 88888888b.  .d88b. 888 d888b 888888 .d88888 .d88b.  .d88b. 888888
# 888   888888 "888 "88b888888 "88bd88P"88b888d88888b888888d88" 888d88P"88bd8P  Y8b888
# 888   888888  888  888888888  888888  88888888P Y88888888888  888888  88888888888888
# Y88b. 888888  888  888888888  888Y88b 8888888P   Y8888888Y88b 888Y88b 888Y8b.    Y88b.
#  "Y888888888  888  888888888  888 "Y88888888P     Y888888 "Y88888 "Y88888 "Y8888  "Y888
#                                       888                             888
#                                  Y8b d88P                        Y8b d88P
#                                   "Y88P"                          "Y88P"

class TimingWidget(kcgw.KCGWidgets):
    """
    This is the container that holds the tab widget which contains the timing widgets for each board
    """
    def __init__(self, unique_id, parent=None):
        super(TimingWidget, self).__init__()

        self.id = unique_id
        self.par = parent
        self.setWindowTitle("Timing")

        self.layout = QtGui.QHBoxLayout()
        self.setLayout(self.layout)
        self.widgets = {i: TimingPart(i, self) for i in available_boards}  # has to set parent with self because
                                            # otherwise the window does not get resized correctly upon enabling timescan

        if available_boards.multi_board:
            self.tabWidget = QtGui.QTabWidget()
            self.layout.addWidget(self.tabWidget)

            for id, widget in self.widgets.items():
                self.tabWidget.addTab(widget, available_boards.get_board_name_from_id(id))
        else:
            self.single_board_widget = list(self.widgets.values())[0]
            self.layout.addWidget(self.single_board_widget)

    def adjustSizeForTimeScan(self):
        """
        Adjust the size of the widget to accomodate the time_scan part
        :return:
        """
                # self.parentWindow = self.parent().parent().parent().parent()  # one up is stacked widget, second up is
                #                     tab widget, third up is timingWidget fourh up is KCGWSubWindow (the actual window)
        QtCore.QCoreApplication.processEvents()
        if self.parent().windowState() & QtCore.Qt.WindowMaximized:
            self.parent().setWindowState(QtCore.Qt.WindowMaximized)
        else:
            # self.parent().resize(self.minimumSizeHint().width() * 1.2, self.minimumSizeHint().height()*1.1)
            self.parent().adjustSize()

    def closeEvent(self, event):
        global __widget_id__
        __widget_id__ = None

        for widget in list(self.widgets.values()):
            widget.closeEvent(event)
        del self.par.widgets[self.id]
        super(TimingWidget, self).closeEvent(event)


def addTimingWidget():
    """
    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 = TimingWidget(nid, global_objects.get_global('area'))
        global_objects.get_global('area').newWidget(w, tr("Heading", "Timing"), nid, widget_type=4, minSize=True) #TODO: proper type

kcgw.register_widget(QtGui.QIcon(config.icon_path(config.timingIcon)), tr("Heading", "Timing"), addTimingWidget, "Ctrl+T")
kcgw.register_widget_creation_function(addTimingWidget)