KaptureControlGui/KCG/base/settings.py

from PyQt4 import QtGui, QtCore

import kcgwidget as kcgw
from .. import config

tr = kcgw.tr

class Settings(kcgw.KCGWidgets):
    """
    Settings Window
    """
    changed = QtCore.pyqtSignal(list)
    def __init__(self, storage_handler):
        """
        Initialise the Settings Window
        :param storage_handler: the container class used to store settings
        :return: -
        """
        super(Settings, self).__init__()
        self.storage_handler = storage_handler
        self.local_storage = []
        self.langlist = ["de_DE", "en_GB"]

        # --------[ Instance Objects ]-----------
        self.layout = QtGui.QVBoxLayout()
        self.grid = QtGui.QGridLayout()

        self.headerTick = self.build_new_setting(QtGui.QCheckBox(tr("Button", "Header")), 'header')
        self.subDirName = self.build_new_setting(self.createInput(self.storage_handler.subdirname, width=320), 'subdirname')
        self.dirName = self.build_new_setting(self.createInput(self.storage_handler.save_location, width=320), 'save_location')
        self.language = self.build_new_setting(QtGui.QComboBox(), 'language')
        self.advanced_control = self.build_new_setting(self.createCheckbox(tr("Label", "Enable Advanced Table View")), 'advanced_control')
        for lang in self.langlist:
            self.language.addItem(lang)
        self.local_storage.append(self.headerTick)
        self.applyButton = self.createButton(tr("Button", "Apply"), connect=self._apply)
        self.okButton = self.createButton(tr("Button", "OK"), connect=self._ok)
        self.cancelButton = self.createButton(tr("Button", "Cancel"), connect=self._cancel)
        # ------[ End Instance Objects ]--------

        # ------[ Apply Layout and read Settings ] ---------
        self.initUI()
        self._setSettings()
        # ------[ End Apply... ]----------------------------

        self.show()

    def initUI(self):
        """
        Initialise the UI
        """
        self.setLayout(self.layout)
        self.layout.addLayout(self.grid)

        self.headerTick.setToolTip(tr("Tooltip", "Save header in output file")) # TODO: better tooltip
        self.applyButton.setToolTip(tr("Tooltip", "Save settings"))
        self.okButton.setToolTip(tr("Tooltip", "Save settings and close settings-window"))
        self.cancelButton.setToolTip(tr("Tooltip", "Discard changes and close settings-window"))
        # self.grid.addWidget(self.createLabel("Settings"), 0, 0)
        self.grid.addWidget(self.headerTick, 0, 0)
        self.grid.addWidget(self.createLabel(tr("Label", "Subdirectory Name:")), 1, 0)
        self.grid.addWidget(self.subDirName, 1, 1)
        self.grid.addWidget(self.createLabel(tr("Label", "Save location:")), 2, 0)
        self.grid.addWidget(self.dirName, 2, 1)
        self.grid.addWidget(self.createLabel(tr("Label", "Language")), 3, 0)
        self.grid.addWidget(self.language, 3, 1)
        self.grid.addWidget(self.advanced_control, 4, 0)
        self.hbox = QtGui.QHBoxLayout()
        self.layout.addLayout(self.hbox)
        self.hbox.addStretch(1)
        self.hbox.addWidget(self.okButton)
        self.hbox.addWidget(self.applyButton)
        self.hbox.addWidget(self.cancelButton)
        self.setWindowTitle(tr("Heading", "KCG - Settings"))
        self.setWindowIcon(QtGui.QIcon(config.install_path + config.guiIcon))

    def build_new_setting(self, handle, value):
        """
        Build a new setting.
        This will add the setting to the local_storage.
        :param handle: the handle of the new setting (input field, checkbox etc)
        :param value: (str) key for this setting
        :return: the handle :)
        """
        self.local_storage.append(handle)
        self.local_storage[-1].setting_name = value
        return handle

    def _read_setting_from_object(self, object):
        """
        Get the value from a settings object
        :param object: the object to read the value from
        :return:
        """
        if type(object).__name__ == 'QCheckBox':
            return object.isChecked()
        if isinstance(object, QtGui.QLineEdit):
            return str(object.text())
        if isinstance(object, QtGui.QComboBox):
            return object.currentText()

    def _setSettings(self):
        """
        Set the values in the settings window to the current values
        :return:
        """
        self.headerTick.setChecked(self.storage_handler.header)
        self.subDirName.setText(self.storage_handler.subdirname)
        self.dirName.setText(self.storage_handler.save_location)
        self.language.setCurrentIndex(self.langlist.index(self.storage_handler.language))
        self.advanced_control.setChecked(self.storage_handler.advanced_control)

    def _apply(self):
        """
        Called when the apply button is pressed. It emits the changed signal if anything was changed
        """
        hasChanged = False
        changedSettings = []
        for object in self.local_storage:
            if self.storage_handler.__getattr__(object.setting_name) != self._read_setting_from_object(object):
                hasChanged = True
                self.storage_handler.__setattr__(object.setting_name, self._read_setting_from_object(object))
                changedSettings.append(object.setting_name)
        if hasChanged:
            self.changed.emit(changedSettings)

    def _ok(self):
        """
        Handler for the ok button. It calls _apply and close
        :return:
        """
        self._apply()
        self.close()

    def _cancel(self):
        """
        Handler for the cancel button. It calls close() and discards changed values
        :return:
        """
        self.close()

    def show(self):
        """
        Shows the window and sets the current values (calls _setSettings)
        :return:
        """
        self._setSettings()
        super(Settings, self).show()

    def keyPressEvent(self, QKeyEvent):
        """
        Reimplementation of the keyPressEvent of QWidget to close the window on ESC press.
        """
        if QKeyEvent.key() == QtCore.Qt.Key_Escape:
            self.close()