Ulm-IQO / qudi

        name = self._pg.saved_ensembles_ComboBox.currentText()

        self._pulsed_master_logic.load_block_ensemble(name)

        return

    def editor_generate_sequence_clicked(self):

        name = self._sg.curr_sequence_name_LineEdit.text()

        if name == '':

            self.log.error('No name has been entered for the PulseSequence to be generated.')

            return

        rotating_frame = self._sg.curr_sequence_rot_frame_CheckBox.isChecked()

        sequence_object = self.sequence_editor.generate_sequence_object(name, rotating_frame)

        self._pulsed_master_logic.save_sequence(name, sequence_object)

        return

    def editor_delete_sequence_clicked(self):

        name = self._sg.saved_sequences_ComboBox.currentText()

        self._pulsed_master_logic.delete_sequence(name)

        return

    def editor_load_sequence_clicked(self):

        name = self._sg.saved_sequences_ComboBox.currentText()

        self._pulsed_master_logic.load_sequence(name)

        return

    def load_block_in_editor(self, block_obj):

        self.block_editor.load_pulse_block(block_obj)

        if block_obj is not None:

            self._pg.curr_block_name_LineEdit.setText(block_obj.name)

        return

    def load_ensemble_in_editor(self, ensemble_obj, ensemble_params):

        self.block_organizer.load_pulse_block_ensemble(ensemble_obj)

        if ensemble_params != {}:

            self._pg.curr_ensemble_length_DSpinBox.setValue(ensemble_params['sequence_length'])

            self._pg.curr_ensemble_bins_SpinBox.setValue(ensemble_params['sequence_length_bins'])

            # FIXME: This is just a rough estimation of the waveform size in MB (only valid for AWG)

            size_mb = (ensemble_params['sequence_length_bins'] * 5) / 1024**2

            self._pg.curr_ensemble_size_DSpinBox.setValue(size_mb)

            self._pg.curr_ensemble_laserpulses_SpinBox.setValue(ensemble_params['num_of_lasers'])

            self._pg.curr_ensemble_bins_SpinBox.setValue(ensemble_params['sequence_length_bins'])

            # FIXME: This is just a rough estimation of the waveform size in MB (only valid for AWG)

            size_mb = (ensemble_params['sequence_length_bins'] * 5) / 1024**2

            self._pg.curr_ensemble_size_DSpinBox.setValue(size_mb)

            self._pg.curr_ensemble_laserpulses_SpinBox.setValue(ensemble_params['num_of_lasers'])

        else:

            self._pg.curr_ensemble_length_DSpinBox.setValue(0.0)

            self._pg.curr_ensemble_bins_SpinBox.setValue(0)

            self._pg.curr_ensemble_size_DSpinBox.setValue(0.0)

            self._pg.curr_ensemble_laserpulses_SpinBox.setValue(0)

        if ensemble_obj is not None:

            self._pg.curr_ensemble_name_LineEdit.setText(ensemble_obj.name)

        return

    def load_sequence_in_editor(self, sequence_obj, sequence_params):

        self.sequence_editor.load_pulse_sequence(sequence_obj)

        if sequence_params != {}:

            self._sg.curr_sequence_length_DSpinBox.setValue(sequence_params['sequence_length'])

            self._sg.curr_sequence_bins_SpinBox.setValue(sequence_params['sequence_length_bins'])

            # FIXME: This is just a rough estimation of the sequence size in MB

            size_mb = (sequence_params['sequence_length_bins'] * 5) / 1024**2

            self._sg.curr_sequence_size_DSpinBox.setValue(size_mb)

        else:

            self._sg.curr_sequence_length_DSpinBox.setValue(0.0)

            self._sg.curr_sequence_bins_SpinBox.setValue(0)

            self._sg.curr_sequence_size_DSpinBox.setValue(0.0)

        if sequence_obj is not None:

            self._sg.curr_sequence_name_LineEdit.setText(sequence_obj.name)

        return

    def update_block_dict(self, block_dict):

        """

        @param block_dict:

        @return:

        """

        self.block_organizer.set_block_dict(block_dict)

        self._pg.saved_blocks_ComboBox.blockSignals(True)