#! /usr/bin/env python3

from typing import Tuple
import gi, os, sys, gettext, re, zoneinfo, subprocess, datetime, time, locale

gi.require_version("Gtk", "3.0")

from gi.repository import Gtk as gtk, Gdk
# подключение переводчика
language_sys = locale.getdefaultlocale()[0]
language = ""
index = language_sys.find("_")
if index != -1:
    language = language_sys[0:index]
    if language == "ru":
        pass
    else:
        language = "en"
translate_en = gettext.translation(
    os.path.basename(__file__), "/usr/share/locale", fallback=True
)

translate_ru = gettext.translation(
    "ubconfig-gui", "/usr/share/locale", languages=[language]
)
translate_ru.install()
i18n = translate_ru.gettext

if language == "ru":
    i18n = translate_ru.gettext
else:
    i18n = translate_en.gettext


ubconfig_file = "/usr/bin/ubconfig"

# перезапуск от рута
if not os.geteuid() == 0:
    print(i18n("Attention: The script is started from the user, restart from root!"))
    os.execv("/usr/bin/pkexec", ["pkexec -W ignore"] + sys.argv)

configFile = {
    "CMDLINE": "",
    "DEFAULTPASSWD": "",
    "DEFAULTROOTPASSWD": "",
    "DEFAULTUSER": "",
    "NEEDEDUSERS": "",
    "ADDADM": "",
    "AUTOLOGINUSER": "",
    "USERGROUPS": "",
    "SERVICESSTART": "",
    "SERVICESNOSTART": "",
    "SERVICESMASK": "",
    "PARTITIONSAUTOMOUNT": "",
    "PARTITIONSNOMOUNT": "",
    "PARTITIONSMOUNTUID": "",
    "HOSTNAME": "",
    "MACHINEID": "",
    "UBLINUXSERVER": "",
    "NETWORKIP": "",
    "IPV6": "",
    "NTPSERVERS": "",
    "NSSWITCHAVAHI": "",
    "NSSWITCHWINBIND": "",
    "ADSERVER": "",
    "DOMAIN": "",
    "SAMBADOMAIN": "",
    "PUBLICDIR": "",
    "AUTOMOUNTSERVER": "",
    "PARTITIONSSHARE": "",
    "PARTITIONSNOSHARE": "",
    "ROUTER": "",
    "IPTABLESOPENPORTSTCP": "",
    "IPTABLESOPENPORTSUDP": "",
    "IPTABLESTRUSTEDIP": "",
    "TORUSERS": "",
    "MACCHANGE": "",
    "MACCHANGEROPTIONS": "",
    "MACCHANGEROPTIONS": "",
    "NUMLOCK": "",
    "GRAFFITI": "",
    "PRINTERADD": "",
    "FREEVGADRV": "",
    "DPMS": "",
    "FAILSAFENVIDIA": "",
    "FAILSAFEATI": "",
    "OPTIRUN": "",
    "PRIMUSRUN": "",
    "INTEGRATEDVGA": "",
    "MONITORPRIMARY": "",
    "MONITORLEFT": "",
    "MONITORRIGHT": "",
    "MONITORABOVE": "",
    "MONITORBELOW": "",
    "RUNLDCONFIG": "",
    "DEPMOD": "",
    "UPDATEHOME": "",
    "TMPFS": "",
    "VARTMPFS": "",
    "AUTOEXEC": "",
    "PULSEAUDIO": "",
    "ALSACARD": "",
    "ALSADEVICE": "",
    "UBLINUXUPDATE": "",
    "THEME": "",
    "BACKGROUND": "",
    "BACKGROUNDMODE": "",
    "SSAVERTHEME": "",
    "STEAMCONF": "",
    "STEAMAPP": "",
    "UTC": "",
    "ZONE": "",
    "XkbModel": "",
    "XkbLayout": "",
    "KEYBOARD": "",
    "KEYTABLE": "",
    "XkbOptions": "",
    "DESKTOP": "",
    "DISPLAYMANAGER": "",
    "DISPLAYMANAGER_DEFAULTUSER": "",
    "KDEVARTMP": "",
    "__GL_YIELD": "",
    "KWIN_TRIPLE_BUFFER": "",
    "CONTROL_HD_POWERMGMT": "",
    "server_ip": "",
    "ip": "",
    "RPCMOUNTD_OPTIONS": "",
    "STATD_OPTIONS": "",
    "socksParentProxy": "",
    "socksProxyType": "",
    "HTTP_PROXY": "",
    "HTTPS_PROXY": "",
    "FTP_PROXY": "",
    "NAME": "",
    "MODE": "",
    "TYPE": "",
    "BOOTPROTO": "",
    "DEFROUTE": "",
    "IPV6INIT": "",
    "ONBOOT": "",
    "PEERDNS": "",
    "PEERROUTES": "",
    "MAC_ADDRESS_RANDOMIZATION": "",
    "ESSID": "",
    "KEY_MGMT": "",
    "WPA_PSK": "",
    "DEVICE": "",
    "BOOTPROTO": "",
    "IPADDR": "",
    "HASHPASSWD": "",
    "NETMASK": "",
    "GATEWAY": "",
    "MII_NOT_SUPPORTED": "",
    "DNS1": "",
    "WIRELESS_ESSID": "",
    "WIRELESS_MODE": "",
    "WIRELESS_ESSID": "",
    "WIRELESS_CHANNEL": "",
    "driver": "",
    "ssid": "",
    "country_code": "",
    "hw_mode": "",
    "channel": "",
    "wpa_passphrase": "",
    "wpa": "",
    "LC_TELEPHONE": "",
    "LC_CTYPE": "",
    "LANGUAGE": "",
    "LC_MONETARY": "",
    "LC_ADDRESS": "",
    "LC_COLLATE": "",
    "LC_PAPER": "",
    "LC_NAME": "",
    "LC_NUMERIC": "",
    "SYSFONT": "",
    "LC_MEASUREMENT": "",
    "LC_TIME": "",
    "LANG": "",
    "LC_IDENTIFICATION": "",
    "LC_MESSAGES": "",
    "KEYMAP": "",
    "FONT": "",
    "Language": "",
    "Storage": "",
    "MKSQFS_OPTS": "",
    "MKSQFS_FASTALG": "",
    "DHCP_CLIENT": "",
    "NO_PROXY": "",
    "XORG_RES": "",
    "export __GL_YIELD": "",
    "export KWIN_TRIPLE_BUFFER": "",
}

headerVarsArr = {
    "THEME": "[/etc/ublinux/theme]",
    "BACKGROUND": "[/etc/ublinux/theme]",
    "BACKGROUNDMODE": "[/etc/ublinux/theme]",
    "SSAVERTHEME": "[/etc/ublinux/theme]",
    "STEAMCONF": "[/etc/ublinux/steam]",
    "STEAMAPP": "[/etc/ublinux/steam]",
    "UTC": "[/etc/ublinux/clock]",
    "ZONE": "[/etc/ublinux/clock]",
    "KEYBOARD": "[/etc/ublinux/keyboard]",
    "KEYTABLE": "[/etc/ublinux/keyboard]",
    "XkbOptions": "[/etc/ublinux/keyboard]",
    "DESKTOP": "[/etc/ublinux/desktop]",
    "DISPLAYMANAGER": "[/etc/ublinux/desktop]",
    "DISPLAYMANAGER_DEFAULTUSER": "[/etc/ublinux/desktop]",
    "KDEVARTMP": "[/etc/profile.d/ublinux.sh]",
    "CONTROL_HD_POWERMGMT": "[/etc/laptop-mode/laptop-mode.conf]",
    "server_ip": "[/etc/pdnsd.conf]",
    "ip": "[/etc/pdnsd.conf]",
    "RPCMOUNTD_OPTIONS": "[/etc/ublinux/nfs-server]",
    "STATD_OPTIONS": "[/etc/ublinux/nfs-common]",
    "socksParentProxy": "[/etc/polipo/config]",
    "socksProxyType": "[/etc/polipo/config]",
    "LC_TELEPHONE": "[/etc/locale.conf]",
    "LC_CTYPE": "[/etc/locale.conf]",
    "LANGUAGE": "[/etc/locale.conf]",
    "LC_MONETARY": "[/etc/locale.conf]",
    "LC_ADDRESS": "[/etc/locale.conf]",
    "LC_COLLATE": "[/etc/locale.conf]",
    "LC_PAPER": "[/etc/locale.conf]",
    "LC_NAME": "[/etc/locale.conf]",
    "LC_NUMERIC": "[/etc/locale.conf]",
    "SYSFONT": "[/etc/locale.conf]",
    "LC_MEASUREMENT": "[/etc/locale.conf]",
    "LC_TIME": "[/etc/locale.conf]",
    "LANG": "[/etc/locale.conf]",
    "LC_IDENTIFICATION": "[/etc/locale.conf]",
    "LC_MESSAGES": "[/etc/locale.conf]",
    "KEYMAP": "[/etc/vconsole.conf]",
    "FONT": "[/etc/vconsole.conf]",
    "Language": "[/usr/share/ublinux/kde4/share/config/kdm/kdmrc]",
    "export __GL_YIELD": "[/etc/profile.d/ublinux.sh]",
    "export KWIN_TRIPLE_BUFFER": "[/etc/profile.d/ublinux.sh]",
}

# дублирующий новый массив, для отслеживания изменений.
# нужен чтобы выводить лог-окно, где будет показанно, какие параметры изменились
configFileOld = dict(configFile)

argIniFile = ""
if len(sys.argv) > 1:
    argIniFile = sys.argv[1]


class Main:
    def __init__(self):
        self.domainNameOld=""
        self.cherk_itor = 0
        self.is_save_domain = False
        self.ubdomain_get()
        self.language_sys = locale.getdefaultlocale()
        gladeFile = "/usr/share/ubconfig-gui/ui/ubconfig-gui.glade"
        self.builder = gtk.Builder()
        self.builder.add_from_file(gladeFile)
        self.builder.connect_signals(self)

        provider = gtk.CssProvider()
        provider.load_from_path("/usr/share/ubconfig-gui/css/style.css")

        self.temp_height = 0
        self.temp_width = 0

        self.iniFile = (
            argIniFile if argIniFile else "/mnt/livemedia/ublinux-data/ublinux.ini"
        )
        self.osFile = "/usr/lib/ublinux/os-config"
        # тут можно указать путь до файла конфигурации и для файла с параметрами по умолчанию
        # чтобы тестироать на другом пк (не ломая ublinux)
        # 1. изменить путь
        # 2. закомментировть предыдущие 2 переменные
        # self.iniFile = "/home/hahafreshmeat/git/ublinux.ini"
        # self.osFile = "/home/hahafreshmeat/git/os-config"

        self.wndErrorMsgFile = self.builder.get_object("wndErrorMsgFile")
        self.lblErrorMsgFile = self.builder.get_object("lblErrorMsgFile")
        self.wndErrorMsgFile.connect("hide", gtk.main_quit)

        self.checkAplay = (
            True if subprocess.getstatusoutput("which aplay")[0] == 0 else False
        )
        self.checkSmbpasswd = (
            True
            if subprocess.getstatusoutput("command -v smbpasswd && exit 0 || exit 1")[0]
            == 0
            else False
        )

        if os.path.isfile(self.iniFile):

            self.read_config_file(configFile)
            self.read_config_file(configFileOld)

            self.servicesString = configFile["SERVICESSTART"]

            self.iniTextBuff = gtk.TextBuffer()
            with open(self.iniFile) as iniF:
                data = iniF.read()
            self.iniTextBuff.set_text(data)

            self.txtUblinuxIni = self.builder.get_object("txtUblinuxIni")
            self.txtUblinuxIni.set_buffer(self.iniTextBuff)

            self.imgUBLeft = self.builder.get_object("imgUBLeft")

            self.popCopy = self.builder.get_object("popCopy")
            self.popCalendar = self.builder.get_object("popCalendar")

            self.textCheckChanges = self.builder.get_object("textCheckChanges")
            self.changeBuffer = gtk.TextBuffer()

            self.btnSaveChanges = self.builder.get_object("btnSaveChanges")
            self.checkMkpasswd = False

            if subprocess.getstatusoutput("which mkpasswd")[0] == 0:
                strTypes = "{0}|{1}|{2}|{3}|{4}|{5}|{6}|{7}|{8}|{9}".format(
                    "bcrypt",
                    "bcrypt(obsolete)",
                    "scrypt",
                    "md5",
                    i18n("sha512 (Default)"),
                    "sha256",
                    "gost-yescrypt",
                    "yescrypt",
                    i18n("BSDI extended DES-based"),
                    i18n("Standard 56 bit DES-based"),
                )
                self.checkMkpasswd = True
            else:
                strTypes = "{0}|{1}|{2}|{3}|{4}".format(
                    "md5",
                    "md5(Apache variant)",
                    "AIX md5",
                    "sha256",
                    i18n("sha512 (Default)"),
                )

            self.cmdUsers = []

            ### Основные ###
            ### Система ###
            self.txtHostname = self.builder.get_object("txtHostname")
            self.cbxRandomid = self.builder.get_object("cbxRandomid")
            self.txtMachinieId = self.builder.get_object("txtMachinieId")
            self.txtUsers = self.builder.get_object("txtUsers")
            self.txtGroups = self.builder.get_object("txtGroups")
            self.cbxAdmin = self.builder.get_object("cbxAdmin")
            self.txtUser = self.builder.get_object("txtUser")
            self.txtPasswd = self.builder.get_object("txtPasswd")
            self.txtPasswd.props.caps_lock_warning = True
            self.cbxAutologin = self.builder.get_object("cbxAutologin")
            self.cbAutologinUser = self.builder.get_object("cbAutologinUser")
            self.cbxEnableHome = self.builder.get_object("cbxEnableHome")
            self.cbxTmp = self.builder.get_object("cbxTmp")
            self.cbxVarTmp = self.builder.get_object("cbxVarTmp")
            self.txtAutoexec = self.builder.get_object("txtAutoexec")
            self.lblHashingAlgPass = self.builder.get_object("lblHashingAlgPass")
            self.cbHashingAlgPass = self.builder.get_object("cbHashingAlgPass")
            self.listHashingAlgPass = self.builder.get_object("listHashingAlgPass")
            iterTypeHash = 0
            if strTypes:
                for i in strTypes.split("|"):
                    self.listHashingAlgPass.append([iterTypeHash, i])
                    iterTypeHash += 1
            self.cbHashingAlgPass.set_active(4)
            self.lblHashingAlgPassDes = self.builder.get_object("lblHashingAlgPassDes")
            self.cbHashingAlgPassDes = self.builder.get_object("cbHashingAlgPassDes")
            self.listPamCryptMethod = self.builder.get_object("listPamCryptMethod")
            ### Система ###

            ### Дата и Время ###
            self.listZone = self.builder.get_object("listZone")
            self.cbZone = self.builder.get_object("cbZone")
            self.listReg = gtk.ListStore(int, str)
            self.cbRegion = self.builder.get_object("cbRegion")
            self.cbxDhcp = self.builder.get_object("cbxDhcp")
            self.txtNtpServer = self.builder.get_object("txtNtpServer")
            ### Дата и Время ###

            ### Локализация ###
            self.cbLocale = self.builder.get_object("cbLocale")
            self.listLang = self.builder.get_object("listLang")
            ### Локализация ###

            ### Консоль ###
            self.cbKeymap = self.builder.get_object("cbKeymap")
            self.cbFontConsole = self.builder.get_object("cbFontConsole")
            self.cbNumLock = self.builder.get_object("cbNumLock")
            self.listKeymap = self.builder.get_object("listKeymap")
            self.listFont = self.builder.get_object("listFont")
            self.listNumlock = self.builder.get_object("listNumlock")
            ### Консоль ###

            ### Монтирование Дисков и Разделов ###
            self.cbxConnectAllPart = self.builder.get_object("cbxConnectAllPart")
            self.cbxDontConnectPart = self.builder.get_object("cbxDontConnectPart")
            self.txtDontConnectPart = self.builder.get_object("txtDontConnectPart")
            self.txtUserNtfsOwner = self.builder.get_object("txtUserNtfsOwner")
            self.btnEditUserNtfsOwner = self.builder.get_object("btnEditUserNtfsOwner")
            ### Монтирование Дисков и Разделов ###

            ### Обновление Системы ###
            self.cbAutoUpdateSys = self.builder.get_object("cbAutoUpdateSys")
            self.listUpdateSys = self.builder.get_object("listUpdateSys")
            ### Обновление Системы ###

            self.txtDomain = self.builder.get_object("txtDomain")
            self.lblDomain = self.builder.get_object("lblDomain")

            ### Модули Системы ###
            self.txtAlgCompressDef = self.builder.get_object("txtAlgCompressDef")
            self.txtAlgForSaveModul = self.builder.get_object("txtAlgForSaveModul")
            ### Модули Системы ###
            ### labels ###
            self.lblHostname = self.builder.get_object("lblHostname")
            self.lblMachinieId = self.builder.get_object("lblMachinieId")
            self.lblUsers = self.builder.get_object("lblUsers")
            self.lblGroups = self.builder.get_object("lblGroups")
            self.lblUserName = self.builder.get_object("lblUserName")
            self.lblPasswd = self.builder.get_object("lblPasswd")
            self.lblAutologin = self.builder.get_object("lblAutologin")
            self.lblUpdateHome = self.builder.get_object("lblUpdateHome")
            self.lblDisableTmpfs = self.builder.get_object("lblDisableTmpfs")
            self.lblAutoexec = self.builder.get_object("lblAutoexec")
            self.lblTimeZone = self.builder.get_object("lblTimeZone")
            self.lblNtpServer = self.builder.get_object("lblNtpServer")
            self.lblLanguage = self.builder.get_object("lblLanguage")
            self.lblKeymap = self.builder.get_object("lblKeymap")
            self.lblFontConsole = self.builder.get_object("lblFontConsole")
            self.lblNumLock = self.builder.get_object("lblNumLock")
            self.lblConnectAllPart = self.builder.get_object("lblConnectAllPart")
            self.lblDontConnectPart = self.builder.get_object("lblDontConnectPart")
            self.lblUserNtfsOwner = self.builder.get_object("lblUserNtfsOwner")
            self.lblAutoUpdateSys = self.builder.get_object("lblAutoUpdateSys")
            self.lblAlgCompressDef = self.builder.get_object("lblAlgCompressDef")
            self.lblAlgForSaveModul = self.builder.get_object("lblAlgForSaveModul")
            ### labels ###
            ### Основные ###

            ### Безопасность ###
            self.cbxBlockSystemCommands = self.builder.get_object(
                "cbxBlockSystemCommands"
            )
            self.cbxBlockConsoleForUsers = self.builder.get_object(
                "cbxBlockConsoleForUsers"
            )
            self.cbxBlockConsoleForGroup = self.builder.get_object(
                "cbxBlockConsoleForGroup"
            )
            self.cbxBlockInterpreters = self.builder.get_object("cbxBlockInterpreters")
            self.cbxBlockMacros = self.builder.get_object("cbxBlockMacros")
            self.cbxPreventExecutionBit = self.builder.get_object(
                "cbxPreventExecutionBit"
            )
            self.cbxApparmorMode = self.builder.get_object("cbxApparmorMode")
            self.cbxSELinuxMode = self.builder.get_object("cbxSELinuxMode")

            self.txtSystemCommands = self.builder.get_object("txtSystemCommands")
            self.txtSystemCommands.set_sensitive(False)

            self.txtConsoleForUsers = self.builder.get_object("txtConsoleForUsers")
            self.txtConsoleForUsers.set_sensitive(False)

            self.txtConsoleForGroup = self.builder.get_object("txtConsoleForGroup")
            self.txtConsoleForGroup.set_sensitive(False)

            self.txtInterpreters = self.builder.get_object("txtInterpreters")
            self.txtInterpreters.set_sensitive(False)
            ### Безопасность ###

            ### Службы ###
            self.treeViewServ = self.builder.get_object("treeViewServ")
            self.lblShowNameServ = self.builder.get_object("lblShowNameServ")
            self.lblShowDescServ = self.builder.get_object("lblShowDescServ")
            self.btnStartServ = self.builder.get_object("btnStartServ")
            self.btnStopServ = self.builder.get_object("btnStopServ")
            self.btnEnableServ = self.builder.get_object("btnEnableServ")
            self.btnDisableSev = self.builder.get_object("btnDisableSev")
            self.cbFilterServ = self.builder.get_object("cbFilterServ")
            self.txtSearchServ = self.builder.get_object("txtSearchServ")
            self.btnSearchServ = self.builder.get_object("btnSearchServ")
            self.lsitFilterServices = self.builder.get_object("lsitFilterServices")
            self.listAllServices = gtk.ListStore(str, str, str, str, str)
            ### Службы ###

            ### Сеть ###
            self.cbNetInterface = self.builder.get_object("cbNetInterface")

            ### настройка ###
            self.cbxAutoRun = self.builder.get_object("cbxAutoRun")
            self.txtAltDhcp = self.builder.get_object("txtAltDhcp")
            self.txtIpAdr = self.builder.get_object("txtIpAdr")
            self.txtMask = self.builder.get_object("txtMask")
            self.txtRout = self.builder.get_object("txtRout")
            self.cbMiiNotSupp = self.builder.get_object("cbMiiNotSupp")
            self.listMiiNotSupp = self.builder.get_object("listMiiNotSupp")
            self.txtDnsServ = self.builder.get_object("txtDnsServ")
            ### настройка ###

            ### Межсетевой экран ###
            self.txtExceptFireTcp = self.builder.get_object("txtExceptFireTcp")
            self.txtExeptFireUdp = self.builder.get_object("txtExeptFireUdp")
            self.txtTrustIp = self.builder.get_object("txtTrustIp")
            ### Межсетевой экран ###

            ### Порядок поиска DNS ###
            self.cbxAvahi = self.builder.get_object("cbxAvahi")
            self.cbxWinbind = self.builder.get_object("cbxWinbind")
            self.cbPrimDnsServ = self.builder.get_object("cbPrimDnsServ")
            self.txtPrimDnsServ = self.builder.get_object("txtPrimDnsServ")
            ### Порядок поиска DNS ###

            ### Дополнительно ###
            self.cbxIpV6 = self.builder.get_object("cbxIpV6")
            self.cbxRouteMode = self.builder.get_object("cbxRouteMode")
            self.cbxTraficTor = self.builder.get_object("cbxTraficTor")
            self.numTraficTorMin = self.builder.get_object("numTraficTorMin")
            self.numTraficTorMax = self.builder.get_object("numTraficTorMax")
            self.cbxAcceptNetGet = self.builder.get_object("cbxAcceptNetGet")
            ### Дополнительно ###

            ### Системные прокси ###
            self.cbxHttpProx = self.builder.get_object("cbxHttpProx")
            self.txtHttpProx = self.builder.get_object("txtHttpProx")
            self.cbxHttpsProx = self.builder.get_object("cbxHttpsProx")
            self.txtHttpsProx = self.builder.get_object("txtHttpsProx")
            self.cbxFtpProx = self.builder.get_object("cbxFtpProx")
            self.txtFtpProx = self.builder.get_object("txtFtpProx")
            self.cbxNoProx = self.builder.get_object("cbxNoProx")
            self.txtNoProx = self.builder.get_object("txtNoProx")
            self.cbxPolipoProx = self.builder.get_object("cbxPolipoProx")
            self.txtPolipoProx = self.builder.get_object("txtPolipoProx")
            self.cbPolipoProx = self.builder.get_object("cbPolipoProx")
            self.listPolipoProxy = self.builder.get_object("listPolipoProxy")
            ### Системные прокси ###
            ### labels ###
            self.lblNetInterface = self.builder.get_object("lblNetInterface")
            self.lblAutorunNet = self.builder.get_object("lblAutorunNet")
            self.lblAltDhcp = self.builder.get_object("lblAltDhcp")
            self.lblIpAdr = self.builder.get_object("lblIpAdr")
            self.lblMask = self.builder.get_object("lblMask")
            self.lblRout = self.builder.get_object("lblRout")
            self.lblMiiNotSupp = self.builder.get_object("lblMiiNotSupp")
            self.lblDnsServ = self.builder.get_object("lblDnsServ")
            self.lblExceptFireTcp = self.builder.get_object("lblExceptFireTcp")
            self.lblExeptFireUdp = self.builder.get_object("lblExeptFireUdp")
            self.lblTrustIp = self.builder.get_object("lblTrustIp")
            self.lblAvahi = self.builder.get_object("lblAvahi")
            self.lblWinbind = self.builder.get_object("lblWinbind")
            self.lblPrimDnsServ = self.builder.get_object("lblPrimDnsServ")
            self.lblIpV6 = self.builder.get_object("lblIpV6")
            self.lblRouteMode = self.builder.get_object("lblRouteMode")
            self.lblTraficTor = self.builder.get_object("lblTraficTor")
            self.lblAcceptNetGet = self.builder.get_object("lblAcceptNetGet")
            self.lblHttpProx = self.builder.get_object("lblHttpProx")
            self.lblHttpsProx = self.builder.get_object("lblHttpsProx")
            self.lblFtpProx = self.builder.get_object("lblFtpProx")
            self.lblNoProx = self.builder.get_object("lblNoProx")
            self.lblPolipoProx = self.builder.get_object("lblPolipoProx")
            ### labels ###
            ### Сеть ###

            ### Пользователи ###
            self.treeviewListUsers = self.builder.get_object("treeviewListUsers")
            self.listUserString = gtk.ListStore(int, str, str, str, str)

            self.txtUid = self.builder.get_object("txtUid")
            self.txtLogin = self.builder.get_object("txtLogin")
            self.txtPass = self.builder.get_object("txtPass")
            self.cbxDefPass = self.builder.get_object("cbxDefPass")
            self.txtUserName = self.builder.get_object("txtUserName")
            self.cbHashingAlgPass1 = self.builder.get_object("cbHashingAlgPass1")

            self.txtEditUid = self.builder.get_object("txtEditUid")
            self.txtEditUid.set_sensitive(False)
            self.txtEditLogin = self.builder.get_object("txtEditLogin")
            self.txtEditPass = self.builder.get_object("txtEditPass")
            self.cbxEditDefPass = self.builder.get_object("cbxEditDefPass")
            self.txtEditUserName = self.builder.get_object("txtEditUserName")
            self.cbHashingAlgPass2 = self.builder.get_object("cbHashingAlgPass2")

            self.cbxAddSambaUser = self.builder.get_object("cbxAddSambaUser")
            self.cbxEditSambaUser = self.builder.get_object("cbxEditSambaUser")
            self.cbxDelSambaUser = self.builder.get_object("cbxDelSambaUser")

            self.btnAddNewUser = self.builder.get_object("btnAddNewUser")
            self.btnEditNewUser = self.builder.get_object("btnEditNewUser")
            self.btnDelNewUser = self.builder.get_object("btnDelNewUser")
            ### Пользователи ###

            ### Рабочий стол ###
            ### Настройка окружения ###
            self.cbDe = self.builder.get_object("cbDe")
            self.listDe = self.builder.get_object("listDe")
            self.cbDm = self.builder.get_object("cbDm")
            self.listDm = self.builder.get_object("listDm")
            self.cbTheme = self.builder.get_object("cbTheme")
            self.listDeTheme = self.builder.get_object("listDeTheme")
            self.listUsers = self.builder.get_object("listUsers")
            self.lblDisplayUserDef = self.builder.get_object("lblDisplayUserDef")
            self.cbDisplayUserDef = self.builder.get_object("cbDisplayUserDef")
            ### Настройка окружения ###

            ### Заставка ###
            self.cbScreenSaverTheme = self.builder.get_object("cbScreenSaverTheme")
            self.listSsTheme = self.builder.get_object("listSsTheme")
            ### Заставка ###

            ### Обои ###
            self.cbSourceWallpaper = self.builder.get_object("cbSourceWallpaper")
            self.listTypeWallpapper = self.builder.get_object("listTypeWallpapper")
            self.btnClrWallpaper = self.builder.get_object("btnClrWallpaper")
            self.txtPathWallpaper = self.builder.get_object("txtPathWallpaper")
            self.btnPathWallpaperChoose = self.builder.get_object(
                "btnPathWallpaperChoose"
            )
            self.cbScaleWallpaper = self.builder.get_object("cbScaleWallpaper")
            self.listScaleWallpaper = self.builder.get_object("listScaleWallpaper")
            ### Обои ###
            ### labels ###
            self.lblDe = self.builder.get_object("lblDe")
            self.lblDm = self.builder.get_object("lblDm")
            self.lblTheme = self.builder.get_object("lblTheme")
            self.lblScreenSaverTheme = self.builder.get_object("lblScreenSaverTheme")
            self.lblSourceWallpaper = self.builder.get_object("lblSourceWallpaper")
            self.lblPathWallpaper = self.builder.get_object("lblPathWallpaper")
            self.lblScaleWallpaper = self.builder.get_object("lblScaleWallpaper")
            ### labels ###
            ### Рабочий стол ###

            ### Загрузчик ###
            self.listAspm = self.builder.get_object("listAspm")
            self.lblAspm = self.builder.get_object("lblAspm")
            self.cbAspm = self.builder.get_object("cbAspm")
            self.lblCmdline = self.builder.get_object("lblCmdline")
            self.txtCmdline = self.builder.get_object("txtCmdline")
            self.lblFixTouchpad = self.builder.get_object("lblFixTouchpad")
            self.cbFixTouchpad = self.builder.get_object("cbFixTouchpad")
            self.listFixTouchpad = self.builder.get_object("listFixTouchpad")
            ### Загрузчик ###

            ### Дата и Время ###
            self.cbxAutoDataTime = self.builder.get_object("cbxAutoDataTime")
            self.numTimeHrs = self.builder.get_object("numTimeHrs")
            self.numTimeMin = self.builder.get_object("numTimeMin")
            self.txtDate = self.builder.get_object("txtDate")
            self.btnChooseDate = self.builder.get_object("btnChooseDate")
            self.btnUpdateDate = self.builder.get_object("btnUpdateDate")
            self.cldrDate = self.builder.get_object("cldrDate")
            ### Дата и Время ###

            ### Оборудование ###
            self.cbxPropDriver = self.builder.get_object("cbxPropDriver")
            self.txtDriverFailsafeAmd = self.builder.get_object("txtDriverFailsafeAmd")
            self.txtDriverFailsafeNvidia = self.builder.get_object(
                "txtDriverFailsafeNvidia"
            )
            self.cbResolution = self.builder.get_object("cbResolution")
            self.listResolution = self.builder.get_object("listResolution")
            self.cbxDpms = self.builder.get_object("cbxDpms")
            self.cbNvidiaRun = self.builder.get_object("cbNvidiaRun")
            self.listWereRunProg = self.builder.get_object("listWereRunProg")
            self.txtNvidiaRun = self.builder.get_object("txtNvidiaRun")
            self.btnNvidiaRunChange = self.builder.get_object("btnNvidiaRunChange")
            self.cbxIgpu = self.builder.get_object("cbxIgpu")
            self.cbxFixCropFps = self.builder.get_object("cbxFixCropFps")
            self.cbFixCropFps = self.builder.get_object("cbFixCropFps")
            self.listFixFps = self.builder.get_object("listFixFps")
            self.cbxPulseAudio = self.builder.get_object("cbxPulseAudio")
            self.cbDeviceOutput = self.builder.get_object("cbDeviceOutput")
            self.cbDeviceOutput.set_sensitive(
                True
            ) if self.checkAplay else self.cbDeviceOutput.set_sensitive(False)
            self.cbPortOutput = self.builder.get_object("cbPortOutput")
            self.cbPortOutput.set_sensitive(
                True
            ) if self.checkAplay else self.cbPortOutput.set_sensitive(False)
            self.cbAddPrinter = self.builder.get_object("cbAddPrinter")
            self.listPrintAdd = self.builder.get_object("listPrintAdd")
            self.cbxParkingHead = self.builder.get_object("cbxParkingHead")
            self.listProg = gtk.ListStore(bool, str)
            self.treeViewProg = self.builder.get_object("treeViewProg")
            self.listAudioCards = gtk.ListStore(int, str)
            self.listAudioDevs = gtk.ListStore(int, str)
            ### labels ###
            self.lblPropDriver = self.builder.get_object("lblPropDriver")
            self.lblDriverFailsafeAmd = self.builder.get_object("lblDriverFailsafeAmd")
            self.lblDriverFailsafeNvidia = self.builder.get_object(
                "lblDriverFailsafeNvidia"
            )
            self.lblResolution = self.builder.get_object("lblResolution")
            self.lblDontTurnOffScreen = self.builder.get_object("lblDontTurnOffScreen")
            self.lblNvidiaRun = self.builder.get_object("lblNvidiaRun")
            self.lblIgpu = self.builder.get_object("lblIgpu")
            self.lblFixCropFps = self.builder.get_object("lblFixCropFps")
            self.lblPulseAudio = self.builder.get_object("lblPulseAudio")
            self.lblDeviceOutput = self.builder.get_object("lblDeviceOutput")
            self.lblPortOutput = self.builder.get_object("lblPortOutput")
            self.lblAddPrinter = self.builder.get_object("lblAddPrinter")
            self.lblParkingHead = self.builder.get_object("lblParkingHead")
            ### labels ###
            ### Оборудование ###

            self.fill_main_window_users(configFile)
            self.fill_main_window_general(configFile)
            self.fill_main_window_services(configFile)
            self.fill_main_window_network(configFile)
            self.fill_main_window_de(configFile)
            self.fill_main_window_grub(configFile)
            self.fill_main_window_date_time(configFile)
            self.fill_main_window_date_Devices(configFile)
            self.window = self.builder.get_object("mainWin")
            self.window.connect("delete-event", gtk.main_quit)

            self.lblErrorMsg = self.builder.get_object("lblErrorMsg")
            self.btnErrorMsg = self.builder.get_object("btnErrorMsg")
            btnClose = self.builder.get_object("btnClose")
            btnClose.connect("clicked", gtk.main_quit)

            self.wndEditGrp = self.builder.get_object("wndEditGrp")
            self.wndErrorMsg = self.builder.get_object("wndErrorMsg")
            self.wndChooseUser = self.builder.get_object("wndChooseUser")
            self.wndCheckChanges = self.builder.get_object("wndCheckChanges")
            self.wndChooseDirWallpaper = self.builder.get_object(
                "wndChooseDirWallpaper"
            )
            self.wndEditPrograms = self.builder.get_object("wndEditPrograms")
            self.popAdditionMenuSettings = self.builder.get_object(
                "popAdditionMenuSettings"
            )
            
            
            
            self.wndAbout = self.builder.get_object("wndAbout")
            self.wndDelProfUser = self.builder.get_object("wndDelProfUser")
            self.wndAddUser = self.builder.get_object("wndAddUser")
            self.wndEditUser = self.builder.get_object("wndEditUser")
            self.wndAbout.connect("delete-event", self.on_destroy)
            self.wndErrorMsg.connect("delete-event", self.on_destroy)
            self.wndDelProfUser.connect("delete-event", self.on_destroy)
            



            self.btnBox = self.builder.get_object("btnBox")
            self.btnBox.set_visible(False)

            self.imgUBLeft.set_from_file(
                "/usr/share/ubconfig-gui/images/side_img_ubc_v_light.png"
            )

            gtk.StyleContext.add_provider_for_screen(
                Gdk.Screen.get_default(),
                provider,
                gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
            )

            self.window.maximize()
            self.window.show()
        else:
            self.wndErrorMsgFile.set_title(i18n("Error!"))
            errorMsg = i18n("Ublinux.ini not found!")
            self.lblErrorMsgFile.set_label(errorMsg)
            self.wndErrorMsgFile.set_transient_for(self.window)
            
            self.wndErrorMsgFile.show()

    def accept_lat_and_dash(self, editable):
        if re.search(r"[^a-zA-Z0-9\-_]", editable.get_chars(0, -1)):
            editable.set_text(editable.get_chars(0, -1)[:-1])

    def check_badnames_user(self, editable):
        if re.search(r"[^a-zA-Z0-9\-_]", editable.get_chars(0, -1)):
            editable.set_text(editable.get_chars(0, -1)[:-1])

    def show_pass(self, entry, icon_pos, event):
        entry.props.visibility = not entry.props.visibility
        if entry.get_icon_name(icon_pos) == "show_pass_icon":
            entry.set_icon_from_icon_name(icon_pos, "hide_pass_icon")
            entry.set_icon_tooltip_text(icon_pos, i18n("Show password"))
        else:
            entry.set_icon_from_icon_name(icon_pos, "show_pass_icon")
            entry.set_icon_tooltip_text(icon_pos, i18n("Hide password"))

    def combo_scrolling(self, combobox, event):
        """Prevent the comboboxes from scrolling."""

        combobox.emit_stop_by_name("scroll-event")

    def on_destroy(self, widget, *data):
        widget.hide()
        return True

    def show_add_menu(self, button):
        self.popAdditionMenuSettings.show()

    def show_about(self, button):
        self.wndAbout.show()
        self.popAdditionMenuSettings.hide()

    # Парсер конфига
    # Читает два файла - ublinux.ini и os-config
    # Если значение не находится в ublinux.ini -> ищет его в os-config
    # Если его нет в os-config -> оставить поле пустым
    def read_config_file(self, array_config):
        with open(self.iniFile) as confFile:
            confData = confFile.read()

        if os.path.isfile(self.osFile):
            with open(self.osFile) as confFile:
                confDefData = confFile.read()

        for key in array_config:
            txt = re.search(r"\n{}=.*".format(key), confData)
            if txt:
                array_config[key] = re.sub(r"\n{}=".format(key), "", txt.group(0))
            else:
                array_config[key] = ""

    # Функция записи измененных переменных в конфиг-файл
    # Читает ublinux.ini, ищет в нем нужные поля по ключам
    # Старое поле - комментирует и под ним прописывает новое с новым значением
    # Если такого поля нет - вносить его в начало файла
    # ЕСли поле есть, но неактивно (закомментированно) - Прописать по ним
    def write_config_file(self, array_config):
        hdrName = ""
        rgxHdrName = ""
        with open(self.iniFile) as confFile:
            confData = confFile.read()
            confDataOld = confFile.read()

        for key in array_config:
            txt = re.search(r"\n{}=.*".format(key), confData)
            if txt:
                if (
                    not array_config[key]
                    or array_config[key] == "''"
                    or array_config[key] == '""'
                ):
                    newStr = "\n#{0}={1}".format(key, "")
                    tmpTxt = re.search(r"\n#{}=.*".format(key), confData)
                    if tmpTxt:
                        # hdrName = self.get_header_var_name(key)
                        # if hdrName:
                        #     rgxHdrName = re.sub(r'\[', '\[', hdrName)
                        #     rgxHdrName = re.sub(r'\]', '\]', rgxHdrName)
                        #     confData = re.sub(r'\n{}'.format(rgxHdrName), '\n#{}'.format(hdrName), confData)
                        confData = re.sub(r"\n{}=.*".format(key), "", confData, count=1)
                    else:
                        # hdrName = self.get_header_var_name(key)
                        # if hdrName:
                        #     rgxHdrName = re.sub(r'\[', '\[', hdrName)
                        #     rgxHdrName = re.sub(r'\]', '\]', rgxHdrName)
                        #     confData = re.sub(r'\n{}'.format(rgxHdrName), '\n#{}'.format(hdrName), confData)
                        confData = re.sub(
                            r"\n{}=.*".format(key), newStr, confData, count=1
                        )
                elif array_config[key] and array_config[key] != re.sub(
                    r"\n{}=".format(key), "", txt.group(0)
                ):
                    if re.search(r"\n#{}=.*".format(key), confData):
                        newStr = "\n#{0}={1}".format(
                            key, re.sub(r"\n{}=".format(key), "", txt.group(0))
                        )
                        confData = re.sub(
                            r"\n#{}=.*".format(key), newStr, confData, count=1
                        )
                        newStr = "\n{0}={1}".format(key, array_config[key])
                        confData = re.sub(
                            r"\n{}=.*".format(key), newStr, confData, count=1
                        )
                    else:
                        newStr = "\n#{0}={1}\n{2}={3}".format(
                            key,
                            re.sub(r"\n{}=".format(key), "", txt.group(0)),
                            key,
                            array_config[key],
                        )
                        confData = re.sub(
                            r"\n{}=.*".format(key), newStr, confData, count=1
                        )
            else:
                txt = re.search(r"\n#{}=.*".format(key), confData)
                if txt:
                    if array_config[
                        key
                    ]:  # and array_config[key] != re.sub(r'\n#{}='.format(key), '', txt.group(0)):
                        hdrName = self.get_header_var_name(key)
                        if hdrName:
                            rgxHdrName = re.sub(r"\[", "\[", hdrName)
                            rgxHdrName = re.sub(r"\]", "\]", rgxHdrName)
                            confData = re.sub(
                                r"#{0}".format(rgxHdrName), hdrName, confData
                            )
                        newStr = "\n#{0}={1}\n{2}={3}".format(
                            key,
                            re.sub(r"\n#{}=".format(key), "", txt.group(0)),
                            key,
                            array_config[key],
                        )
                        confData = re.sub(
                            r"\n#{}=.*".format(key), newStr, confData, count=1
                        )
                else:
                    if array_config[key]:
                        txt = re.search(r"#?\[.*\][0-9a-z+\[\].\ ]*\n", confData)
                        if txt:
                            hdrName = re.sub(r"\[", "\[", txt.group(0))
                            hdrName = re.sub(r"\]", "\]", hdrName)
                            newstr = "\n{0}={1}\n\n{2}".format(
                                key, array_config[key], txt.group(0)
                            )
                            confData = re.sub(hdrName, newstr, confData, count=1)
                        else:
                            confData = "\n{0}={1}\n{2}".format(
                                key, array_config[key], confData
                            )

        with open(self.iniFile, "w") as confFile:
            confFile.write(confData)

        with open(self.iniFile) as confFile:
            confDataNew = confFile.read()

        status = subprocess.getstatusoutput(f"su root -c {ubconfig_file}")

        if confDataNew == confDataOld and status[0] != 0:
            self.wndErrorMsg.set_title(i18n("Error!"))
            self.lblErrorMsg.set_text(i18n("Save error"))
            self.btnErrorMsg.set_label(i18n("OK"))
            self.wndErrorMsg.set_transient_for(self.wndCheckChanges)
            self.wndErrorMsg.show()
        else:
            self.wndErrorMsg.set_title(i18n("Complete"))
            self.lblErrorMsg.set_text(i18n("Save completed"))
            self.btnErrorMsg.set_label(i18n("OK"))
            self.wndErrorMsg.set_transient_for(self.wndCheckChanges)
            self.wndErrorMsg.show()

        self.write_pass_sha()
    
    def change_domain(self, editable):
        
        if str(editable.get_chars(0, -1)) != self.domainNameOld:
            labelText = "<b><i>{}</i></b>".format(i18n("Domain name:"))
            self.is_save_domain = True
        else:
            labelText = i18n("Domain name:")
        self.lblDomain.set_markup(labelText)


    def domain_data(self):
        domain1111 = str(self.txtDomain.get_text())
        cmd=f"/usr/bin/ubconfig set network DOMAIN={domain1111}"
        os.system(cmd)
        labelText = i18n("Domain name:")
        self.lblDomain.set_markup(labelText)
        
        self.domainNameOld = domain1111
        self.ubdomain_get()


        

        

    def write_pass_sha(self):
        isWrite = False
        confData = ""
        listFileSplit = []
        with open("/etc/shadow") as confFile:
            confData = confFile.read()
            listFileSplit = confData.split("\n")
            for index, strPasswd in enumerate(listFileSplit):
                indexStart = strPasswd.find(":!:")
                if indexStart != -1:
                    if strPasswd.find("::::::") == -1:
                        strStart = strPasswd[0 : indexStart + 1]
                        strEnd = strPasswd[indexStart + 2 : len(strPasswd)]
                        passwdSha = configFile["DEFAULTPASSWD"]
                        passwdSha = passwdSha[1:-1]
                        strFinal = f"{strStart}{passwdSha}{strEnd}"
                        listFileSplit[index] = strFinal
                        isWrite = True
        if isWrite:
            with open("/etc/shadow", "w") as confFile:
                confFile.write("\n".join(listFileSplit))

    def findAll(self, str1, sub):
        start = 0
        listStr = []
        exitFlag = True
        while exitFlag:
            start = str1.find(sub, start)
            if start == -1:
                exitFlag = False
            else:
                listStr.append(start)
            start += len(sub)
        return listStr

    def get_header_var_name(self, key):
        arrSet = set(headerVarsArr)
        if key in arrSet:
            return headerVarsArr[key]
        else:
            return None

    # Закрыть окно с ошибкой
    def hide_error_msg(self, window):
        self.wndErrorMsg.hide()

    def hide_error_msg_file(self, window):
        self.wndErrorMsgFile.hide()

    def hide_check_msg(self, window):
        for i in configFile:
            configFile[i] = configFileOld[i]
        self.wndCheckChanges.hide()

    # Открыть конфигурационный файл
    def open_ini_file(self, button):
        cmdStr = f"gedit {self.iniFile} > /dev/null 2>&1 &"
        errorCode = subprocess.getstatusoutput(cmdStr)
        if int(errorCode[0]) != 0:
            self.wndErrorMsg.set_title(i18n("Error!"))
            errorMsg = str(i18n("Open file error")) + "\n\n" + errorCode[1]
            self.lblErrorMsg.set_label(errorMsg)
            self.wndErrorMsg.set_transient_for(self.window)
            self.wndErrorMsg.show()

    def ubdomain_get(self):
        domian = str(subprocess.getstatusoutput("/usr/bin/ubconfig get network DOMAIN")[1])
        if domian != "(null)":
            domian = domian.split("=")[1]
            self.domainNameOld = domian
        else:
            self.domainNameOld = ""
    ### Основные ###
    # Функция для вывода значений в нужные поля во вкладке "Основные"
    def fill_main_window_general(self, array_config):
        #self.ubdomain_get()
        self.txtDomain.set_text(self.domainNameOld)
        renderer = gtk.CellRendererText()

        ### Система ###
        self.txtHostname.set_text(array_config["HOSTNAME"]) if array_config[
            "HOSTNAME"
        ] else None
        if array_config["MACHINEID"] and array_config["MACHINEID"] == "RANDOM":
            self.cbxRandomid.set_active(True)
            self.txtMachinieId.set_sensitive(False)
        elif array_config["MACHINEID"] and array_config["MACHINEID"] != "RANDOM":
            self.cbxRandomid.set_active(False)
            self.txtMachinieId.set_sensitive(True)
            self.txtMachinieId.set_text(array_config["MACHINEID"]) if array_config[
                "MACHINEID"
            ] else None

        self.txtGroups.set_text(array_config["USERGROUPS"]) if array_config[
            "USERGROUPS"
        ] else None
        self.txtGroups.set_editable(False)
        self.txtUser.set_text(array_config["DEFAULTUSER"]) if array_config[
            "DEFAULTUSER"
        ] else None
        self.txtUser.set_sensitive(False)

        if array_config["NEEDEDUSERS"]:
            for i in str(array_config["NEEDEDUSERS"][1:-1]).split(","):
                if int(i.split(":")[1]) == 1000:
                    self.txtUser.set_text(i.split(":")[0])

        self.cbxAdmin.set_active(True) if array_config[
            "ADDADM"
        ] == "yes" else self.cbxAdmin.set_active(False)
        nameUsers = (
            array_config["NEEDEDUSERS"][1:-1].split(",")
            if array_config["NEEDEDUSERS"]
            else None
        )

        if nameUsers:
            iterUser = 0
            userList = gtk.ListStore(int, str)
            for name in nameUsers:
                userList.append([iterUser, name.split(":")[0]])
                iterUser += 1

            self.cbAutologinUser.set_model(userList)

            self.cbAutologinUser.pack_start(renderer, True)
            self.cbAutologinUser.add_attribute(renderer, "text", 1)

        if array_config["AUTOLOGINUSER"] and array_config["AUTOLOGINUSER"] != "none":
            self.cbxAutologin.set_active(True)
            for user in userList:
                if user[1] == array_config["AUTOLOGINUSER"]:
                    self.cbAutologinUser.set_active(user[0])
                    break
        elif array_config["AUTOLOGINUSER"] and array_config["AUTOLOGINUSER"] == "none":
            self.cbxAutologin.set_active(False)
            self.cbAutologinUser.set_active(0)

        self.cbxEnableHome.set_active(array_config["UPDATEHOME"] == "yes")
        self.cbxTmp.set_active(array_config["TMPFS"] == "yes")
        self.cbxVarTmp.set_active(array_config["VARTMPFS"] == "yes")
        self.txtAutoexec.set_text(array_config["AUTOEXEC"][1:-1]) if array_config[
            "AUTOEXEC"
        ] else None

        self.cbHashingAlgPass.pack_start(renderer, True)
        self.cbHashingAlgPass.add_attribute(renderer, "text", 1)

        self.cbHashingAlgPassDes.pack_start(renderer, True)
        self.cbHashingAlgPassDes.add_attribute(renderer, "text", 1)
        if configFile["HASHPASSWD"]:
            for mthd in self.listPamCryptMethod:
                if mthd[1] == array_config["HASHPASSWD"]:
                    self.cbHashingAlgPassDes.set_active(mthd[0])
        else:
            self.cbHashingAlgPassDes.set_active(0)
        # if not array_config['HASHPASSWD']:
        #     self.cbHashingAlgPassDes.set_active(7)
        ### Система ###

        ### Дата и время ###
        self.cbZone.set_model(self.listZone)
        self.cbZone.pack_start(renderer, True)
        self.cbZone.add_attribute(renderer, "text", 1)
        zone = array_config["ZONE"].split("/")[0] if array_config["ZONE"] else None
        reg = array_config["ZONE"].split("/")[1] if array_config["ZONE"] else None

        if zone and reg:
            for zones in self.listZone:
                if zones[1] == zone:
                    self.cbZone.set_active(zones[0])
            for regs in self.listReg:
                if regs[1] == reg[10:]:
                    self.cbRegion.set_active(regs[0])
        else:
            pass
            # self.cbZone.set_active(0)
            # self.cbRegion.set_sensitive(False)

        if array_config["NTPSERVERS"] and array_config["NTPSERVERS"] == "dhcp":
            self.cbxDhcp.set_active(True)
            self.txtNtpServer.set_text("")
            self.txtNtpServer.set_sensitive(False)
        elif array_config["NTPSERVERS"] and array_config["NTPSERVERS"] != "dhcp":
            self.cbxDhcp.set_active(False)
            self.txtNtpServer.set_text(array_config["NTPSERVERS"])
            self.txtNtpServer.set_sensitive(True)
        ### Дата и время ###

        ### Локализация ###
        for s in self.listLang:
            s[1] = i18n(s[1])

        self.cbLocale.pack_start(renderer, True)
        self.cbLocale.add_attribute(renderer, "text", 1)

        if array_config["LANG"] and array_config["LANG"] == "en_US.UTF-8":
            self.cbLocale.set_active(2)
        elif array_config["LANG"] and array_config["LANG"] == "ru_RU.UTF-8":
            self.cbLocale.set_active(1)
        else:
            self.cbLocale.set_active(0)
        ### Локализация ###

        ### Консоль ###
        for text in self.listKeymap:
            text[1] = i18n(text[1])

        for text in self.listNumlock:
            text[1] = i18n(text[1])

        self.cbKeymap.pack_start(renderer, True)
        self.cbKeymap.add_attribute(renderer, "text", 1)

        self.cbFontConsole.pack_start(renderer, True)
        self.cbFontConsole.add_attribute(renderer, "text", 1)

        self.cbNumLock.pack_start(renderer, True)
        self.cbNumLock.add_attribute(renderer, "text", 1)

        if array_config["KEYMAP"] and array_config["KEYMAP"] == "ru":
            self.cbKeymap.set_active(2)
        elif array_config["KEYMAP"] and array_config["KEYMAP"] == "en":
            self.cbKeymap.set_active(1)
        else:
            self.cbKeymap.set_active(0)

        if array_config["FONT"] and array_config["FONT"] == "lat0-16":
            self.cbFontConsole.set_active(1)
        elif array_config["FONT"] and array_config["FONT"] == "cyr-sun16":
            self.cbFontConsole.set_active(2)
        else:
            self.cbFontConsole.set_active(0)

        if array_config["NUMLOCK"] and array_config["NUMLOCK"] == "no":
            self.cbNumLock.set_active(2)
        elif array_config["NUMLOCK"] and array_config["NUMLOCK"] == "yes":
            self.cbNumLock.set_active(1)
        else:
            self.cbNumLock.set_active(0)
        ### Консоль ###

        ### Монтирование Дисков и Разделов ###
        self.cbxConnectAllPart.set_active(True) if array_config[
            "PARTITIONSAUTOMOUNT"
        ] and array_config[
            "PARTITIONSAUTOMOUNT"
        ] == "yes" else self.cbxConnectAllPart.set_active(
            False
        )
        self.cbxDontConnectPart.set_active(True) if array_config[
            "PARTITIONSNOMOUNT"
        ] else self.cbxDontConnectPart.set_active(False)
        self.txtDontConnectPart.set_text(
            array_config["PARTITIONSNOMOUNT"]
        ) if array_config["PARTITIONSNOMOUNT"] else None
        self.txtUser.set_sensitive(False)
        partUser = (
            array_config["PARTITIONSMOUNTUID"]
            if array_config["PARTITIONSMOUNTUID"]
            else None
        )
        partUserName = ""
        if partUser:
            with open("/etc/passwd") as fPasswd:
                for line in fPasswd:
                    if "x:" + partUser in line:
                        partUserName = re.sub(r"\n", "", line.split(":")[0])
            if partUserName:
                self.txtUserNtfsOwner.set_text(partUserName)
        self.txtUserNtfsOwner.set_sensitive(False)
        ### Монтирование Дисков и Разделов ###

        ### Обновление Системы ###
        for s in self.listUpdateSys:
            s[1] = i18n(s[1])
        self.cbAutoUpdateSys.pack_start(renderer, True)
        self.cbAutoUpdateSys.add_attribute(renderer, "text", 1)

        if array_config["UBLINUXUPDATE"] and array_config["UBLINUXUPDATE"] == "auto":
            self.cbAutoUpdateSys.set_active(1)
        elif array_config["UBLINUXUPDATE"] and array_config["UBLINUXUPDATE"] == "ask":
            self.cbAutoUpdateSys.set_active(2)
        elif array_config["UBLINUXUPDATE"] and array_config["UBLINUXUPDATE"] == "never":
            self.cbAutoUpdateSys.set_active(3)
        else:
            self.cbAutoUpdateSys.set_active(0)
        ### Обновление Системы ###

        ### Модули Системы ###
        self.txtAlgCompressDef.set_text(
            array_config["MKSQFS_OPTS"][1:-1]
        ) if array_config["MKSQFS_OPTS"] else None
        self.txtAlgForSaveModul.set_text(
            array_config["MKSQFS_FASTALG"][1:-1]
        ) if array_config["MKSQFS_FASTALG"] else None
        ### Модули Системы ###

    # Функция choose_zone_to_reg предназначена для
    # вывода регионов, в зависимости от выбранной зоны
    def choose_zone_to_reg(self, combo):
        fmtOffset = "(UTC %z)"
        descUtc = ""

        self.listReg.clear()
        self.cbRegion.clear()
        region = []
        region.clear() if region else None
        tree_iter = combo.get_active_iter()
        if tree_iter is not None:
            model = combo.get_model()
            country = model[tree_iter][1]

            if model[tree_iter][0] != 0:
                timeZone = zoneinfo.available_timezones()
                iterReg = 0
                for zoneReg in timeZone:
                    if len(zoneReg.split("/")) > 1 and zoneReg.split("/")[0] == country:
                        timezone = datetime.datetime.now(zoneinfo.ZoneInfo(zoneReg))
                        descUtc = re.sub(
                            r"[0-9][0-9]\)$", ")", timezone.strftime(fmtOffset)
                        )

                        region.append("{0} {1}".format(descUtc, zoneReg.split("/")[1]))

                region = list(set(region))
                region.sort(key=lambda x: int(x[5:8]))

                for s in region:
                    s = re.sub(r"_", " ", s)
                    self.listReg.append([iterReg, s])
                    iterReg += 1
                self.cbRegion.set_model(self.listReg)
                rendererReg = gtk.CellRendererText()
                self.cbRegion.pack_start(rendererReg, True)
                self.cbRegion.add_attribute(rendererReg, "text", 1)
                self.cbRegion.set_sensitive(True)

                region_cfg = configFile["ZONE"].split("/")[1]
                for index, region in enumerate(self.listReg):
                    region_str = region[1].split(")")[1]
                    region_str = region_str[1 : len(region_str)]
                    if region_str == region_cfg:
                        self.cbRegion.set_active(index)

            else:
                self.currDateY = datetime.datetime.now().year
                self.currDateM = datetime.datetime.now().month
                self.currDateD = datetime.datetime.now().day
                self.currTimeH = datetime.datetime.now().hour
                self.currTimeM = datetime.datetime.now().minute

                self.currDateMWithZero = (
                    "0" + str(self.currDateM)
                    if len(str(self.currDateM)) == 1
                    else str(self.currDateM)
                )
                self.currDateDWithZero = (
                    "0" + str(self.currDateD)
                    if len(str(self.currDateD)) == 1
                    else str(self.currDateD)
                )

                # если все окей, обновить параметры
                self.numTimeHrs.set_value(self.currTimeH)
                self.numTimeMin.set_value(self.currTimeM)
                self.txtDate.set_text(
                    self.currDateDWithZero
                    + "."
                    + self.currDateMWithZero
                    + "."
                    + str(self.currDateY)
                )
                # self.cbRegion.set_sensitive(False)
                self.cbRegion.clear()

    def change_time_from_timezone(self, combo):
        fmtTime = "%H:%M"
        fmtDate = "%Y-%m-%d"

        iterReg = self.cbZone.get_active_iter()
        if iterReg:
            modelReg = self.cbZone.get_model()
            if modelReg[iterReg][0] != 0:
                iterZone = combo.get_active_iter()
                if iterZone:
                    modelZone = combo.get_model()

                    zoneReg = modelReg[iterReg][1] + "/" + modelZone[iterZone][1][10:]
                    timezone = datetime.datetime.now(zoneinfo.ZoneInfo(zoneReg))
                    dateStr = str(timezone.strftime(fmtDate))
                    timeStr = str(timezone.strftime(fmtTime))
                    self.numTimeHrs.set_value(int(timeStr.split(":")[0]))
                    self.numTimeMin.set_value(int(timeStr.split(":")[1]))
                    self.txtDate.set_text(
                        dateStr.split("-")[2]
                        + "."
                        + dateStr.split("-")[1]
                        + "."
                        + dateStr.split("-")[0]
                    )

    # Функция toggle_rand_machine_id предназначна для
    # вывода machineID, при выборе "Случайное ID"
    def toggle_rand_machine_id(self, button):
        if button.get_active():
            self.cbxRandomid.set_active(True)
            self.txtMachinieId.set_sensitive(False)
            with open("/etc/machine-id") as f:
                mchnId = f.read()
            self.txtMachinieId.set_text(mchnId[:-1])
        else:
            self.cbxRandomid.set_active(False)
            self.txtMachinieId.set_sensitive(True)
            self.txtMachinieId.set_text(configFile["MACHINEID"]) if configFile[
                "MACHINEID"
            ] != "RANDOM" else None

    # Функция toggle_dhcp_ntp_server предназначна для
    # вывода сервера NTP, при выборе "DHCP" в NTP-Server
    def toggle_dhcp_ntp_server(self, button):
        if button.get_active():
            self.cbxDhcp.set_active(True)
            self.txtNtpServer.set_text("")
            self.txtNtpServer.set_sensitive(False)
        else:
            self.cbxDhcp.set_active(False)
            self.txtNtpServer.set_text(configFile["NTPSERVERS"]) if configFile[
                "NTPSERVERS"
            ] != "dhcp" else None
            self.txtNtpServer.set_sensitive(True)

    # Копирование machine id в буфер обмена
    def copy_to_clipboard(self, button):
        command = "echo " + self.txtMachinieId.get_text() + " | xclip -sel clip"
        subprocess.getstatusoutput(command)
        self.popCopy.show()

    # Загрузка окна "редактировать пользователей"
    def fill_grid_users(self):
        if self.txtUsers.get_text():
            self.selected = None
            self.selectIter = None
            self.uid = ""
            self.login = ""
            self.passwd = ""
            self.nameUser = ""

            if not self.selected:
                self.btnEditNewUser.set_sensitive(False)
                self.btnDelNewUser.set_sensitive(False)

            defList = [[]]
            for strUsr in self.txtUsers.get_text().split(","):
                if strUsr:
                    if strUsr.split(":")[2] == "x":
                        defList.append(
                            [
                                int(strUsr.split(":")[1]),
                                strUsr.split(":")[0],
                                i18n("Default"),
                                strUsr.split(":")[3],
                                strUsr.split(":")[2],
                            ]
                        )
                    else:
                        defList.append(
                            [
                                int(strUsr.split(":")[1]),
                                strUsr.split(":")[0],
                                i18n("Crypt"),
                                strUsr.split(":")[3],
                                strUsr.split(":")[2],
                            ]
                        )

            # Сортировка
            defList.pop(0)
            defList.sort(key=lambda i: i[0])

            # Запись отсортированного списка в GtkListStore
            for s in defList:
                self.listUserString.append(s)

    def update_table_when_edit_users(self, editable):
        self.listUserString.clear()
        self.fill_grid_users()

        if not editable.get_text():
            self.txtUser.set_text("")
            self.txtUser.set_sensitive(True)
        else:
            for i in str(editable.get_text()).split(","):
                if i and int(i.split(":")[1]) == 1000:
                    self.txtUser.set_text(i.split(":")[0])
                    self.txtUser.set_sensitive(False)

    def change_user_name(self, editable):
        self.cbxAdmin.set_sensitive(
            True
        ) if editable.get_text() else self.cbxAdmin.set_sensitive(False)

    # открытие окна "Добавить нового пользователя"
    def show_add_new_user(self, window):
        renderer = gtk.CellRendererText()
        self.txtUid.set_sensitive(False)
        self.txtLogin.set_text("")
        self.txtPass.set_text("")
        self.txtUserName.set_text("")
        if len(self.listUserString) > 0:
            self.txtUid.set_text(
                str(self.listUserString[(len(self.listUserString)) - 1][0] + 1)
            )
        else:
            self.txtUid.set_text("1000")

        self.cbHashingAlgPass1.pack_start(renderer, True)
        self.cbHashingAlgPass1.add_attribute(renderer, "text", 1)
        self.cbHashingAlgPass1.set_active(4)
        self.wndAddUser.set_transient_for(self.window)
        self.wndAddUser.show()

    # закрытие окна "Добавить нового пользователя"
    def hide_add_new_user(self, window):
        self.cbHashingAlgPass1.clear()
        self.wndAddUser.hide()

    # Закрытие окна "Редактировать пользователя"
    def hide_edit_new_user(self, window):
        self.cbHashingAlgPass2.clear()
        self.wndEditUser.hide()

    def on_hide_edit_users(self, widget):
        self.txtEditUid.set_text("")
        self.txtEditLogin.set_text("")
        self.txtEditPass.set_text("")
        self.txtEditUserName.set_text("")
        self.cbxEditDefPass.set_active(True)

    # Добавлние нового пользователя
    def create_add_new_user(self, window):
        defGrp = configFile["USERGROUPS"]
        if defGrp:
            defGrp = "-G %s" % defGrp

        if (
            self.txtUid.get_text()
            and self.txtLogin.get_text()
            and (self.txtPass.get_text() or self.cbxDefPass.get_active())
            and self.txtUserName.get_text()
        ):
            if self.cbxDefPass.get_active():
                self.listUserString.append(
                    [
                        int(self.txtUid.get_text()),
                        self.txtLogin.get_text(),
                        i18n("Default"),
                        self.txtUserName.get_text(),
                        "x",
                    ]
                )
                if len(sys.argv) == 1:
                    self.cmdUsers.append(
                        "useradd -m {0} -u {1} -c {2} {3}".format(
                            defGrp,
                            self.txtUid.get_text(),
                            self.txtUserName.get_text(),
                            self.txtLogin.get_text(),
                        )
                    )
                    if self.checkSmbpasswd and self.cbxAddSambaUser.get_active():
                        passwdStr = configFile["DEFAULTPASSWD"]
                        loginStr = self.txtLogin.get_text()
                        self.cmdUsers.append(
                            '(echo "{0}"; echo "{0}") | sudo smbpasswd -Lsan {1}'.format(
                                passwdStr, loginStr
                            )
                        )
                        # self.cmdUsers.append(f"(echo {passwdStr}; echo {passwdStr}) | sudo passwd {loginStr}")
            else:
                getIterHashPass = self.cbHashingAlgPass1.get_active_iter()
                if getIterHashPass:
                    modelHashPass = self.cbHashingAlgPass1.get_model()
                    hashType = int(modelHashPass[getIterHashPass][0])
                    hashPass = self.crypt_pass(self.txtPass.get_text(), hashType)
                self.listUserString.append(
                    [
                        int(self.txtUid.get_text()),
                        self.txtLogin.get_text(),
                        i18n("Crypt"),
                        self.txtUserName.get_text(),
                        hashPass,
                    ]
                )
                if len(sys.argv) == 1:
                    uidStr = self.txtEditUid.get_text()
                    usernameStr = self.txtEditUserName.get_text()
                    loginStr = self.txtEditLogin.get_text()
                    passwdStr = self.txtEditPass.get_text()

                    self.cmdUsers.append(
                        "useradd -m {0} -p {1} -u {2} -c {3} {4}".format(
                            defGrp, hashPass, uidStr, usernameStr, loginStr
                        )
                    )
                    if self.checkSmbpasswd and self.cbxAddSambaUser.get_active():
                        self.cmdUsers.append(
                            '(echo "{0}"; echo "{0}") | sudo smbpasswd -Lsa {1}'.format(
                                passwdStr, loginStr
                            )
                        )
                        self.cmdUsers.append(
                            f"(echo {passwdStr}; echo {passwdStr}) | sudo passwd {loginStr}"
                        )

            self.wndAddUser.hide()
            self.txtUid.set_text("")
            self.txtLogin.set_text("")
            self.txtPass.set_text("")
            self.cbxDefPass.set_active(False)
            self.txtUserName.set_text("")
            self.save_users()
            self.cbHashingAlgPass1.clear()
        else:
            self.wndErrorMsg.set_title(i18n("Warning"))
            self.lblErrorMsg.set_text(i18n("All fields must be filled in!"))
            self.btnErrorMsg.set_label(i18n("OK"))
            self.wndErrorMsg.set_transient_for(self.wndAddUser)
            self.wndErrorMsg.show()

    def crypt_pass(self, passwdStr, methodHash):
        if self.checkMkpasswd:
            allHashMethods = [
                "bcrypt",
                "bcrypt-a",
                "scrypt",
                "md5crypt",
                "sha512crypt",
                "sha256crypt",
                "gost-yescrypt",
                "yescrypt",
                "bsdicrypt",
                "descrypt",
            ]
            if methodHash >= 0 and methodHash <= 9:
                return str(
                    subprocess.getstatusoutput(
                        "mkpasswd -m {0} {1}".format(
                            allHashMethods[methodHash], str(passwdStr)
                        )
                    )[1]
                )
            else:
                return str(
                    subprocess.getstatusoutput(
                        "mkpasswd -m sha512crypt {0}".format(str(passwdStr))
                    )[1]
                )
        else:
            if methodHash == 0:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -1 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )
            elif methodHash == 1:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -apr1 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )
            elif methodHash == 2:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -aixmd5 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )
            elif methodHash == 3:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -5 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )
            elif methodHash == 4:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -6 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )
            else:
                return str(
                    subprocess.getstatusoutput(
                        "openssl passwd -6 -salt ubsalt {0}".format(str(passwdStr))
                    )[1]
                )

    # Отработка ивента
    # Если выбрать "Пароль по умолчанию" - запретить ввод в поле "Пароль"
    def check_def_passwd(self, checkbtn):
        self.txtPass.set_sensitive(not checkbtn.get_active())

    def open_edit_users(self, button):
        self.wndEditUser.set_transient_for(self.window)
        self.wndEditUser.show()

    def double_click_show_edit_user(self, treeView, pat, column):
        self.wndEditUser.set_transient_for(self.window)
        self.wndEditUser.show()

    # загрузка окна - "Редактироват пользователя"
    def show_edit_user(self, widget):
        renderer = gtk.CellRendererText()
        if self.selected[2] == i18n("Default"):
            self.txtEditUid.set_text(str(self.selected[0]))
            self.txtEditLogin.set_text(self.selected[1])
            self.cbxEditDefPass.set_active(True)
            self.txtEditUserName.set_text(self.selected[3])
        else:
            self.txtEditUid.set_text(str(self.selected[0]))
            self.txtEditLogin.set_text(self.selected[1])
            self.txtEditPass.set_text("")
            self.cbxEditDefPass.set_active(False)
            self.txtEditUserName.set_text(self.selected[3])

        if (
            subprocess.getstatusoutput("who | grep {0}".format(self.selected[1]))[0]
            == 0
        ):
            self.txtEditLogin.set_sensitive(False)

        self.cbHashingAlgPass2.pack_start(renderer, True)
        self.cbHashingAlgPass2.add_attribute(renderer, "text", 1)
        self.cbHashingAlgPass2.set_active(4)

    # Редактировать пользователя
    def edit_user(self, button):
        oldLogin = str(self.selected[1])
        newLogin = self.txtEditLogin.get_text()
        login = ""
        checkChangeLogin = False
        if (
            self.txtEditUid.get_text()
            and self.txtEditLogin.get_text()
            and self.txtEditUserName.get_text()
        ):
            if self.txtEditLogin.get_text() != str(self.selected[1]):
                self.listUserString[self.selectIter][1] = self.txtEditLogin.get_text()
                if len(sys.argv) == 1:
                    self.cmdUsers.append(
                        "usermod -l {0} {1}".format(
                            self.txtEditLogin.get_text(), oldLogin
                        )
                    )
                    # TODO: добавление пользователя samba с тем же паролем
                    # if self.checkSmbpasswd and self.cbxEditSambaUser.get_active():
                    #    self.cmdUsers.append("smbpasswd -Lsx {0}".format(oldLogin))
                    checkChangeLogin = True
            if checkChangeLogin:
                login = newLogin
            else:
                login = oldLogin

            if self.txtEditUserName.get_text() != str(self.selected[3]):
                self.listUserString[self.selectIter][
                    3
                ] = self.txtEditUserName.get_text()
                if len(sys.argv) == 1:
                    self.cmdUsers.append(
                        "usermod -c '{0}' {1}".format(
                            self.txtEditUserName.get_text(), login
                        )
                    )

            if (
                self.selected[2] == i18n("Default")
                and not self.cbxEditDefPass.get_active()
            ):
                if self.txtEditPass.get_text():
                    getIterHashPass = self.cbHashingAlgPass2.get_active_iter()

                    if getIterHashPass:
                        modelHashPass = self.cbHashingAlgPass2.get_model()
                        hashType = int(modelHashPass[getIterHashPass][0])
                        hashPass = self.crypt_pass(
                            self.txtEditPass.get_text(), hashType
                        )
                        self.listUserString[self.selectIter][2] = i18n("Crypt")
                        self.listUserString[self.selectIter][4] = hashPass

                        if len(sys.argv) == 1:
                            self.cmdUsers.append(
                                "usermod -p '{0}' {1}".format(hashPass, login)
                            )
                            if (
                                self.checkSmbpasswd
                                and self.cbxEditSambaUser.get_active()
                            ):
                                passwdStr = self.txtEditPass.get_text()
                                self.cmdUsers.append(
                                    '(echo "{0}"; echo "{0}") | sudo smbpasswd -Lsa {1}'.format(
                                        passwdStr, login
                                    )
                                )
                                self.cmdUsers.append(
                                    f"(echo {passwdStr}; echo {passwdStr}) | sudo passwd {login}"
                                )
                else:
                    self.wndErrorMsg.set_title(i18n("Warning"))
                    self.lblErrorMsg.set_text(
                        i18n("The password field must be filled in!")
                    )
                    self.btnErrorMsg.set_label(i18n("OK"))
                    self.wndErrorMsg.set_transient_for(self.wndEditUser)
                    self.wndErrorMsg.show()

            elif self.selected[2] == i18n("Crypt") and self.cbxEditDefPass.get_active():
                self.listUserString[self.selectIter][2] = i18n("Default")
                self.listUserString[self.selectIter][4] = "x"
                if len(sys.argv) == 1:
                    passwdStr = "ublinux"
                    self.cmdUsers.append(
                        "usermod -p '{0}' {1}".format(
                            configFile["DEFAULTPASSWD"], login
                        )
                    )
                    if self.checkSmbpasswd and self.cbxEditSambaUser.get_active():
                        self.cmdUsers.append(
                            '(echo "{0}"; echo "{0}") | sudo smbpasswd -Lsa {1}'.format(
                                passwdStr, login
                            )
                        )

            self.wndEditUser.hide()
            self.cbHashingAlgPass2.clear()
            self.save_users()
        else:
            self.wndErrorMsg.set_title(i18n("Warning"))
            self.lblErrorMsg.set_text(i18n("All fields must be filled in!"))
            self.btnErrorMsg.set_label(i18n("OK"))
            self.wndErrorMsg.set_transient_for(self.wndEditUser)
            self.wndErrorMsg.show()

    # Выбор пользователя из таблицы
    def set_select_row(self, select):
        if select.get_selected()[1]:
            self.selected = self.listUserString[select.get_selected()[1]]
            self.selectIter = select.get_selected()[1]
            self.btnEditNewUser.set_sensitive(True)
            self.btnDelNewUser.set_sensitive(True)

    # Отработка ивента
    # Если выбрать "Пароль по умолчанию" - запретить ввод в поле "Пароль"
    def check_edit_def_passwd(self, checkbtn):
        self.txtEditPass.set_sensitive(not checkbtn.get_active())

    # Удаление пользователей
    def delete_new_user(self, button):
        self.wndDelProfUser.set_transient_for(self.window)
        self.wndDelProfUser.show()

    def accept_del_prof_user(self, button):
        if len(sys.argv) == 1:
            self.cmdUsers.append(
                "killall -TERM -u {0}; userdel -f -r  {0}".format(self.selected[1])
            )
            if self.checkSmbpasswd and self.cbxDelSambaUser.get_active():
                self.cmdUsers.append("smbpasswd -Lsx {0}".format(self.selected[1]))

        self.listUserString.remove(self.selectIter)
        self.save_users()
        if len(self.listUserString) == 0:
            self.btnEditNewUser.set_sensitive(False)
            self.btnDelNewUser.set_sensitive(False)

        self.wndDelProfUser.hide()

    def decline_del_prof_user(self, button):
        if len(sys.argv) == 1:
            self.cmdUsers.append("userdel -r {0}".format(self.selected[1]))
            if self.checkSmbpasswd and self.cbxDelSambaUser.get_active():
                self.cmdUsers.append("smbpasswd -Lsx {0}".format(self.selected[1]))

        self.listUserString.remove(self.selectIter)
        self.save_users()
        if len(self.listUserString) == 0:
            self.btnEditNewUser.set_sensitive(False)
            self.btnDelNewUser.set_sensitive(False)

        self.wndDelProfUser.hide()

    # Сохранение пользователей
    def save_users(self):
        strNewUsers = ""
        for strUser in self.listUserString:
            tmp = (
                str(strUser[1])
                + ":"
                + str(strUser[0])
                + ":"
                + str(strUser[4])
                + ":"
                + str(strUser[3])
                + ","
            )
            strNewUsers += tmp

        if strNewUsers:
            self.txtUsers.set_text(str(strNewUsers)[:-1])
        else:
            self.txtUsers.set_text("")

    # открыть окно "редактировать группы"
    def open_edit_groups(self, button):
        self.wndEditGrp.set_transient_for(self.window)
        self.wndEditGrp.show()

    # Загрузка окна "редактировать группы"
    def load_edit_gpoups(self, window):
        self.treeViewGrps = self.builder.get_object("treeViewGrps")
        self.btnCancelGroup = self.builder.get_object("btnCancelGroup")
        self.btnAddEditGroup = self.builder.get_object("btnAddEditGroup")

        listGrpConfig = self.txtGroups.get_text().split(",")
        listGrpAll = [[]]
        self.listGrp = gtk.ListStore(bool, str)
        checkGrp = False

        with open("/etc/group") as f:
            dataGrp = f.read().split("\n")

        for grp in dataGrp:
            if grp:
                if listGrpConfig:
                    for grpConfig in listGrpConfig:
                        if grp.split(":")[0] == grpConfig:
                            checkGrp = True
                            break
                listGrpAll.append([checkGrp, grp.split(":")[0]])
                checkGrp = False

        listGrpAll.pop(0)
        listGrpAll.sort(key=lambda x: x[1])

        for grp in listGrpAll:
            self.listGrp.append(grp)

        self.treeViewGrps.set_model(self.listGrp)

        renderer_toggle = gtk.CellRendererToggle()
        renderer_toggle.connect("toggled", self.on_cell_toggled_grp)
        self.columnToggleGrps = gtk.TreeViewColumn("", renderer_toggle, active=0)
        self.treeViewGrps.append_column(self.columnToggleGrps)

        renderer_text = gtk.CellRendererText()
        self.columnNameGrps = gtk.TreeViewColumn(i18n("Group"), renderer_text, text=1)
        self.treeViewGrps.append_column(self.columnNameGrps)

    # Сохранить измененные группы
    def save_grps(self, button):
        strGrps = ""
        for grp in self.listGrp:
            strGrps += str(grp[1]) + "," if grp[0] else ""

        if strGrps:
            self.txtGroups.set_text(strGrps[:-1])
        else:
            self.txtGroups.set_text("")
        self.wndEditGrp.hide()
        self.clear_grps()

    # Очистка списка групп из окна
    def clear_grps(self):
        self.listGrp.clear()
        self.treeViewGrps.set_model(model=None)
        self.treeViewGrps.remove_column(self.columnToggleGrps)
        self.treeViewGrps.remove_column(self.columnNameGrps)

    # Ивент, для активации переключателей в окне "редактировать группы"
    def on_cell_toggled_grp(self, widget, path):
        self.listGrp[path][0] = not self.listGrp[path][0]

    # Закрыь модальное окно "редактировать группы"
    def close_wnd_edit_group(self, button):
        self.wndEditGrp.hide()
        self.clear_grps()

    # Открыть модальное окно "Выбор пользователя"
    def open_choose_user(self, button):
        self.wndChooseUser.set_transient_for(self.window)
        self.wndChooseUser.show()

    # Закрыть модальное окно "Выбор пользователя"
    def close_chooser_user(self, button):
        self.wndChooseUser.hide()
        self.clear_chooser_user()

    # Загрузка окна "Выбор пользователя"
    def load_chooser_user(self, window):
        self.treeViewChooseUser = self.builder.get_object("treeViewChooseUser")
        self.btnOkChooseUser = self.builder.get_object("btnOkChooseUser")

        user = self.txtUserNtfsOwner.get_text()
        listUsers = [[]]
        self.listChooseUser = gtk.ListStore(bool, str)

        with open("/etc/passwd") as f:
            dataUsers = f.read().split("\n")

        for userLine in dataUsers:
            if userLine:
                if (
                    user
                    and user == userLine.split(":")[0]
                    and (
                        int(userLine.split(":")[2]) >= 1000
                        or int(userLine.split(":")[2]) == 0
                    )
                ):
                    listUsers.append([True, userLine.split(":")[0]])
                elif (
                    int(userLine.split(":")[2]) >= 1000
                    or int(userLine.split(":")[2]) == 0
                ):
                    listUsers.append([False, userLine.split(":")[0]])

        listUsers.pop(0)
        listUsers.sort(key=lambda x: x[1])

        for s in listUsers:
            if s:
                self.listChooseUser.append(s)

        self.treeViewChooseUser.set_model(self.listChooseUser)

        rendererRadioChooseUser = gtk.CellRendererToggle()
        rendererRadioChooseUser.set_radio(True)
        rendererRadioChooseUser.connect(
            "toggled", self.on_cell_radio_toggled_chooser_user
        )
        self.columnRadioChooseUser = gtk.TreeViewColumn(
            "", rendererRadioChooseUser, active=0
        )
        self.treeViewChooseUser.append_column(self.columnRadioChooseUser)

        rendererTextChooseUser = gtk.CellRendererText()
        self.columnTextChooseUser = gtk.TreeViewColumn(
            i18n("User"), rendererTextChooseUser, text=1
        )
        self.treeViewChooseUser.append_column(self.columnTextChooseUser)

    # Событие при выборе радиобокса в окне "Выбор пользователя"
    def on_cell_radio_toggled_chooser_user(self, widget, path):
        selected_path = gtk.TreePath(path)
        for row in self.listChooseUser:
            row[0] = row.path == selected_path

    # Очистка окна "Выбор пользователя"
    def clear_chooser_user(self):
        self.listChooseUser.clear()
        self.treeViewChooseUser.set_model(model=None)
        self.treeViewChooseUser.remove_column(self.columnRadioChooseUser)
        self.treeViewChooseUser.remove_column(self.columnTextChooseUser)

    # Обновление текста в текстовом поле с пользователем FAT NTFS
    def save_chooser_user(self, button):
        strChooseUser = ""
        for usr in self.listChooseUser:
            if usr[0]:
                strChooseUser = str(usr[1])
                break

        if strChooseUser:
            self.txtUserNtfsOwner.set_text(strChooseUser)
        else:
            self.txtUserNtfsOwner.set_text("")

        self.wndChooseUser.hide()
        self.clear_chooser_user()

    ### Основные ###

    ### Службы ###
    # Загрузка вкладки "Службы"
    def fill_main_window_services(self, array_config):
        self.selectedServ = None
        self.selectedServIter = None
        self.btnStartServ.set_sensitive(False)
        self.btnStopServ.set_sensitive(False)
        self.btnEnableServ.set_sensitive(False)
        self.btnDisableSev.set_sensitive(False)
        renderer = gtk.CellRendererText()
        self.startServicesList = (
            str(array_config["SERVICESSTART"]).split(",")
            if array_config["SERVICESSTART"]
            else None
        )

        for strType in self.lsitFilterServices:
            strType[1] = i18n(strType[1])

        self.cbFilterServ.pack_start(renderer, True)
        self.cbFilterServ.add_attribute(renderer, "text", 1)
        self.cbFilterServ.set_active(0)
        self.load_services("all")

    # Загрузка служб в таблицу
    def load_services(self, chekType):
        tmpNestedListServ = [[]]
        tmpNestedListSock = [[]]
        tmpListAllServ = [[]]
        tmpNestedListServ.clear()
        tmpNestedListSock.clear()

        # Получить список служб
        tmpListServ = subprocess.getoutput(
            "systemctl list-units --type service --all | sed -e 's/●//g'"
        ).split("\n")
        tmpListServ = list(filter(None, tmpListServ))

        tmpListSock = subprocess.getoutput(
            "systemctl list-units --type socket --all | sed -e 's/●//g'"
        ).split("\n")
        tmpListSock = list(filter(None, tmpListSock))

        for servInffo in tmpListServ:
            tmpNestedListServ.append(servInffo.split())
        tmpNestedListServ.pop(0)

        for servInffo in tmpListSock:
            tmpNestedListSock.append(servInffo.split())
        tmpNestedListSock.pop(0)

        if chekType == "all":
            tmpListAllServ.clear()
            # Убрать лишнее и вставить в ListStor
            for servStr in tmpNestedListServ:
                if servStr[0] == "UNIT":
                    continue
                if servStr[0] == "LOAD":
                    break
                minLen = 4
                maxLen = len(servStr)
                strInfoServ = ""
                while minLen < maxLen:
                    strInfoServ += " " + servStr[minLen]
                    minLen += 1
                tmpListAllServ.append(
                    [
                        i18n(servStr[1]),
                        i18n(servStr[2]),
                        i18n(servStr[3]),
                        i18n(servStr[0]),
                        strInfoServ,
                    ]
                )
            tmpListAllServ.pop(0)

            for servStr in tmpNestedListSock:
                if servStr[0] == "UNIT":
                    continue
                if servStr[0] == "LOAD":
                    break
                minLen = 4
                maxLen = len(servStr)
                strInfoServ = ""
                while minLen < maxLen:
                    strInfoServ += " " + servStr[minLen]
                    minLen += 1
                tmpListAllServ.append(
                    [
                        i18n(servStr[1]),
                        i18n(servStr[2]),
                        i18n(servStr[3]),
                        servStr[0],
                        strInfoServ,
                    ]
                )

            # Вывод в зависимости от фильтра
            for listServ in tmpListAllServ:
                self.listAllServices.append(listServ)
        elif chekType == "serv":
            tmpListAllServ.clear()
            for servStr in tmpNestedListServ:
                if servStr[0] == "UNIT":
                    continue
                if servStr[0] == "LOAD":
                    break
                minLen = 4
                maxLen = len(servStr)
                strInfoServ = ""
                while minLen < maxLen:
                    strInfoServ += " " + servStr[minLen]
                    minLen += 1
                tmpListAllServ.append(
                    [
                        i18n(servStr[1]),
                        i18n(servStr[2]),
                        i18n(servStr[3]),
                        i18n(servStr[0]),
                        strInfoServ,
                    ]
                )
            tmpListAllServ.pop(0)

            for listServ in tmpListAllServ:
                self.listAllServices.append(listServ)
        elif chekType == "sock":
            tmpListAllServ.clear()
            for servStr in tmpNestedListSock:
                if servStr[0] == "UNIT":
                    continue
                if servStr[0] == "LOAD":
                    break
                minLen = 4
                maxLen = len(servStr)
                strInfoServ = ""
                while minLen < maxLen:
                    strInfoServ += " " + servStr[minLen]
                    minLen += 1
                tmpListAllServ.append(
                    [
                        i18n(servStr[1]),
                        i18n(servStr[2]),
                        i18n(servStr[3]),
                        servStr[0],
                        strInfoServ,
                    ]
                )
            tmpListAllServ.pop(0)

            for listServ in tmpListAllServ:
                self.listAllServices.append(listServ)
        elif chekType == "enabled":
            tmpListAllServ.clear()
            for servStr in tmpNestedListServ:
                if servStr[0] == "UNIT":
                    continue
                if servStr[0] == "LOAD":
                    break
                minLen = 4
                maxLen = len(servStr)
                strInfoServ = ""
                while minLen < maxLen:
                    strInfoServ += " " + servStr[minLen]
                    minLen += 1
                tmpListAllServ.append(
                    [
                        i18n(servStr[1]),
                        i18n(servStr[2]),
                        i18n(servStr[3]),
                        i18n(servStr[0]),
                        strInfoServ,
                    ]
                )

            for listServ in tmpListAllServ:
                if self.startServicesList[0]:
                    for startServ in self.startServicesList:
                        if startServ in listServ[3]:
                            self.listAllServices.append(listServ)
                            break
        else:
            index = self.cbFilterServ.get_active()

            if int(index) == 0 or int(index) == 1:
                tmpListAllServ.clear()
                for servStr in tmpNestedListServ:
                    if servStr[0] == "UNIT":
                        continue
                    if servStr[0] == "LOAD":
                        break
                    minLen = 4
                    maxLen = len(servStr)
                    strInfoServ = ""
                    while minLen < maxLen:
                        strInfoServ += " " + servStr[minLen]
                        minLen += 1
                    tmpListAllServ.append(
                        [
                            i18n(servStr[1]),
                            i18n(servStr[2]),
                            i18n(servStr[3]),
                            i18n(servStr[0]),
                            strInfoServ,
                        ]
                    )
                tmpListAllServ.pop(0)

            if int(index) == 0 or int(index) == 2:
                for servStr in tmpNestedListSock:
                    if servStr[0] == "UNIT":
                        continue
                    if servStr[0] == "LOAD":
                        break
                    minLen = 4
                    maxLen = len(servStr)
                    strInfoServ = ""
                    while minLen < maxLen:
                        strInfoServ += " " + servStr[minLen]
                        minLen += 1
                    tmpListAllServ.append(
                        [
                            i18n(servStr[1]),
                            i18n(servStr[2]),
                            i18n(servStr[3]),
                            servStr[0],
                            strInfoServ,
                        ]
                    )

            if int(index) == 2:
                tmpListAllServ.pop(0)

            for listServ in tmpListAllServ:
                if chekType in listServ[3]:
                    self.listAllServices.append(listServ)

        self.treeViewServ.set_model(self.listAllServices)

        loadRender = gtk.CellRendererText()
        self.loadColumn = gtk.TreeViewColumn(
            title=i18n("Load status"), cell_renderer=loadRender, text=0
        )
        self.loadColumn.set_sort_column_id(0)
        self.treeViewServ.append_column(self.loadColumn)
        activeRender = gtk.CellRendererText()
        self.activeColumn = gtk.TreeViewColumn(
            title=i18n("Active status"), cell_renderer=activeRender, text=1
        )
        self.activeColumn.set_sort_column_id(1)
        self.treeViewServ.append_column(self.activeColumn)

        servRender = gtk.CellRendererText()
        self.servColumn = gtk.TreeViewColumn(
            title=i18n("Service status"), cell_renderer=servRender, text=2
        )
        self.servColumn.set_sort_column_id(2)
        self.treeViewServ.append_column(self.servColumn)

        servNameRender = gtk.CellRendererText()
        self.servNameColumn = gtk.TreeViewColumn(
            title=i18n("Service"), cell_renderer=servNameRender, text=3
        )
        self.servNameColumn.set_sort_column_id(3)
        servNameRender.props.wrap_width = 250
        servNameRender.props.wrap_mode = gtk.WrapMode.WORD
        self.treeViewServ.append_column(self.servNameColumn)

        servDescRender = gtk.CellRendererText()
        self.servDescColumn = gtk.TreeViewColumn(
            title=i18n("Desk"), cell_renderer=servDescRender, text=4
        )
        self.servDescColumn.set_visible(False)
        self.treeViewServ.append_column(self.servDescColumn)

    # Очистка таблицы со службами
    def clear_serv_treeview(self):
        self.listAllServices.clear()
        self.treeViewServ.set_model(model=None)
        self.treeViewServ.remove_column(self.loadColumn)
        self.treeViewServ.remove_column(self.activeColumn)
        self.treeViewServ.remove_column(self.servColumn)
        self.treeViewServ.remove_column(self.servNameColumn)
        self.treeViewServ.remove_column(self.servDescColumn)

    # Событие при выборе службы
    def set_select_serv_row(self, select):
        if select.get_selected()[1]:
            self.selectedServ = self.listAllServices[select.get_selected()[1]]
            self.selectedServIter = select.get_selected()[1]
            self.lblShowNameServ.set_label(self.selectedServ[3])
            self.lblShowDescServ.set_label(self.selectedServ[4])
            if self.selectedServ[1] == i18n("active"):
                self.btnStartServ.set_sensitive(False)
                self.btnStopServ.set_sensitive(True)
            elif self.selectedServ[1] == i18n("inactive"):
                self.btnStartServ.set_sensitive(True)
                self.btnStopServ.set_sensitive(False)

            checkFile = False
            for dirFind in os.scandir("/etc/systemd/system"):
                if dirFind.is_dir():
                    for files in os.scandir("/etc/systemd/system/" + dirFind.name):
                        if files.is_symlink() and files.name == str(
                            self.selectedServ[3]
                        ):
                            self.btnEnableServ.set_sensitive(False)
                            self.btnDisableSev.set_sensitive(True)
                            checkFile = True
                            break
                        else:
                            self.btnEnableServ.set_sensitive(True)
                            self.btnDisableSev.set_sensitive(False)
                    if checkFile:
                        break
        else:
            return

    # Запуск службы
    def start_serv(self, button):
        if self.selectedServ:
            strCommand = "systemctl start " + str(self.selectedServ[3])
            getErrorCode = subprocess.getstatusoutput(strCommand)
            if int(getErrorCode[0]) != 0:
                self.wndErrorMsg.set_title(i18n("Error!"))
                errorMsg = (
                    str(i18n("Error starting the "))
                    + str(self.selectedServ[3])
                    + "\n\n"
                    + getErrorCode[1]
                )
            else:
                self.wndErrorMsg.set_title(i18n("Complete"))
                errorMsg = str(i18n("The service has been started"))

            self.lblErrorMsg.set_label(errorMsg)
            self.wndErrorMsg.set_transient_for(self.window)
            self.wndErrorMsg.show()

            self.clear_serv_treeview()
            if int(self.cbFilterServ.get_active()) == 0:
                self.load_services("all")
            elif int(self.cbFilterServ.get_active()) == 1:
                self.load_services("serv")
            elif int(self.cbFilterServ.get_active()) == 2:
                self.load_services("sock")
            elif int(self.cbFilterServ.get_active()) == 3:
                self.load_services("enabled")
        self.selectedServ = None

    # Остановка службы
    def stop_serv(self, button):
        strCommand = "systemctl stop " + str(self.selectedServ[3])
        getErrorCode = subprocess.getstatusoutput(strCommand)
        if int(getErrorCode[0]) != 0:
            self.wndErrorMsg.set_title(i18n("Error!"))
            errorMsg = (
                str(i18n("Error stopping the "))
                + str(self.selectedServ[3])
                + "\n\n"
                + getErrorCode[1]
            )
        else:
            self.wndErrorMsg.set_title(i18n("Complete"))
            errorMsg = str(i18n("The service has been stopped"))

        self.lblErrorMsg.set_label(errorMsg)
        self.wndErrorMsg.set_transient_for(self.window)
        self.wndErrorMsg.show()

        self.clear_serv_treeview()
        if int(self.cbFilterServ.get_active()) == 0:
            self.load_services("all")
        elif int(self.cbFilterServ.get_active()) == 1:
            self.load_services("serv")
        elif int(self.cbFilterServ.get_active()) == 2:
            self.load_services("sock")
        elif int(self.cbFilterServ.get_active()) == 3:
            self.load_services("enabled")

    # Включение автозапуска службы
    def enable_serv(self, button):
        if self.selectedServ:
            strCommand = "sudo systemctl enable " + str(self.selectedServ[3]) + " 2>&1"
            getErrorCode = subprocess.getstatusoutput(strCommand)

            if (
                int(getErrorCode[0]) != 0
                or "The unit files have no installation config" in getErrorCode[1]
            ):

                self.wndErrorMsg.set_title(i18n("Error!"))
                errorMsg = (
                    str(i18n("Error enabling "))
                    + str(self.selectedServ[3])
                    + "\n\n"
                    + getErrorCode[1]
                )
            else:
                self.wndErrorMsg.set_title(i18n("Complete"))
                errorMsg = str(i18n("The service has been enabled"))
                self.startServicesList.append(
                    re.sub(r"\.\S+", "", str(self.selectedServ[3]))
                )

            self.lblErrorMsg.set_label(errorMsg)
            self.wndErrorMsg.set_transient_for(self.window)
            self.wndErrorMsg.show()

            self.clear_serv_treeview()
            if int(self.cbFilterServ.get_active()) == 0:
                self.load_services("all")
            elif int(self.cbFilterServ.get_active()) == 1:
                self.load_services("serv")
            elif int(self.cbFilterServ.get_active()) == 2:
                self.load_services("sock")
            elif int(self.cbFilterServ.get_active()) == 3:
                self.load_services("enabled")
        else:
            pass
        self.selectedServ = None

    # отключение автозапуска службы
    def disable_serv(self, button):
        if self.selectedServ:
            strCommand = "systemctl disable " + str(self.selectedServ[3])
            getErrorCode = subprocess.getstatusoutput(strCommand)

            if int(getErrorCode[0]) != 0:
                self.wndErrorMsg.set_title(i18n("Error!"))
                errorMsg = (
                    str(i18n("Error disabling "))
                    + str(self.selectedServ[3])
                    + "\n\n"
                    + getErrorCode[1]
                )
            else:
                self.wndErrorMsg.set_title(i18n("Complete"))
                errorMsg = str(i18n("The service has been disabled"))

                removedService = re.sub(r"\.\S+", "", str(self.selectedServ[3]))
                if removedService in self.startServicesList:
                    self.startServicesList.remove(removedService)
                elif self.selectedServ[3] in self.startServicesList:
                    self.startServicesList.remove(self.selectedServ[3])

            self.lblErrorMsg.set_label(errorMsg)
            self.wndErrorMsg.set_transient_for(self.window)
            self.wndErrorMsg.show()

            self.clear_serv_treeview()
            if int(self.cbFilterServ.get_active()) == 0:
                self.load_services("all")
            elif int(self.cbFilterServ.get_active()) == 1:
                self.load_services("serv")
            elif int(self.cbFilterServ.get_active()) == 2:
                self.load_services("sock")
            elif int(self.cbFilterServ.get_active()) == 3:
                self.load_services("enabled")

    # фильтрация служб с помощью компбобокса
    def change_to_all_enable(self, combobox):
        index = combobox.get_active()
        self.clear_serv_treeview()
        if int(index) == 0:
            self.load_services("all")
        elif int(index) == 1:
            self.load_services("serv")
        elif int(index) == 2:
            self.load_services("sock")
        elif int(index) == 3:
            self.load_services("enabled")

    def return_changes(self, button):
        strCommand = ""
        for strService in self.servicesString.split(","):
            strCommand += (
                f"sudo systemctl start {strService}; sudo systemctl enable {strService}"
            )
        getErrorCode = subprocess.getstatusoutput(strCommand)
        if int(getErrorCode[0]) != 0:
            self.wndErrorMsg.set_title(i18n("Error!"))
            errorMsg = (
                str(i18n("Error enabling "))
                + str(self.selectedServ[3])
                + "\n\n"
                + getErrorCode[1]
            )
        else:
            self.wndErrorMsg.set_title(i18n("Complete"))
            errorMsg = str(i18n("The list of services was restored by default!"))
            self.startServicesList = list(self.servicesString.split(","))

        self.lblErrorMsg.set_label(errorMsg)
        self.wndErrorMsg.set_transient_for(self.window)
        self.wndErrorMsg.show()

        self.clear_serv_treeview()
        if int(self.cbFilterServ.get_active()) == 0:
            self.load_services("all")
        elif int(self.cbFilterServ.get_active()) == 1:
            self.load_services("serv")
        elif int(self.cbFilterServ.get_active()) == 2:
            self.load_services("sock")
        elif int(self.cbFilterServ.get_active()) == 3:
            self.load_services("enabled")

    # self.selectedServ = None

    # Событие на кнопку поиска служб
    def find_services(self, button):
        findServ = self.txtSearchServ.get_text()
        self.clear_serv_treeview()
        self.load_services(findServ)

    ### Службы ###

    ### Сеть ###

    # Заполнение вкладки Сеть
    def fill_main_window_network(self, array_config):
        renderer = gtk.CellRendererText()

        listNetworkDev = gtk.ListStore(int, str)
        iterDev = 1
        listNetworkDev.append([0, i18n("Default")])
        for netDev in os.listdir("/sys/class/net/"):
            listNetworkDev.append([iterDev, netDev])
            iterDev += 1

        netDevice = array_config["DEVICE"] if array_config["DEVICE"] else None

        self.cbNetInterface.set_model(listNetworkDev)
        self.cbNetInterface.pack_start(renderer, True)
        self.cbNetInterface.add_attribute(renderer, "text", 1)
        if array_config["DEVICE"]:
            if netDevice:
                for i in listNetworkDev:
                    if i[1] == netDevice:
                        self.cbNetInterface.set_active(i[0])
                        break
        else:
            self.cbNetInterface.set_active(0)

        onBoot = array_config["ONBOOT"] if array_config["ONBOOT"] else None
        self.cbxAutoRun.set_active(onBoot == "yes")

        if array_config["DHCP_CLIENT"]:
            self.txtAltDhcp.set_text(array_config["DHCP_CLIENT"])
        if array_config["IPADDR"]:
            self.txtIpAdr.set_text(array_config["IPADDR"])
        if array_config["NETMASK"]:
            self.txtMask.set_text(array_config["NETMASK"])
        if array_config["GATEWAY"]:
            self.txtRout.set_text(array_config["GATEWAY"])
        if array_config["DNS1"]:
            self.txtDnsServ.set_text(array_config["DNS1"])

        for i in self.listMiiNotSupp:
            i[1] = i18n(i[1])

        self.cbMiiNotSupp.pack_start(renderer, True)
        self.cbMiiNotSupp.add_attribute(renderer, "text", 1)

        m11NotSup = (
            array_config["MII_NOT_SUPPORTED"]
            if array_config["MII_NOT_SUPPORTED"]
            else None
        )
        if m11NotSup:
            for i in self.listMiiNotSupp:
                if i18n(m11NotSup) == i[1]:
                    self.cbMiiNotSupp.set_active(i[0])
        else:
            self.cbMiiNotSupp.set_active(0)

        self.txtExceptFireTcp.set_text(
            array_config["IPTABLESOPENPORTSTCP"]
        ) if array_config["IPTABLESOPENPORTSTCP"] else None
        self.txtExeptFireUdp.set_text(
            array_config["IPTABLESOPENPORTSUDP"]
        ) if array_config["IPTABLESOPENPORTSUDP"] else None
        self.txtTrustIp.set_text(array_config["IPTABLESTRUSTEDIP"]) if array_config[
            "IPTABLESTRUSTEDIP"
        ] else None

        avahi = array_config["NSSWITCHAVAHI"] if array_config["NSSWITCHAVAHI"] else None
        winbind = (
            array_config["NSSWITCHWINBIND"] if array_config["NSSWITCHWINBIND"] else None
        )
        self.cbxAvahi.set_active(avahi and avahi == "yes")
        self.cbxWinbind.set_active(winbind and winbind == "yes")

        if array_config["ip"]:
            self.txtPrimDnsServ.set_text(array_config["ip"])
            self.txtPrimDnsServ.set_sensitive(True)
            self.cbPrimDnsServ.set_active(True)
        else:
            self.txtPrimDnsServ.set_sensitive(False)
            self.cbPrimDnsServ.set_active(False)

        self.cbxIpV6.set_active(array_config["IPV6"] == "yes")
        self.cbxRouteMode.set_active(array_config["ROUTER"] == "yes")

        self.numTraficTorMin.set_increments(1, 10)
        self.numTraficTorMax.set_increments(1, 10)
        self.numTraficTorMin.set_range(0, 9999)
        self.numTraficTorMax.set_range(1, 10000)

        if array_config["TORUSERS"]:
            self.numTraficTorMin.set_value(int(array_config["TORUSERS"].split("-")[0]))
            self.numTraficTorMax.set_value(int(array_config["TORUSERS"].split("-")[1]))
            self.cbxTraficTor.set_active(True)
        else:
            self.numTraficTorMin.set_value(0)
            self.numTraficTorMax.set_value(1)
            self.cbxTraficTor.set_active(False)

        self.cbxAcceptNetGet.set_active(array_config["server_ip"] == "any;")

        if array_config["HTTP_PROXY"]:
            self.cbxHttpProx.set_active(True)
            self.txtHttpProx.set_text(array_config["HTTP_PROXY"])
        else:
            self.cbxHttpProx.set_active(False)
            self.txtHttpProx.set_sensitive(False)

        if array_config["HTTPS_PROXY"]:
            self.cbxHttpsProx.set_active(True)
            self.txtHttpsProx.set_text(array_config["HTTPS_PROXY"])
        else:
            self.cbxHttpsProx.set_active(False)
            self.txtHttpsProx.set_sensitive(False)

        if array_config["FTP_PROXY"]:
            self.cbxFtpProx.set_active(True)
            self.txtFtpProx.set_text(array_config["FTP_PROXY"])
        else:
            self.cbxFtpProx.set_active(False)
            self.txtFtpProx.set_sensitive(False)

        if array_config["NO_PROXY"]:
            self.cbxNoProx.set_active(True)
            self.txtNoProx.set_text(array_config["NO_PROXY"])
            self.cbxHttpProx.set_active(False)
            self.txtHttpProx.set_sensitive(False)
            self.cbxHttpsProx.set_active(False)
            self.txtHttpsProx.set_sensitive(False)
            self.cbxFtpProx.set_active(False)
            self.txtFtpProx.set_sensitive(False)
        else:
            self.cbxNoProx.set_active(False)
            self.txtNoProx.set_sensitive(False)

        self.cbPolipoProx.pack_start(renderer, True)
        self.cbPolipoProx.add_attribute(renderer, "text", 1)

        if array_config["socksParentProxy"] and array_config["socksProxyType"]:
            self.cbxPolipoProx.set_active(True)
            self.txtPolipoProx.set_text(array_config["socksParentProxy"][1:-1])
            for i in self.listPolipoProxy:
                if i[1] == array_config["socksProxyType"]:
                    self.cbPolipoProx.set_active(i[0])
                    break
        else:
            self.cbxPolipoProx.set_active(False)
            self.txtPolipoProx.set_text("")
            self.txtPolipoProx.set_sensitive(False)
            self.cbPolipoProx.set_active(0)

    # запрет на превышение максимального числа в spinButton для минимального значения
    def change_min_tor(self, num):
        if int(num.get_value()) >= int(self.numTraficTorMax.get_value()):
            num.set_value(int(self.numTraficTorMax.get_value()) - 1)

    # запрет на понижение минимального числа в spinButton для максимального значения
    def change_max_tor(self, num):
        if int(num.get_value()) <= int(self.numTraficTorMin.get_value()):
            num.set_value(int(self.numTraficTorMin.get_value()) + 1)

    # Событие на чекбокс Основной ДНС сервер
    # в зависимости от положения - блокирует текстовое поле
    def toggle_prim_dns_serv(self, cbox):
        self.txtPrimDnsServ.set_sensitive(cbox.get_active())

    def toggle_http_prox(self, cbox):
        if cbox.get_active():
            cbox.set_active(True)
            self.txtHttpProx.set_sensitive(True)
            self.txtHttpProx.set_text(configFile["HTTP_PROXY"]) if configFile[
                "HTTP_PROXY"
            ] else None
        else:
            cbox.set_active(False)
            self.txtHttpProx.set_sensitive(False)
            self.txtHttpProx.set_text("")

    def toggle_https_prox(self, cbox):
        if cbox.get_active():
            cbox.set_active(True)
            self.txtHttpsProx.set_sensitive(True)
            self.txtHttpsProx.set_text(configFile["HTTPS_PROXY"]) if configFile[
                "HTTPS_PROXY"
            ] else None
        else:
            cbox.set_active(False)
            self.txtHttpsProx.set_sensitive(False)
            self.txtHttpsProx.set_text("")

    def toggle_ftp_prox(self, cbox):
        if cbox.get_active():
            cbox.set_active(True)
            self.txtFtpProx.set_sensitive(True)
            self.txtFtpProx.set_text(configFile["FTP_PROXY"]) if configFile[
                "FTP_PROXY"
            ] else None
        else:
            cbox.set_active(False)
            self.txtFtpProx.set_sensitive(False)
            self.txtFtpProx.set_text("")

    def toggle_no_prox(self, cbox):
        if cbox.get_active():
            cbox.set_active(True)
            self.txtNoProx.set_sensitive(True)
            self.cbxHttpProx.set_active(False)
            self.txtHttpProx.set_sensitive(False)
            self.cbxHttpsProx.set_active(False)
            self.txtHttpsProx.set_sensitive(False)
            self.cbxFtpProx.set_active(False)
            self.txtFtpProx.set_sensitive(False)
            if configFile["NO_PROXY"]:
                self.txtNoProx.set_text(configFile["NO_PROXY"])
        else:
            cbox.set_active(False)
            self.txtNoProx.set_sensitive(False)
            self.txtNoProx.set_text("")

    def toggle_polipo_prox(self, cbox):
        if cbox.get_active():
            cbox.set_active(True)
            self.txtPolipoProx.set_sensitive(True)
            self.txtPolipoProx.set_text(
                configFile["socksParentProxy"][1:-1]
            ) if configFile["socksParentProxy"] else None
            if configFile["socksProxyType"]:
                for i in self.listPolipoProxy:
                    if i[1] == configFile["socksProxyType"]:
                        self.cbPolipoProx.set_active(i[0])
                        break
            else:
                self.cbPolipoProx.set_active(0)
        else:
            cbox.set_active(False)
            self.txtPolipoProx.set_text("")
            self.txtPolipoProx.set_sensitive(False)
            self.cbPolipoProx.set_active(0)

    ### Сеть ###

    ### Пользователи ###
    def fill_main_window_users(self, array_config):
        self.treeviewListUsers.set_model(self.listUserString)

        self.rendererUid = gtk.CellRendererText()
        self.columnUid = gtk.TreeViewColumn(i18n("UID"), self.rendererUid, text=0)
        self.columnUid.set_sort_column_id(0)
        self.columnUid.set_sizing(gtk.TreeViewColumnSizing.AUTOSIZE)
        self.treeviewListUsers.append_column(self.columnUid)

        self.rendererLogin = gtk.CellRendererText()
        self.columnLogin = gtk.TreeViewColumn(i18n("Login"), self.rendererLogin, text=1)
        self.columnLogin.set_sort_column_id(1)
        self.columnLogin.set_expand(True)
        self.treeviewListUsers.append_column(self.columnLogin)

        self.rendererPass = gtk.CellRendererText()
        self.columnPass = gtk.TreeViewColumn(
            i18n("Password"), self.rendererPass, text=2
        )
        self.columnPass.set_sort_column_id(2)
        self.rendererPass.props.wrap_mode = gtk.WrapMode.WORD
        self.columnPass.set_expand(True)
        self.treeviewListUsers.append_column(self.columnPass)

        self.rendererUsName = gtk.CellRendererText()
        self.columnUsName = gtk.TreeViewColumn(
            i18n("User name"), self.rendererUsName, text=3
        )
        self.columnUsName.set_sort_column_id(3)
        self.columnUsName.set_expand(True)
        self.rendererUsName.props.wrap_mode = gtk.WrapMode.WORD
        self.treeviewListUsers.append_column(self.columnUsName)

        self.txtUsers.set_text(array_config["NEEDEDUSERS"][1:-1]) if array_config[
            "NEEDEDUSERS"
        ] else None

    ### Пользователи ###

    ### Рабочий стол ###
    def fill_main_window_de(self, array_config):
        renderer = gtk.CellRendererText()
        self.cbDe.pack_start(renderer, True)
        self.cbDe.add_attribute(renderer, "text", 1)
        desktop = array_config["DESKTOP"] if array_config["DESKTOP"] else ""
        for i in self.listDe:
            i[1] = i18n(i[1])
        if desktop:
            if desktop == "none":
                self.cbDe.set_active(1)
            elif desktop == "LXDE":
                self.cbDe.set_active(4)
            elif desktop == "GNOME":
                self.cbDe.set_active(2)
            elif desktop == "xfce":
                self.cbDe.set_active(3)
        else:
            self.cbDe.set_active(0)

        self.cbDm.pack_start(renderer, True)
        self.cbDm.add_attribute(renderer, "text", 1)
        dManager = (
            array_config["DISPLAYMANAGER"] if array_config["DISPLAYMANAGER"] else ""
        )
        if dManager:
            if dManager == "slim":
                self.cbDm.set_active(1)
            elif dManager == "GDM":
                self.cbDm.set_active(2)
            elif dManager == "lightdm":
                self.cbDm.set_active(3)
        else:
            self.cbDm.set_active(0)

        defUsedDM = (
            array_config["DISPLAYMANAGER_DEFAULTUSER"]
            if array_config["DISPLAYMANAGER_DEFAULTUSER"]
            else None
        )
        dataUserCombo = (
            array_config["NEEDEDUSERS"][1:-1].split(",")
            if array_config["NEEDEDUSERS"]
            else None
        )

        self.listUsers.append([0, i18n("Default")])
        if dataUserCombo:
            itrUserCombo = 1
            for name in dataUserCombo:
                self.listUsers.append([itrUserCombo, name.split(":")[0]])
                itrUserCombo += 1

        self.cbDisplayUserDef.pack_start(renderer, True)
        self.cbDisplayUserDef.add_attribute(renderer, "text", 1)

        if defUsedDM:
            for i in self.listUsers:
                if i[1] == defUsedDM:
                    self.cbDisplayUserDef.set_active(i[0])
        else:
            self.cbDisplayUserDef.set_active(0)

        self.cbTheme.pack_start(renderer, True)
        self.cbTheme.add_attribute(renderer, "text", 1)
        theme = array_config["THEME"] if array_config["THEME"] else ""
        if theme:
            if theme == "ublinux":
                self.cbTheme.set_active(7)
            elif theme == "ublinux-green":
                self.cbTheme.set_active(8)
            elif theme == "ublinux-dark":
                self.cbTheme.set_active(9)
            elif theme == "arc":
                self.cbTheme.set_active(1)
            elif theme == "arc-dark":
                self.cbTheme.set_active(2)
            elif theme == "arc-darker":
                self.cbTheme.set_active(3)
            elif theme == "arc-lighter":
                self.cbTheme.set_active(4)
            elif theme == "adwaita":
                self.cbTheme.set_active(5)
            elif theme == "adwaita-dark":
                self.cbTheme.set_active(6)
        else:
            self.cbTheme.set_active(0)

        self.cbScreenSaverTheme.pack_start(renderer, True)
        self.cbScreenSaverTheme.add_attribute(renderer, "text", 1)
        sSaveTheme = array_config["SSAVERTHEME"] if array_config["SSAVERTHEME"] else ""
        for i in self.listSsTheme:
            i[1] = i18n(i[1])
        if sSaveTheme:
            if (
                sSaveTheme
                == "/mnt/livedata/ublinux-data/backgrounds/screensaver/default"
            ):
                self.cbScreenSaverTheme.set_active(1)
        else:
            self.cbScreenSaverTheme.set_active(0)

        self.cbSourceWallpaper.pack_start(renderer, True)
        self.cbSourceWallpaper.add_attribute(renderer, "text", 1)
        sourceWlppr = array_config["BACKGROUND"] if array_config["BACKGROUND"] else ""
        self.txtPathWallpaper.set_editable(False)
        for i in self.listTypeWallpapper:
            i[1] = i18n(i[1])
        if sourceWlppr:
            if (
                sourceWlppr
                == "/mnt/livedata/ublinux-data/backgrounds/wallpapers/default"
            ):
                self.cbSourceWallpaper.set_active(1)
                self.txtPathWallpaper.set_text(
                    "/mnt/livedata/ublinux-data/backgrounds/wallpapers/default"
                )
                self.btnClrWallpaper.set_sensitive(False)
                self.btnPathWallpaperChoose.set_sensitive(False)
            elif sourceWlppr == "Color":
                self.cbSourceWallpaper.set_active(2)
                self.txtPathWallpaper.set_text("")
                self.btnClrWallpaper.set_sensitive(True)
                self.btnPathWallpaperChoose.set_sensitive(False)
            elif sourceWlppr == "Personal":
                self.cbSourceWallpaper.set_active(3)
                self.txtPathWallpaper.set_text("")
                self.btnClrWallpaper.set_sensitive(False)
                self.btnPathWallpaperChoose.set_sensitive(True)
        else:
            self.cbSourceWallpaper.set_active(0)
            self.txtPathWallpaper.set_text("")
            self.btnClrWallpaper.set_sensitive(False)
            self.btnPathWallpaperChoose.set_sensitive(True)

        # if sourceWlppr != '/mnt/livedata/ublinux-data/backgrounds/wallpapers/default':
        #     self.cbSourceWallpaper.set_active(2)
        #     self.txtPathWallpaper.set_text(sourceWlppr)
        #     self.btnClrWallpaper.set_sensitive(False)
        #     self.btnPathWallpaperChoose.set_sensitive(True)
        self.cbScaleWallpaper.pack_start(renderer, True)
        self.cbScaleWallpaper.add_attribute(renderer, "text", 1)
        scaleWlppr = (
            array_config["BACKGROUNDMODE"] if array_config["BACKGROUNDMODE"] else ""
        )
        for i in self.listScaleWallpaper:
            i[1] = i18n(i[1])
        if scaleWlppr:
            if scaleWlppr == "0":
                self.cbScaleWallpaper.set_active(1)
            elif scaleWlppr == "1":
                self.cbScaleWallpaper.set_active(2)
            elif scaleWlppr == "2":
                self.cbScaleWallpaper.set_active(3)
        else:
            self.cbScaleWallpaper.set_active(0)

    def change_type_suorce_wallpapper(self, combo):
        self.btnClrWallpaper.set_sensitive(False)
        self.btnPathWallpaperChoose.set_sensitive(False)

        if combo.get_active() == 0:
            self.txtPathWallpaper.set_text("")
        if combo.get_active() == 1:
            self.txtPathWallpaper.set_text(
                "/mnt/livedata/ublinux-data/backgrounds/wallpapers/default"
            )
        elif combo.get_active() == 2:
            self.txtPathWallpaper.set_text("")
            self.btnClrWallpaper.set_sensitive(True)
        elif combo.get_active() == 3:
            self.txtPathWallpaper.set_text("")
            self.btnPathWallpaperChoose.set_sensitive(True)

    def show_dir_chooser(self, button):
        self.wndChooseDirWallpaper.set_transient_for(self.window)
        self.wndChooseDirWallpaper.show()

    def hide_dir_chooser(self, button):
        self.wndChooseDirWallpaper.hide()

    def choose_dir(self, button):
        self.txtPathWallpaper.set_text(self.wndChooseDirWallpaper.get_filename())
        self.wndChooseDirWallpaper.hide()

    ### Рабочий стол ###

    ### Загрузчик ###
    def fill_main_window_grub(self, array_config):
        renderer = gtk.CellRendererText()
        cbIter = 2
        defValueAspm = ""

        self.txtCmdline.set_text(array_config["CMDLINE"][1:-1]) if array_config[
            "CMDLINE"
        ] else None
        self.listAspm.append([0, i18n("Disabled")])
        self.listAspm.append([1, i18n("off")])

        with open("/sys/module/pcie_aspm/parameters/policy") as f:
            dataPcie = f.read().split()

        if dataPcie[0]:
            for i in dataPcie:
                if re.search(r"\[[a-zA-Z0-9]*\]", i):
                    i = i[1:-1]
                    defValueAspm = i18n(i)
                self.listAspm.append([cbIter, i18n(i)])
                cbIter += 1

        cbIter += 1
        self.listAspm.append([cbIter, i18n("force")])

        self.cbAspm.pack_start(renderer, True)
        self.cbAspm.add_attribute(renderer, "text", 1)
        if re.search(r"pcie_aspm=.*", array_config["CMDLINE"][1:-1]):
            if re.search(r"pcie_aspm=off", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(1)
            elif re.search(r"pcie_aspm=default", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(2)
            elif re.search(r"pcie_aspm=performance", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(3)
            elif re.search(r"pcie_aspm=powersave", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(4)
            elif re.search(r"pcie_aspm=powersupersave", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(5)
            elif re.search(r"pcie_aspm=force", array_config["CMDLINE"][1:-1]):
                self.cbAspm.set_active(6)
        else:
            self.cbAspm.set_active(0)

        for i in self.listFixTouchpad:
            i[1] = i18n(i[1])

        self.cbFixTouchpad.pack_start(renderer, True)
        self.cbFixTouchpad.add_attribute(renderer, "text", 1)

        if re.search(r"i8042.nopnp=1", array_config["CMDLINE"][1:-1]) and re.search(
            "pci=nocrs", array_config["CMDLINE"][1:-1]
        ):
            self.cbFixTouchpad.set_active(0)
        else:
            self.cbFixTouchpad.set_active(1)

    def add_aspm_in_cmdline_on_change(self, combo):
        getChooseAsmp = ""
        cmdLineList = self.txtCmdline.get_text().split()
        cmdlineStr = ""
        pcieLineStr = ""
        checkPcieLine = False
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model:
                getChooseAsmp = model[getIter][1]

        for i in range(len(cmdLineList)):
            if re.search(r"pcie_aspm=.*", cmdLineList[i]):
                if getChooseAsmp == i18n("off"):
                    cmdLineList[i] = "pcie_aspm=off"
                elif getChooseAsmp == i18n("default"):
                    cmdLineList[i] = "pcie_aspm=default"
                elif getChooseAsmp == i18n("performance"):
                    cmdLineList[i] = "pcie_aspm=performance"
                elif getChooseAsmp == i18n("powersave"):
                    cmdLineList[i] = "pcie_aspm=powersave"
                elif getChooseAsmp == i18n("powersupersave"):
                    cmdLineList[i] = "pcie_aspm=powersupersave"
                elif getChooseAsmp == i18n("force"):
                    cmdLineList[i] = "pcie_aspm=force"
                else:
                    cmdLineList[i] = ""
                checkPcieLine = True

        if checkPcieLine == False:
            if getChooseAsmp == i18n("off"):
                pcieLineStr = "pcie_aspm=off"
            elif getChooseAsmp == i18n("default"):
                pcieLineStr = "pcie_aspm=default"
            elif getChooseAsmp == i18n("performance"):
                pcieLineStr = "pcie_aspm=performance"
            elif getChooseAsmp == i18n("powersave"):
                pcieLineStr = "pcie_aspm=powersave"
            elif getChooseAsmp == i18n("powersupersave"):
                pcieLineStr = "pcie_aspm=powersupersave"
            elif getChooseAsmp == i18n("force"):
                pcieLineStr = "pcie_aspm=force"
            else:
                pcieLineStr = ""

            cmdLineList.append(pcieLineStr)

        self.txtCmdline.set_text("")

        for i in cmdLineList:
            cmdlineStr += "%s " % i

        self.txtCmdline.set_text(re.sub(r"\ \ ", " ", cmdlineStr)[:-1])

    def switch_fix_touchpad(self, combo):
        getChooseFixTp = ""
        cmdLineList = self.txtCmdline.get_text()
        cmdlineStr = ""

        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model:
                getChooseFixTp = model[getIter][1]

        if getChooseFixTp == i18n("yes"):
            if re.search("i8042.nopnp=1", cmdLineList) and re.search(
                "pci=nocrs", cmdLineList
            ):
                pass
            elif not re.search("i8042.nopnp=1", cmdLineList) and re.search(
                "pci=nocrs", cmdLineList
            ):
                cmdLineList += " i8042.nopnp=1"
            elif re.search("i8042.nopnp=1", cmdLineList) and not re.search(
                "pci=nocrs", cmdLineList
            ):
                cmdLineList += " pci=nocrs"
            else:
                cmdLineList += " i8042.nopnp=1 pci=nocrs"
        elif getChooseFixTp == i18n("no"):
            cmdLineList = re.sub("i8042.nopnp=1", "", cmdLineList)
            cmdLineList = re.sub("pci=nocrs", "", cmdLineList)
            cmdLineList = re.sub(r"\ \ ", " ", cmdLineList)
            cmdLineList = re.sub(r"\ $", "", cmdLineList)

        self.txtCmdline.set_text(cmdLineList)

    ### Загрузчик ###

    ### Дата и время ###
    def fill_main_window_date_time(self, configFile):

        # получение корректной даты-время
        self.txtDate.set_editable(False)
        self.currDateY = datetime.datetime.now().year
        self.currDateM = datetime.datetime.now().month
        self.currDateD = datetime.datetime.now().day
        self.currTimeH = datetime.datetime.now().hour
        self.currTimeM = datetime.datetime.now().minute

        # определение, включен ли ntp
        ntpIsEnabled = (
            subprocess.getstatusoutput(
                'systemctl status ntpd.service systemd-timesyncd.service | grep "Active: active"'
            )[0]
            == 0
        )
        self.cbxAutoDataTime.set_active(ntpIsEnabled)
        self.numTimeHrs.set_sensitive(not ntpIsEnabled)
        self.numTimeMin.set_sensitive(not ntpIsEnabled)
        self.txtDate.set_sensitive(not ntpIsEnabled)
        self.btnChooseDate.set_sensitive(not ntpIsEnabled)
        # self.cbxDhcp.set_sensitive(ntpIsEnabled)
        # self.txtNtpServer.set_sensitive(ntpIsEnabled)

        # добавить 0 в одинарные значения, для более красивого вывода
        self.currDateMWithZero = (
            "0" + str(self.currDateM)
            if len(str(self.currDateM)) == 1
            else str(self.currDateM)
        )
        self.currDateDWithZero = (
            "0" + str(self.currDateD)
            if len(str(self.currDateD)) == 1
            else str(self.currDateD)
        )

        self.numTimeHrs.set_increments(1, 10)
        self.numTimeMin.set_increments(1, 10)
        self.numTimeHrs.set_range(0, 23)
        self.numTimeMin.set_range(0, 59)

        self.numTimeHrs.set_value(self.currTimeH)
        self.numTimeMin.set_value(self.currTimeM)

        self.chckCrrhrs = True
        self.chckCrrMin = True

        self.txtDate.set_text(
            self.currDateDWithZero
            + "."
            + self.currDateMWithZero
            + "."
            + str(self.currDateY)
        )

    # вызов поп-меню с календарем
    def open_calendar_pop(self, button):
        self.cldrDate.select_day(self.currDateD)
        self.cldrDate.select_month(self.currDateM - 1, self.currDateY)
        self.popCalendar.show()

    # выбор дня в календаре
    def select_day_calendar(self, calendar):
        self.currDateMWithZero = (
            "0" + str(calendar.get_date()[1] + 1)
            if len(str(calendar.get_date()[1] + 1)) == 1
            else str(calendar.get_date()[1] + 1)
        )
        self.currDateDWithZero = (
            "0" + str(calendar.get_date()[2])
            if len(str(calendar.get_date()[2])) == 1
            else str(calendar.get_date()[2])
        )
        self.txtDate.set_text(
            self.currDateDWithZero
            + "."
            + self.currDateMWithZero
            + "."
            + str(calendar.get_date()[0])
        )

    # переключение ntp и обновление времени
    def set_ntp_toggle(self, toggle):
        if toggle.get_active():
            getErrorCode = subprocess.getstatusoutput(
                "systemctl --now enable systemd-timesyncd.service"
            )
            if int(getErrorCode[0]) == 0:
                if not "systemd-timesyncd" in self.servicesString:
                    self.startServicesList.append("systemd-timesyncd")

                # self.cbZone.set_active(0)
                for i in self.listReg:
                    if i[1][10:] == "Omsk":
                        self.cbRegion.set_active(i[0])

                self.change_switch_while_ntp(True)
            else:
                self.change_switch_while_ntp(False)

                self.wndErrorMsg.set_title(i18n("Error!"))
                errorMsg = str(
                    i18n("Failed to enable automatic time setting")
                    + "\n\n"
                    + getErrorCode[1]
                )
                self.lblErrorMsg.set_label(errorMsg)
                self.wndErrorMsg.set_transient_for(self.window)
                self.wndErrorMsg.show()
        else:
            getErrorCode = subprocess.getstatusoutput(
                "systemctl --now disable systemd-timesyncd.service ntpd.service"
            )
            if int(getErrorCode[0]) == 0:
                if "npd" in self.startServicesList:
                    self.startServicesList.remove("ntpd")
                if "systemd-timesyncd" in self.startServicesList:
                    self.startServicesList.remove("systemd-timesyncd")

                self.change_switch_while_ntp(False)
                zone = configFile["ZONE"].split("/")[0] if configFile["ZONE"] else None
                reg = configFile["ZONE"].split("/")[1] if configFile["ZONE"] else None

                if zone and reg:
                    for zones in self.listZone:
                        if zones[1] == zone:
                            self.cbZone.set_active(zones[0])
                    for regs in self.listReg:
                        if regs[1] == reg[10:]:
                            self.cbRegion.set_active(regs[0])
                else:
                    pass
                    # self.cbZone.set_active(0)
                    # self.cbRegion.set_sensitive(False)
            else:
                self.change_switch_while_ntp(True)

                self.wndErrorMsg.set_title(i18n("Error!"))
                errorMsg = str(
                    i18n("Couldn't turn off the automatic time setting")
                    + "\n\n"
                    + getErrorCode[1]
                )
                self.lblErrorMsg.set_label(errorMsg)
                self.wndErrorMsg.set_transient_for(self.window)
                self.wndErrorMsg.show()

    def change_switch_while_ntp(self, check):
        self.cbxAutoDataTime.set_active(check)
        self.numTimeHrs.set_sensitive(not check)
        self.numTimeMin.set_sensitive(not check)
        self.txtDate.set_sensitive(not check)
        self.btnChooseDate.set_sensitive(not check)
        # self.cbxDhcp.set_sensitive(check)
        # self.txtNtpServer.set_sensitive(check)

    def update_time_date(self, button):
        zoneChoose = ""
        regChoose = ""
        getIterZone = self.cbZone.get_active_iter()
        if getIterZone:
            modelZone = self.cbZone.get_model()
            zoneChoose = modelZone[getIterZone][1]

        getIterReg = self.cbRegion.get_active_iter()
        if getIterReg:
            modelReg = self.cbRegion.get_model()
            regChoose = modelReg[getIterReg][1][10:]

        dateStr = (
            str(self.txtDate.get_text()).split(".")[2]
            + "-"
            + str(self.txtDate.get_text()).split(".")[1]
            + "-"
            + str(self.txtDate.get_text()).split(".")[0]
        )
        timeStr = (
            str(self.numTimeHrs.get_value())[:-2]
            + ":"
            + str(self.numTimeMin.get_value())[:-2]
            + ":00"
        )

        if modelZone[getIterZone][0] != 0:
            getErrorCode = subprocess.getstatusoutput(
                'rm -f /etc/localtime && ln -s /usr/share/zoneinfo/{0}/{1} /etc/localtime && timedatectl set-timezone {0}/{1} && date +"%Y-%m-%d %T" -s "{2} {3}"'.format(
                    zoneChoose, regChoose, dateStr, timeStr
                )
            )
        else:
            getErrorCode = subprocess.getstatusoutput(
                'rm -f /etc/localtime /etc/ublinux/clock && date +"%Y-%m-%d %T" -s "{0} {1}"'.format(
                    dateStr, timeStr
                )
            )
        if int(getErrorCode[0]) != 0:
            self.wndErrorMsg.set_title(i18n("Error!"))
            errorMsg = str(
                i18n("The date and time could not be updated")
                + "\n\n"
                + getErrorCode[1]
            )
        else:
            self.wndErrorMsg.set_title(i18n("Complete"))
            errorMsg = i18n("Date and time updated successfully")

        self.lblErrorMsg.set_label(errorMsg)
        self.wndErrorMsg.set_transient_for(self.window)
        self.wndErrorMsg.show()

    ### Дата и время ###

    ### Оборудование ###
    def fill_main_window_date_Devices(self, array_config):
        renderer = gtk.CellRendererText()

        isFREEVGADRV = array_config["FREEVGADRV"] == "yes"
        self.cbxPropDriver.set_active(isFREEVGADRV)
        self.txtDriverFailsafeAmd.set_sensitive(not isFREEVGADRV)
        self.txtDriverFailsafeNvidia.set_sensitive(not isFREEVGADRV)

        if array_config["FAILSAFEATI"]:
            self.txtDriverFailsafeAmd.set_text(array_config["FAILSAFEATI"])
        if array_config["FAILSAFENVIDIA"]:
            self.txtDriverFailsafeNvidia.set_text(array_config["FAILSAFENVIDIA"])

        self.cbResolution.pack_start(renderer, True)
        self.cbResolution.add_attribute(renderer, "text", 1)

        if array_config["XORG_RES"]:
            for i in self.listResolution:
                if i[1] == array_config["XORG_RES"]:
                    self.cbResolution.set_active(i[0])
        else:
            self.cbResolution.set_active(0)

        for i in self.listResolution:
            if i:
                i[1] = i18n(i[1])

        self.cbxDpms.set_active(array_config["DPMS"] == "yes")

        self.cbNvidiaRun.pack_start(renderer, True)
        self.cbNvidiaRun.add_attribute(renderer, "text", 1)

        if array_config["OPTIRUN"]:
            self.cbNvidiaRun.set_active(1)
            self.txtNvidiaRun.set_text(array_config["OPTIRUN"])
        elif array_config["PRIMUSRUN"]:
            self.cbNvidiaRun.set_active(2)
            self.txtNvidiaRun.set_text(array_config["PRIMUSRUN"])
        else:
            self.cbNvidiaRun.set_active(0)
            self.txtNvidiaRun.set_text("")

        self.cbxIgpu.set_active(True) if array_config[
            "INTEGRATEDVGA"
        ] else self.cbxIgpu.set_active(False)

        self.cbFixCropFps.pack_start(renderer, True)
        self.cbFixCropFps.add_attribute(renderer, "text", 1)

        for i in self.listFixFps:
            i[1] = i18n(i[1])

        if array_config["export __GL_YIELD"]:
            self.cbxFixCropFps.set_active(True)
            self.cbFixCropFps.set_sensitive(True)
            self.cbFixCropFps.set_active(0)
        elif array_config["export KWIN_TRIPLE_BUFFER"]:
            self.cbxFixCropFps.set_active(True)
            self.cbFixCropFps.set_sensitive(True)
            self.cbFixCropFps.set_active(1)

        self.cbxPulseAudio.set_active(array_config["PULSEAUDIO"] == "yes")

        if self.checkAplay:
            listAllAudioCard = [[]]
            iterCards = 1

            # получение списка звуковых карт
            getErrorCode = subprocess.getstatusoutput("aplay -l | grep card")

            if getErrorCode[0] == 0:
                for i in getErrorCode[1].split("\n"):
                    listAllAudioCard.append(i.split(",")[0].split(":")[1])

            listAllAudioCard.pop(0)
            listAllAudioCard = list(set(listAllAudioCard))

            self.listAudioCards.append([0, i18n("Default")])

            for i in listAllAudioCard:
                self.listAudioCards.append([iterCards, i[1:]])
                iterCards += 1

            self.cbDeviceOutput.set_model(self.listAudioCards)
            self.cbDeviceOutput.pack_start(renderer, True)
            self.cbDeviceOutput.add_attribute(renderer, "text", 1)

            # парсинг вывода и вывод в комбобоксы
            if array_config["ALSACARD"]:
                strCommand = 'aplay -l | grep "card {}:"'.format(
                    array_config["ALSACARD"]
                )
                getErrorCode = subprocess.getstatusoutput(strCommand)
                if getErrorCode:
                    cardName = (
                        getErrorCode[1].split("\n")[0].split(",")[0].split(":")[1][1:]
                    )
                for i in self.listAudioCards:
                    if cardName == i[1]:
                        self.cbDeviceOutput.set_active(i[0])
            else:
                self.cbDeviceOutput.set_active(0)

            if array_config["ALSADEVICE"]:
                strCommand = 'aplay -l | grep "device {}:"'.format(
                    array_config["ALSADEVICE"]
                )
                getErrorCode = subprocess.getstatusoutput(strCommand)
                if getErrorCode:
                    devName = (
                        getErrorCode[1].split("\n")[0].split(",")[1].split(":")[1][1:]
                    )
                for i in self.listAudioDevs:
                    if devName == i[1]:
                        self.cbPortOutput.set_active(i[0])
            else:
                self.cbPortOutput.set_active(0)

        self.cbAddPrinter.pack_start(renderer, True)
        self.cbAddPrinter.add_attribute(renderer, "text", 1)

        if array_config["PRINTERADD"] == "manual":
            self.cbAddPrinter.set_active(1)
        elif array_config["PRINTERADD"] == "auto":
            self.cbAddPrinter.set_active(2)
        elif array_config["PRINTERADD"] == "disable":
            self.cbAddPrinter.set_active(3)
        else:
            self.cbAddPrinter.set_active(0)

        for i in self.listPrintAdd:
            i[1] = i18n(i[1])

        self.cbxParkingHead.set_active(True) if array_config[
            "CONTROL_HD_POWERMGMT"
        ] == "1" else self.cbxParkingHead.set_active(False)

    # вывод в комбобокс с устройством в зависимости от карты
    def set_audio_card(self, combo):
        if self.checkAplay:
            self.cbPortOutput.clear()
            self.listAudioDevs.clear()
            renderer = gtk.CellRendererText()
            cardName = self.listAudioCards[combo.get_active()][1]
            cardName = re.sub(r"\[", "\[", cardName)
            cardName = re.sub(r"\]", "\]", cardName)
            strCommand = 'aplay -l | grep "{}"'.format(cardName)
            listAllAudioDev = [[]]
            iterDevs = 1

            getErrorCode = subprocess.getstatusoutput(strCommand)

            if getErrorCode[0] == 0:
                for i in getErrorCode[1].split("\n"):
                    listAllAudioDev.append(i.split(",")[1].split(":")[1])

            listAllAudioDev.pop(0)

            self.listAudioDevs.append([0, i18n("Default")])

            for i in listAllAudioDev:
                self.listAudioDevs.append([iterDevs, i[1:]])
                iterDevs += 1

            self.cbPortOutput.set_model(self.listAudioDevs)
            self.cbPortOutput.pack_start(renderer, True)
            self.cbPortOutput.add_attribute(renderer, "text", 1)
            self.cbPortOutput.set_active(0)
        else:
            return

    def set_fix_gpu_toggle(self, toggle):
        if toggle.get_active():
            self.cbFixCropFps.set_sensitive(True)
            if configFile["export KWIN_TRIPLE_BUFFER"]:
                self.cbFixCropFps.set_active(1)
            else:
                self.cbFixCropFps.set_active(0)
        else:
            self.cbFixCropFps.set_sensitive(False)

    def set_prop_driver_toggle(self, toggle):
        self.cbxPropDriver.set_active(toggle.get_active())
        self.txtDriverFailsafeAmd.set_sensitive(not toggle.get_active())
        self.txtDriverFailsafeNvidia.set_sensitive(not toggle.get_active())

    def show_choose_prog(self, button):
        self.wndEditPrograms.set_transient_for(self.window)
        self.wndEditPrograms.show()

    def init_choose_prog(self, wnd):
        self.txtNvidiaRun.set_editable(False)
        getErrorCode = subprocess.getstatusoutput("pacman -Qqet")
        listAllProg = [[]]
        listTxtProg = str(self.txtNvidiaRun.get_text()).split(",")
        if getErrorCode[0] == 0:
            listProgTmp = getErrorCode[1].split("\n")
            check = False
            for prog in listProgTmp:
                if listTxtProg:
                    for txtProg in listTxtProg:
                        if prog == txtProg:
                            check = True
                            break
                    listAllProg.append([check, prog])
                    if check:
                        check = False
                else:
                    listAllProg.append([False, prog])

        listAllProg.pop(0)
        listAllProg.sort(key=lambda x: x[1])

        for i in listAllProg:
            self.listProg.append(i)

        self.treeViewProg.set_model(self.listProg)

        renderer_toggle = gtk.CellRendererToggle()
        renderer_toggle.connect("toggled", self.on_cell_toggled_prog)
        self.columnToggleProg = gtk.TreeViewColumn("", renderer_toggle, active=0)
        self.treeViewProg.append_column(self.columnToggleProg)

        renderer_text = gtk.CellRendererText()
        self.columnNameProg = gtk.TreeViewColumn(
            i18n("Programms"), renderer_text, text=1
        )
        self.treeViewProg.append_column(self.columnNameProg)

    def on_cell_toggled_prog(self, toggle, path):
        self.listProg[path][0] = not self.listProg[path][0]

    def set_choosing_prog(self, button):
        strProgs = ""
        for i in self.listProg:
            if i[0]:
                strProgs += i[1] + ","

        if strProgs:
            self.txtNvidiaRun.set_text(strProgs[:-1])
        else:
            self.txtNvidiaRun.set_text("")
        self.clear_progs()
        self.wndEditPrograms.hide()

    def clear_progs(self):
        self.listProg.clear()
        self.treeViewProg.set_model(model=None)
        self.treeViewProg.remove_column(self.columnToggleProg)
        self.treeViewProg.remove_column(self.columnNameProg)

    def hide_choose_prog(self, button):
        self.clear_progs()
        self.wndEditPrograms.hide()

    ### Оборудование ###

    # внесение нужных параметров к массив
    def save_changes(self, button):
        

        
        ### Основные ###
        configFile["CMDLINE"] = (
            '"' + self.txtCmdline.get_text() + '"'
            if str(self.txtCmdline.get_text())
            else ""
        )
        configFile["HOSTNAME"] = (
            self.txtHostname.get_text() if str(self.txtHostname.get_text()) else ""
        )
        if self.cbxRandomid.get_active():
            configFile["MACHINEID"] = "RANDOM"
        else:
            configFile["MACHINEID"] = (
                self.txtMachinieId.get_text()
                if str(self.txtHostname.get_text())
                else ""
            )
        configFile["NEEDEDUSERS"] = (
            "'" + self.txtUsers.get_text() + "'"
            if str(self.txtUsers.get_text())
            else ""
        )
        configFile["USERGROUPS"] = (
            self.txtGroups.get_text() if str(self.txtGroups.get_text()) else ""
        )
        configFile["ADDADM"] = "yes" if self.cbxAdmin.get_active() else "no"

        hashType = 0
        getIterHashPass = self.cbHashingAlgPass.get_active_iter()
        if getIterHashPass:
            modelHashPass = self.cbHashingAlgPass.get_model()
            hashType = int(modelHashPass[getIterHashPass][0])
            hashPass = (
                self.crypt_pass(self.txtPasswd.get_text(), hashType)
                if self.txtPasswd.get_text()
                else ""
            )
        configFile["DEFAULTPASSWD"] = (
            "'" + hashPass + "'" if hashPass else configFile["DEFAULTPASSWD"]
        )
        self.txtPasswd.set_text("")

        if not configFile["AUTOLOGINUSER"] and not self.cbxAutologin.get_active():
            configFile["AUTOLOGINUSER"] = ""
        elif self.cbxAutologin.get_active():
            getIterUser = self.cbAutologinUser.get_active_iter()
            if getIterUser:
                modelUser = self.cbAutologinUser.get_model()
                configFile["AUTOLOGINUSER"] = modelUser[getIterUser][1]
        else:
            configFile["AUTOLOGINUSER"] = "none"

        if not configFile["UPDATEHOME"] and not self.cbxEnableHome.get_active():
            configFile["UPDATEHOME"] = ""
        elif self.cbxEnableHome.get_active():
            configFile["UPDATEHOME"] = "yes"
        else:
            configFile["UPDATEHOME"] = "no"

        if not configFile["TMPFS"] and not self.cbxTmp.get_active():
            configFile["TMPFS"] = ""
        elif self.cbxTmp.get_active():
            configFile["TMPFS"] = "yes"
        else:
            configFile["TMPFS"] = "no"

        if not configFile["VARTMPFS"] and not self.cbxVarTmp.get_active():
            configFile["VARTMPFS"] = ""
        elif self.cbxVarTmp.get_active():
            configFile["VARTMPFS"] = "yes"
        else:
            configFile["VARTMPFS"] = "no"

        configFile["AUTOEXEC"] = (
            '"' + self.txtAutoexec.get_text() + '"'
            if str(self.txtAutoexec.get_text())
            else ""
        )
        getIterZone = self.cbZone.get_active_iter()
        getIterReg = self.cbRegion.get_active_iter()
        if getIterZone and getIterReg:
            modelZone = self.cbZone.get_model()
            modelReg = self.cbRegion.get_model()
            if modelZone[getIterZone][0] != 0:
                configFile["ZONE"] = (
                    modelZone[getIterZone][1] + "/" + modelReg[getIterReg][1][10:]
                )
            else:
                configFile["ZONE"] = ""
        else:
            modelZone = self.cbZone.get_model()
            if modelZone[getIterZone][0] == 0:
                configFile["ZONE"] = ""

        configFile["NTPSERVERS"] = (
            "dhcp" if self.cbxDhcp.get_active() else self.txtNtpServer.get_text()
        )

        getIterCryptMtd = self.cbHashingAlgPassDes.get_active_iter()
        if getIterCryptMtd:
            modelCryptMtd = self.cbHashingAlgPassDes.get_model()
            configFile["HASHPASSWD"] = (
                ""
                if modelCryptMtd[getIterCryptMtd][1] == i18n("Default")
                else modelCryptMtd[getIterCryptMtd][1]
            )

        getIterLang = self.cbLocale.get_active_iter()
        if getIterLang:
            modelLang = self.cbLocale.get_model()
            if modelLang[getIterLang][1] == i18n("Russian"):
                configFile["LC_TELEPHONE"] = "ru_RU.UTF-8"
                configFile["LC_CTYPE"] = "ru_RU.UTF-8"
                configFile["LANGUAGE"] = "ru_RU.UTF-8:ru_RU:ru"
                configFile["LC_MONETARY"] = "ru_RU.UTF-8"
                configFile["LC_ADDRESS"] = "ru_RU.UTF-8"
                configFile["LC_COLLATE"] = "ru_RU.UTF-8"
                configFile["LC_PAPER"] = "ru_RU.UTF-8"
                configFile["LC_NAME"] = "ru_RU.UTF-8"
                configFile["LC_NUMERIC"] = "ru_RU.UTF-8"
                configFile["LC_MEASUREMENT"] = "ru_RU.UTF-8"
                configFile["LC_TIME"] = "ru_RU.UTF-8"
                configFile["LANG"] = "ru_RU.UTF-8"
                configFile["LC_IDENTIFICATION"] = "ru_RU.UTF-8"
                configFile["LC_MESSAGES"] = "ru_RU.UTF-8"
            elif modelLang[getIterLang][1] == i18n("English"):
                configFile["LC_TELEPHONE"] = "en_US.UTF-8"
                configFile["LC_CTYPE"] = "en_US.UTF-8"
                configFile["LANGUAGE"] = "en_US.UTF-8:en_US:en"
                configFile["LC_MONETARY"] = "en_US.UTF-8"
                configFile["LC_ADDRESS"] = "en_US.UTF-8"
                configFile["LC_COLLATE"] = "en_US.UTF-8"
                configFile["LC_PAPER"] = "en_US.UTF-8"
                configFile["LC_NAME"] = "en_US.UTF-8"
                configFile["LC_NUMERIC"] = "en_US.UTF-8"
                configFile["LC_MEASUREMENT"] = "en_US.UTF-8"
                configFile["LC_TIME"] = "en_US.UTF-8"
                configFile["LANG"] = "en_US.UTF-8"
                configFile["LC_IDENTIFICATION"] = "en_US.UTF-8"
                configFile["LC_MESSAGES"] = "en_US.UTF-8"
            else:
                configFile["LC_TELEPHONE"] = ""
                configFile["LC_CTYPE"] = ""
                configFile["LANGUAGE"] = ""
                configFile["LC_MONETARY"] = ""
                configFile["LC_ADDRESS"] = ""
                configFile["LC_COLLATE"] = ""
                configFile["LC_PAPER"] = ""
                configFile["LC_NAME"] = ""
                configFile["LC_NUMERIC"] = ""
                configFile["LC_MEASUREMENT"] = ""
                configFile["LC_TIME"] = ""
                configFile["LANG"] = ""
                configFile["LC_IDENTIFICATION"] = ""
                configFile["LC_MESSAGES"] = ""

        getIterKeymap = self.cbKeymap.get_active_iter()
        if getIterKeymap:
            modelKeymap = self.cbKeymap.get_model()
            if modelKeymap[getIterKeymap][1] == i18n("Russian"):
                configFile["KEYMAP"] = "ru"
            elif modelKeymap[getIterKeymap][1] == i18n("English"):
                configFile["KEYMAP"] = "en"
            else:
                configFile["KEYMAP"] = ""

        getIterFontConsole = self.cbFontConsole.get_active_iter()
        if getIterFontConsole:
            modelFontConsole = self.cbFontConsole.get_model()
            configFile["FONT"] = (
                ""
                if modelFontConsole[getIterFontConsole][1] == i18n("Default")
                else modelFontConsole[getIterFontConsole][1]
            )

            # configFile["FONT"] = modelFontConsole[getIterFontConsole][1]
        getIterNumLock = self.cbNumLock.get_active_iter()
        if getIterNumLock:
            modelNumLock = self.cbNumLock.get_model()
            if modelNumLock[getIterNumLock][1] == i18n("On"):
                configFile["NUMLOCK"] = "yes"
            elif modelNumLock[getIterNumLock][1] == i18n("Off"):
                configFile["NUMLOCK"] = "no"
            else:
                configFile["NUMLOCK"] = ""

        if (
            not configFile["PARTITIONSAUTOMOUNT"]
            and not self.cbxConnectAllPart.get_active()
        ):
            configFile["PARTITIONSAUTOMOUNT"] = ""
        elif self.cbxConnectAllPart.get_active():
            configFile["PARTITIONSAUTOMOUNT"] = "yes"
        else:
            configFile["PARTITIONSAUTOMOUNT"] = "no"

        configFile["PARTITIONSNOMOUNT"] = (
            self.txtDontConnectPart.get_text()
            if self.cbxDontConnectPart.get_active()
            else ""
        )
        with open("/etc/passwd") as f:
            dataUser = f.read().split("\n")
        userUid = ""
        for usr in dataUser:
            if usr and usr.split(":")[0] == self.txtUserNtfsOwner.get_text():
                userUid = usr.split(":")[2]
                break
        configFile["PARTITIONSMOUNTUID"] = userUid if userUid else ""
        getIterAutoUpdateSys = self.cbAutoUpdateSys.get_active_iter()
        if getIterAutoUpdateSys:
            modelAutoUpdateSys = self.cbAutoUpdateSys.get_model()
            if modelAutoUpdateSys[getIterAutoUpdateSys][1] == i18n("Auto"):
                configFile["UBLINUXUPDATE"] = "auto"
            elif modelAutoUpdateSys[getIterAutoUpdateSys][1] == i18n("ask"):
                configFile["UBLINUXUPDATE"] = "ask"
            elif modelAutoUpdateSys[getIterAutoUpdateSys][1] == i18n("never"):
                configFile["UBLINUXUPDATE"] = "never"
            else:
                configFile["UBLINUXUPDATE"] = ""
        configFile["MKSQFS_OPTS"] = (
            '"' + self.txtAlgCompressDef.get_text() + '"'
            if self.txtAlgCompressDef.get_text()
            else ""
        )
        configFile["MKSQFS_FASTALG"] = (
            '"' + self.txtAlgForSaveModul.get_text() + '"'
            if self.txtAlgForSaveModul.get_text()
            else ""
        )
        ### Основные ###

        ### Службы ###
        servList = ""
        for serv in self.startServicesList:
            if serv:
                servList += serv + ","
        if servList:
            configFile["SERVICESSTART"] = servList[:-1]
        ### Службы ###

        ### Сеть ###
        getIterNetDev = self.cbNetInterface.get_active_iter()
        if getIterNetDev:
            modelNetDeve = self.cbNetInterface.get_model()
            configFile["DEVICE"] = (
                ""
                if modelNetDeve[getIterNetDev][1] == i18n("Default")
                else modelNetDeve[getIterNetDev][1]
            )

        if not configFile["ONBOOT"] and not self.cbxAutoRun.get_active():
            configFile["ONBOOT"] = ""
        elif self.cbxAutoRun.get_active():
            configFile["ONBOOT"] = "yes"
        else:
            configFile["ONBOOT"] = "no"

        configFile["DHCP_CLIENT"] = (
            self.txtAltDhcp.get_text() if self.txtAltDhcp.get_text() else ""
        )
        configFile["IPADDR"] = (
            self.txtIpAdr.get_text() if self.txtIpAdr.get_text() else ""
        )
        configFile["NETMASK"] = (
            self.txtMask.get_text() if self.txtMask.get_text() else ""
        )
        configFile["GATEWAY"] = (
            self.txtRout.get_text() if self.txtRout.get_text() else ""
        )

        getIterMiiNotSupp = self.cbMiiNotSupp.get_active_iter()
        if getIterMiiNotSupp:
            modelMiiNotSupp = self.cbMiiNotSupp.get_model()
            if modelMiiNotSupp[getIterMiiNotSupp][1] == i18n("yes"):
                configFile["MII_NOT_SUPPORTED"] = "yes"
            elif modelMiiNotSupp[getIterMiiNotSupp][1] == i18n("no"):
                configFile["MII_NOT_SUPPORTED"] = "no"
            else:
                configFile["MII_NOT_SUPPORTED"] = ""

        configFile["DNS1"] = (
            self.txtDnsServ.get_text() if self.txtDnsServ.get_text() else ""
        )
        configFile["IPTABLESOPENPORTSTCP"] = (
            self.txtExceptFireTcp.get_text() if self.txtExceptFireTcp.get_text() else ""
        )
        configFile["IPTABLESOPENPORTSUDP"] = (
            self.txtExeptFireUdp.get_text() if self.txtExeptFireUdp.get_text() else ""
        )
        configFile["IPTABLESTRUSTEDIP"] = (
            self.txtTrustIp.get_text() if self.txtTrustIp.get_text() else ""
        )

        if not configFile["NSSWITCHAVAHI"] and not self.cbxAvahi.get_active():
            configFile["NSSWITCHAVAHI"] = ""
        elif self.cbxAvahi.get_active():
            configFile["NSSWITCHAVAHI"] = "yes"
        else:
            configFile["NSSWITCHAVAHI"] = "no"

        if not configFile["NSSWITCHWINBIND"] and not self.cbxWinbind.get_active():
            configFile["NSSWITCHWINBIND"] = ""
        elif self.cbxWinbind.get_active():
            configFile["NSSWITCHWINBIND"] = "yes"
        else:
            configFile["NSSWITCHWINBIND"] = "no"

        configFile["ip"] = (
            self.txtPrimDnsServ.get_text() if self.cbPrimDnsServ.get_active() else ""
        )

        if not configFile["IPV6"] and not self.cbxIpV6.get_active():
            configFile["IPV6"] = ""
        elif self.cbxIpV6.get_active():
            configFile["IPV6"] = "yes"
        else:
            configFile["IPV6"] = "no"

        if not configFile["ROUTER"] and not self.cbxRouteMode.get_active():
            configFile["ROUTER"] = ""
        elif self.cbxRouteMode.get_active():
            configFile["ROUTER"] = "yes"
        else:
            configFile["ROUTER"] = "no"

        configFile["HTTP_PROXY"] = (
            self.txtHttpProx.get_text() if self.cbxHttpProx.get_active() else ""
        )
        configFile["HTTPS_PROXY"] = (
            self.txtHttpsProx.get_text() if self.cbxHttpsProx.get_active() else ""
        )
        configFile["FTP_PROXY"] = (
            self.txtFtpProx.get_text() if self.cbxFtpProx.get_active() else ""
        )
        configFile["NO_PROXY"] = (
            self.txtNoProx.get_text() if self.cbxNoProx.get_active() else ""
        )
        configFile["socksParentProxy"] = (
            '"' + self.txtPolipoProx.get_text() + '"'
            if self.cbxPolipoProx.get_active()
            else ""
        )
        getIterPolipoProx = self.cbPolipoProx.get_active_iter()
        if getIterPolipoProx:
            modelPolipoProx = self.cbPolipoProx.get_model()
            configFile["socksProxyType"] = (
                ""
                if modelPolipoProx[getIterPolipoProx][1] == i18n("Default")
                else modelPolipoProx[getIterPolipoProx][1]
            )
        configFile["TORUSERS"] = (
            str(self.numTraficTorMin.get_value())[:-2]
            + "-"
            + str(self.numTraficTorMax.get_value())[:-2]
            if self.cbxTraficTor.get_active()
            else ""
        )
        ### Сеть ###

        ### Рабочий стол ###
        getIterDe = self.cbDe.get_active_iter()
        if getIterDe:
            modelDe = self.cbDe.get_model()
            if modelDe[getIterDe][1] == i18n("none"):
                configFile["DESKTOP"] = "none"
            elif modelDe[getIterDe][1] == i18n("Default"):
                configFile["DESKTOP"] = ""
            else:
                configFile["DESKTOP"] = str(modelDe[getIterDe][1]).lower()

        getIterDm = self.cbDm.get_active_iter()
        if getIterDm:
            modelDm = self.cbDm.get_model()
            configFile["DISPLAYMANAGER"] = (
                ""
                if modelDm[getIterDm][1] == i18n("Default")
                else str(modelDm[getIterDm][1]).lower()
            )

        getIterDeDefUser = self.cbDisplayUserDef.get_active_iter()
        if getIterDeDefUser:
            modelDeDefUser = self.cbDisplayUserDef.get_model()
            configFile["DISPLAYMANAGER_DEFAULTUSER"] = (
                ""
                if modelDeDefUser[getIterDeDefUser][1] == i18n("Default")
                else modelDeDefUser[getIterDeDefUser][1]
            )

        getIterTheme = self.cbTheme.get_active_iter()
        if getIterTheme:
            modelTheme = self.cbTheme.get_model()
            configFile["THEME"] = (
                ""
                if modelTheme[getIterTheme][1] == i18n("Default")
                else str(modelTheme[getIterTheme][1]).lower()
            )

        getIterSsTheme = self.cbScreenSaverTheme.get_active_iter()
        if getIterSsTheme:
            modelSsTheme = self.cbScreenSaverTheme.get_model()
            if modelSsTheme[getIterSsTheme][1] == i18n("Standart"):
                configFile[
                    "SSAVERTHEME"
                ] = "/mnt/livedata/ublinux-data/backgrounds/screensaver/default"
            elif modelSsTheme[getIterSsTheme][1] == i18n("Default"):
                configFile["SSAVERTHEME"] = ""

        getIterWllppr = self.cbSourceWallpaper.get_active_iter()
        if getIterWllppr:
            modelWllppr = self.cbSourceWallpaper.get_model()
            if modelWllppr[getIterWllppr][1] == i18n("Standart"):
                configFile[
                    "BACKGROUND"
                ] = "/mnt/livedata/ublinux-data/backgrounds/wallpapers/default"
            elif modelWllppr[getIterWllppr][1] == i18n("Default"):
                configFile["BACKGROUND"] = ""
            elif modelWllppr[getIterWllppr][1] == i18n("Personal"):
                configFile["BACKGROUND"] = self.txtPathWallpaper.get_text()

        getIterWllpprScale = self.cbScaleWallpaper.get_active_iter()
        if getIterWllpprScale:
            modelWllpprScale = self.cbScaleWallpaper.get_model()
            if modelWllpprScale[getIterWllpprScale][1] == i18n("Default"):
                configFile["BACKGROUNDMODE"] = ""
            elif modelWllpprScale[getIterWllpprScale][1] == i18n(
                "Stretch proportionally on background color"
            ):
                configFile["BACKGROUNDMODE"] = "0"
            elif modelWllpprScale[getIterWllpprScale][1] == i18n(
                "Stretch out of proportion"
            ):
                configFile["BACKGROUNDMODE"] = "1"
            elif modelWllpprScale[getIterWllpprScale][1] == i18n("Stretch with trim"):
                configFile["BACKGROUNDMODE"] = "2"
        ### Рабочий стол ###

        ### Оборудование ###
        if not configFile["FREEVGADRV"] and not self.cbxPropDriver.get_active():
            configFile["FREEVGADRV"] = ""
        elif self.cbxPropDriver.get_active():
            configFile["FREEVGADRV"] = "yes"
        else:
            configFile["FREEVGADRV"] = "no"

        configFile["FAILSAFENVIDIA"] = (
            self.txtDriverFailsafeAmd.get_text()
            if self.txtDriverFailsafeAmd.get_text()
            else ""
        )
        configFile["FAILSAFEATI"] = (
            self.txtDriverFailsafeNvidia.get_text()
            if self.txtDriverFailsafeNvidia.get_text()
            else ""
        )

        getIterRes = self.cbResolution.get_active_iter()
        if getIterRes:
            modelRes = self.cbResolution.get_model()
            if modelRes[getIterRes][1] == i18n("auto"):
                configFile["XORG_RES"] = "auto"
            elif modelRes[getIterRes][1] == i18n("Default"):
                configFile["XORG_RES"] = ""
            else:
                configFile["XORG_RES"] = str(modelRes[getIterRes][1])

        if not configFile["DPMS"] and not self.cbxDpms.get_active():
            configFile["DPMS"] = ""
        elif self.cbxDpms.get_active():
            configFile["DPMS"] = "yes"
        else:
            configFile["DPMS"] = "no"

        getIterNvidiaRun = self.cbNvidiaRun.get_active_iter()
        if getIterNvidiaRun:
            modelNvidiaRun = self.cbNvidiaRun.get_model()
            if modelNvidiaRun[getIterNvidiaRun][1] == "optirun":
                configFile["OPTIRUN"] = (
                    self.txtNvidiaRun.get_text() if self.txtNvidiaRun.get_text() else ""
                )
                configFile["PRIMUSRUN"] = ""
            elif modelNvidiaRun[getIterNvidiaRun][1] == "primusun":
                configFile["OPTIRUN"] = ""
                configFile["PRIMUSRUN"] = (
                    self.txtNvidiaRun.get_text() if self.txtNvidiaRun.get_text() else ""
                )
            else:
                configFile["OPTIRUN"] = ""
                configFile["PRIMUSRUN"] = ""

        if not configFile["INTEGRATEDVGA"] and not self.cbxIgpu.get_active():
            configFile["INTEGRATEDVGA"] = ""
        elif self.cbxIgpu.get_active():
            configFile["INTEGRATEDVGA"] = "yes"
        else:
            configFile["INTEGRATEDVGA"] = "no"

        if self.cbxFixCropFps.get_active():
            getIterFixCropFps = self.cbFixCropFps.get_active_iter()
            if getIterFixCropFps:
                modelFixCropFps = self.cbFixCropFps.get_model()
                if modelFixCropFps[getIterFixCropFps][1] == i18n(
                    "1 option. May reduce performance in games"
                ):
                    configFile["export __GL_YIELD"] = "USLEEP"
                    configFile["export KWIN_TRIPLE_BUFFER"] = ""
                elif modelFixCropFps[getIterFixCropFps][1] == i18n(
                    "2 option. It may not work on every GPU"
                ):
                    configFile["export __GL_YIELD"] = ""
                    configFile["export KWIN_TRIPLE_BUFFER"] = "1"
        else:
            configFile["export __GL_YIELD"] = ""
            configFile["export KWIN_TRIPLE_BUFFER"] = ""

        if not configFile["PULSEAUDIO"] and not self.cbxPulseAudio.get_active():
            configFile["PULSEAUDIO"] = ""
        elif self.cbxPulseAudio.get_active():
            configFile["PULSEAUDIO"] = "yes"
        else:
            configFile["PULSEAUDIO"] = "no"

        nameDev = ""
        idDev = ""
        idCard = ""
        getIterPortOutput = self.cbPortOutput.get_active_iter()
        if getIterPortOutput:
            modelPortOutput = self.cbPortOutput.get_model()
            nameDev = modelPortOutput[getIterPortOutput][1]
            nameDev = re.sub(r"\[", "\[", nameDev)
            nameDev = re.sub(r"\]", "\]", nameDev)

        if nameDev:
            strCommand = 'aplay -l | grep "{}"'.format(nameDev)
            getErrorCode = subprocess.getstatusoutput(strCommand)
            if getErrorCode[0] == 0:
                idDev = (
                    getErrorCode[1]
                    .split("\n")[0]
                    .split(",")[0]
                    .split(":")[0]
                    .split()[1]
                )
                idCard = (
                    getErrorCode[1]
                    .split("\n")[0]
                    .split(",")[1]
                    .split(":")[0]
                    .split()[1]
                )
            else:
                idDev = ""
                idCard = ""

        if idDev and idCard:
            configFile["ALSACARD"] = str(idDev)
            configFile["ALSADEVICE"] = str(idCard)
        else:
            configFile["ALSACARD"] = ""
            configFile["ALSADEVICE"] = ""

        getIterPrint = self.cbAddPrinter.get_active_iter()
        if getIterPrint:
            modelPrint = self.cbAddPrinter.get_model()
            if modelPrint[getIterPrint][1] == i18n("Manual"):
                configFile["PRINTERADD"] = "manual"
            elif modelPrint[getIterPrint][1] == i18n("Auto"):
                configFile["PRINTERADD"] = "auto"
            elif modelPrint[getIterPrint][1] == i18n("Disabled"):
                configFile["PRINTERADD"] = "disable"
            else:
                configFile["PRINTERADD"] = ""

        if (
            not configFile["CONTROL_HD_POWERMGMT"]
            and not self.cbxParkingHead.get_active()
        ):
            configFile["CONTROL_HD_POWERMGMT"] = ""
        elif self.cbxParkingHead.get_active():
            configFile["CONTROL_HD_POWERMGMT"] = "1"
        else:
            configFile["CONTROL_HD_POWERMGMT"] = "0"

        ### Оборудование ###
        # проверка со старым массивом, для вывода в окно изменений
        checkString = ""
        for strConf in configFile:
            # if configFile[strConf]:
            # достаточно вывести только язык, эти параметры можно не показывать
            if (
                strConf == "LC_TELEPHONE"
                or strConf == "LC_CTYPE"
                or strConf == "LANGUAGE"
                or strConf == "LC_MONETARY"
                or strConf == "LC_ADDRESS"
                or strConf == "LC_COLLATE"
                or strConf == "LC_PAPER"
                or strConf == "LC_NAME"
                or strConf == "LC_NUMERIC"
                or strConf == "LC_MEASUREMENT"
                or strConf == "LC_TIME"
                or strConf == "LC_IDENTIFICATION"
                or strConf == "LC_MESSAGES"
            ):
                continue
            else:
                if configFile[strConf] != configFileOld[strConf]:
                    if configFileOld[strConf] and configFile[strConf]:
                        checkString += (
                            strConf
                            + ": "
                            + configFileOld[strConf]
                            + " -> "
                            + configFile[strConf]
                            + "\n"
                        )
                    elif not configFileOld[strConf] and configFile[strConf]:
                        checkString += (
                            strConf
                            + ": "
                            + i18n("Disable")
                            + " -> "
                            + configFile[strConf]
                            + "\n"
                        )
                    elif configFileOld[strConf] and not configFile[strConf]:
                        checkString += (
                            strConf
                            + ": "
                            + configFileOld[strConf]
                            + " -> "
                            + i18n("Disable")
                            + "\n"
                        )

        if  self.is_save_domain==True:
            checkString += (
                            "Домен изменён на -> " + str(self.txtDomain.get_text())
                        )

        
        if checkString:
            self.changeBuffer.set_text(checkString)
            self.textCheckChanges.set_buffer(self.changeBuffer)
            self.wndCheckChanges.set_transient_for(self.window)
            self.wndCheckChanges.show()
        #elif self.is_save_domain==True:
        #    pass
        else:
            self.wndErrorMsg.set_title(i18n("Warning"))
            self.lblErrorMsg.set_label(i18n("Nothing to save!"))
            self.wndErrorMsg.set_transient_for(self.window)
            self.wndErrorMsg.show()

    # сохранить
    def save_confirm(self, button):
        if len(sys.argv) == 1:
            for i in self.cmdUsers:
                errCode = subprocess.getstatusoutput(i)

            with open("/etc/shadow") as f:
                dataUsers = f.read()

            if dataUsers:
                for data in dataUsers.split():
                    if (
                        data.split(":")[1] == configFileOld["DEFAULTPASSWD"][1:-1]
                        and configFile["DEFAULTPASSWD"]
                        != configFileOld["DEFAULTPASSWD"]
                    ):
                        errCode = subprocess.getstatusoutput(
                            "usermod -p '{0}' {1}".format(
                                configFile["DEFAULTPASSWD"][1:-1], data.split(":")[0]
                            )
                        )
        self.write_config_file(configFile)
        self.read_config_file(configFile)
        self.read_config_file(configFileOld)

        with open(self.iniFile) as iniF:
            data = iniF.read()
        self.iniTextBuff.set_text(data)
        self.txtUblinuxIni.set_buffer(self.iniTextBuff)
        self.update_label_after_save()
        if  self.is_save_domain==True:
            self.domain_data()
            self.is_save_domain = False
        self.wndCheckChanges.hide()
        

    ### отслеживание измененных полей ###
    ### Основные ###
    def change_cmdline(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["CMDLINE"][1:-1]:
            labelText = "<b><i>CMDLINE</i></b>"
        else:
            labelText = "CMDLINE"
        self.lblCmdline.set_markup(labelText)

    def change_hostname(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["HOSTNAME"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Host Name"))
        else:
            labelText = i18n("Host Name")
        self.lblHostname.set_markup(labelText)

    def change_machineid(self, editable):
        if (
            str(editable.get_chars(0, -1)) != configFile["MACHINEID"]
            and not self.cbxRandomid.get_active()
        ):
            labelText = "<b><i>{}</i></b>".format(i18n("Work station ID"))
        else:
            labelText = i18n("Work station ID")
        self.lblMachinieId.set_markup(labelText)

    def change_machineid_toggle(self, toggle):
        if toggle.get_active():
            if configFile["MACHINEID"] != "RANDOM":
                labelText = "<b><i>{}</i></b>".format(i18n("Work station ID"))
            else:
                labelText = i18n("Work station ID")
        else:
            if configFile["MACHINEID"] == "RANDOM":
                labelText = "<b><i>{}</i></b>".format(i18n("Work station ID"))
            else:
                labelText = i18n("Work station ID")
        self.lblMachinieId.set_markup(labelText)

    def change_users(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["NEEDEDUSERS"][1:-1]:
            labelText = "<b><i>{}</i></b>".format(i18n("User String"))
        else:
            labelText = i18n("User String")
        self.lblUsers.set_markup(labelText)

    def change_groups(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["USERGROUPS"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Users groups (default)"))
        else:
            labelText = i18n("Users groups (default)")
        self.lblGroups.set_markup(labelText)

    def change_admin_toggle(self, toggle):
        if toggle.get_active():
            if configFile["ADDADM"] == "no":
                labelText = "<b><i>{}</i></b>".format(i18n("User name"))
            else:
                labelText = i18n("User name")
        else:
            if configFile["ADDADM"] != "no":
                labelText = "<b><i>{}</i></b>".format(i18n("User name"))
            else:
                labelText = i18n("User name")
        self.lblUserName.set_markup(labelText)

    def change_pass(self, editable):
        if str(editable.get_chars(0, -1)) != "":
            labelText = "<b><i>{}</i></b>".format(i18n("User password"))
            self.cbHashingAlgPass.set_sensitive(True)
        else:
            labelText = i18n("User password")
            self.cbHashingAlgPass.set_sensitive(False)
        self.lblPasswd.set_markup(labelText)

    def change_autologin_toggle(self, toggle):
        if toggle.get_active():
            if configFile["AUTOLOGINUSER"] == "none" or not configFile["AUTOLOGINUSER"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Automatic login user"))
            else:
                labelText = i18n("Automatic login user")
        else:
            if configFile["AUTOLOGINUSER"] != "none" and configFile["AUTOLOGINUSER"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Automatic login user"))
            else:
                labelText = i18n("Automatic login user")
        self.lblAutologin.set_markup(labelText)

    def change_autologin_combo(self, combo):
        if self.cbxAutologin.get_active():
            getIterAutologin = combo.get_active_iter()
            if getIterAutologin:
                modelAutologin = combo.get_model()
                if configFile["AUTOLOGINUSER"] != modelAutologin[getIterAutologin][1]:
                    labelText = "<b><i>{}</i></b>".format(i18n("Automatic login user"))
                else:
                    labelText = i18n("Automatic login user")
            self.lblAutologin.set_markup(labelText)

    def change_updatehome_toggle(self, toggle):
        if toggle.get_active():
            if configFile["UPDATEHOME"] == "no" or not configFile["UPDATEHOME"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Update the HOME directory(s)")
                )
            else:
                labelText = i18n("Update the HOME directory(s)")
        else:
            if configFile["UPDATEHOME"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Update the HOME directory(s)")
                )
            else:
                labelText = i18n("Update the HOME directory(s)")
        self.lblUpdateHome.set_markup(labelText)

    def change_tmp_toggle(self, toggle):
        if toggle.get_active():
            if configFile["TMPFS"] == "no" or not configFile["TMPFS"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Disable the use of tmpfs for:")
                )
            else:
                labelText = i18n("Disable the use of tmpfs for:")
        else:
            if configFile["TMPFS"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Disable the use of tmpfs for:")
                )
            else:
                labelText = i18n("Disable the use of tmpfs for:")
        self.lblDisableTmpfs.set_markup(labelText)

    def change_vartmp_toggle(self, toggle):
        if toggle.get_active():
            if configFile["VARTMPFS"] == "no" or not configFile["VARTMPFS"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Disable the use of tmpfs for:")
                )
            else:
                labelText = i18n("Disable the use of tmpfs for:")
        else:
            if configFile["VARTMPFS"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Disable the use of tmpfs for:")
                )
            else:
                labelText = i18n("Disable the use of tmpfs for:")
        self.lblDisableTmpfs.set_markup(labelText)

    def change_autoexec(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["AUTOEXEC"][1:-1]:
            labelText = "<b><i>{}</i></b>".format(i18n("Autorun of user programs"))
        else:
            labelText = i18n("Autorun of user programs")
        self.lblAutoexec.set_markup(labelText)

    def change_zone_combo(self, combo):
        zoneChoose = ""
        regChoose = ""
        getIterZone = self.cbZone.get_active_iter()
        if getIterZone:
            modelZone = self.cbZone.get_model()
            zoneChoose = modelZone[getIterZone][1]

        getIterReg = self.cbRegion.get_active_iter()
        if getIterReg:
            modelReg = self.cbRegion.get_model()
            regChoose = modelReg[getIterReg][1][10:]

        if modelZone[getIterZone][0] != 0:
            strZoneReg = "{0}/{1}".format(zoneChoose, regChoose)
        else:
            strZoneReg = ""
        if strZoneReg != configFile["ZONE"]:  # Баг
            labelText = "<b><i>{}</i></b>".format(i18n("Time zone"))
        else:
            labelText = i18n("Time zone")
        self.lblTimeZone.set_markup(labelText)

    def change_reg_combo(self, combo):
        zoneChoose = ""
        regChoose = ""
        getIterZone = self.cbZone.get_active_iter()
        if getIterZone:
            modelZone = self.cbZone.get_model()
            zoneChoose = modelZone[getIterZone][1]

        getIterReg = combo.get_active_iter()
        if getIterReg:
            modelReg = combo.get_model()
            regChoose = modelReg[getIterReg][1].split(")")[1]
            regChoose = regChoose[1 : len(regChoose)]

        if modelZone[getIterZone][0] != 0:
            strZoneReg = "{0}/{1}".format(zoneChoose, regChoose)
        else:
            strZoneReg = ""
        if strZoneReg != configFile["ZONE"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Time zone"))
        else:
            labelText = i18n("Time zone")
        self.lblTimeZone.set_markup(labelText)

    def change_ntp_toggle(self, toggle):
        if toggle.get_active():
            if configFile["NTPSERVERS"] != "dhcp":
                labelText = "<b><i>{}</i></b>".format(i18n("NTP server"))
            else:
                labelText = i18n("NTP server")
        else:
            if configFile["NTPSERVERS"] == "dhcp":
                labelText = "<b><i>{}</i></b>".format(i18n("NTP server"))
            else:
                labelText = i18n("NTP server")
        self.lblNtpServer.set_markup(labelText)

    def change_ntp(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["NTPSERVERS"]:
            labelText = "<b><i>{}</i></b>".format(i18n("NTP server"))
        else:
            labelText = i18n("NTP server")
        self.lblNtpServer.set_markup(labelText)

    def change_crypt_method_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()

            if not configFile["HASHPASSWD"] and model[getIter][1] == i18n("Default"):
                labelText = i18n(
                    "Password hashing algorithm in the system (by default):"
                )
            elif model[getIter][1] != configFile["HASHPASSWD"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Password hashing algorithm in the system (by default):")
                )
            else:
                labelText = i18n(
                    "Password hashing algorithm in the system (by default):"
                )

        self.lblHashingAlgPassDes.set_markup(labelText)

    def change_lang_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Russian"):
                lang = "ru_RU.UTF-8"
            elif model[getIter][1] == i18n("English"):
                lang = "en_US.UTF-8"
            else:
                lang = "def"

            if not configFile["LANG"] and lang == "def":
                labelText = i18n("Language")
            elif configFile["LANG"] != lang:
                labelText = "<b><i>{}</i></b>".format(i18n("Language"))
            else:
                labelText = i18n("Language")

            # if configFile["LANG"] != lang:
            #     labelText = '<b><i>{}</i></b>'.format(i18n("Language"))
            # else:
            #     labelText = i18n("Language")
        self.lblLanguage.set_markup(labelText)

    def change_keymap_combo(self, combo):
        lang = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Russian"):
                lang = "ru"
            elif model[getIter][1] == i18n("English"):
                lang = "en"
            else:
                lang = "def"

            if not configFile["KEYMAP"] and lang == "def":
                labelText = i18n("Keyboard layout")
            elif configFile["KEYMAP"] != lang:
                labelText = "<b><i>{}</i></b>".format(i18n("Keyboard layout"))
            else:
                labelText = i18n("Keyboard layout")

            # if configFile["KEYMAP"] != lang:
            #     labelText = '<b><i>{}</i></b>'.format(i18n("Keyboard layout"))
            # else:
            #     labelText = i18n("Keyboard layout")
        self.lblKeymap.set_markup(labelText)

    def change_font_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if not configFile["FONT"] and model[getIter][1] == i18n("Default"):
                labelText = i18n("Console font")
            elif model[getIter][1] != configFile["FONT"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Console font"))
            else:
                labelText = i18n("Console font")
        self.lblFontConsole.set_markup(labelText)

    def change_numlock_combo(self, combo):
        strNum = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("On"):
                strNum = "yes"
            elif model[getIter][1] == i18n("Off"):
                strNum = "no"
            else:
                strNum = "def"

            if not configFile["NUMLOCK"] and strNum == "def":
                labelText = i18n("Num lock on boot")
            elif configFile["NUMLOCK"] != strNum:
                labelText = "<b><i>{}</i></b>".format(i18n("Num lock on boot"))
            else:
                labelText = i18n("Num lock on boot")
        self.lblNumLock.set_markup(labelText)

    def change_connect_all_part_toggle(self, toggle):
        if toggle.get_active():
            if (
                configFile["PARTITIONSAUTOMOUNT"] == "no"
                or not configFile["PARTITIONSAUTOMOUNT"]
            ):
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Connect all partitions at startup")
                )
            else:
                labelText = i18n("Connect all partitions at startup")
        else:
            if configFile["PARTITIONSAUTOMOUNT"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Connect all partitions at startup")
                )
            else:
                labelText = i18n("Connect all partitions at startup")
        self.lblConnectAllPart.set_markup(labelText)

    def change_dont_connect_part(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["PARTITIONSNOMOUNT"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Do not connect the specified partitions")
                )
            else:
                labelText = i18n("Do not connect the specified partitions")
            self.lblDontConnectPart.set_markup(labelText)

    def change_dont_connect_part_toggle(self, toggle):
        if toggle.get_active():
            if configFile["PARTITIONSNOMOUNT"] == "":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Do not connect the specified partitions")
                )
            else:
                labelText = i18n("Do not connect the specified partitions")
        else:
            if configFile["PARTITIONSNOMOUNT"] != "":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Do not connect the specified partitions")
                )
            else:
                labelText = i18n("Do not connect the specified partitions")
        self.lblDontConnectPart.set_markup(labelText)

    def change_user_ntfs_owner_part(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["PARTITIONSMOUNTUID"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Owner user for FAT NTFS"))
        else:
            labelText = i18n("Owner user for FAT NTFS")
        self.lblUserNtfsOwner.set_markup(labelText)

    def change_update_sys_combo(self, combo):
        updt = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Auto"):
                updt = "auto"
            elif model[getIter][1] == i18n("ask"):
                updt = "ask"
            elif model[getIter][1] == i18n("never"):
                updt = "never"
            else:
                updt = "def"

            if not configFile["UBLINUXUPDATE"] and updt == "def":
                labelText = i18n("System update")
            elif configFile["UBLINUXUPDATE"] != updt:
                labelText = "<b><i>{}</i></b>".format(i18n("System update"))
            else:
                labelText = i18n("System update")
        self.lblAutoUpdateSys.set_markup(labelText)

    def change_compress_def(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["MKSQFS_OPTS"][1:-1]:
            labelText = "<b><i>{}</i></b>".format(
                i18n("Default module compression algorithm")
            )
        else:
            labelText = i18n("Default module compression algorithm")
        self.lblAlgCompressDef.set_markup(labelText)

    def change_save_modul(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["MKSQFS_FASTALG"][1:-1]:
            labelText = "<b><i>{}</i></b>".format(
                i18n("Compression algorithm used to save the change to the module")
            )
        else:
            labelText = i18n(
                "Compression algorithm used to save the change to the module"
            )
        self.lblAlgForSaveModul.set_markup(labelText)

    ### Основные ###

    ### Безопасность ###
    def change_block_system_commands_toggle(self, toggle):
        self.txtSystemCommands.set_sensitive(toggle.get_active())

    def change_block_console_for_users_toggle(self, toggle):
        self.txtConsoleForUsers.set_sensitive(toggle.get_active())

    def change_block_console_for_groups_toggle(self, toggle):
        self.txtConsoleForGroup.set_sensitive(toggle.get_active())

    def change_block_interpreters_toggle(self, toggle):
        self.txtInterpreters.set_sensitive(toggle.get_active())

    ### Безопасность ###

    ### Сеть ###
    def change_net_dev_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if not configFile["DEVICE"] and model[getIter][1] == i18n("Default"):
                labelText = i18n("Network Interface")
            elif configFile["DEVICE"] != model[getIter][1]:
                labelText = "<b><i>{}</i></b>".format(i18n("Network Interface"))
            else:
                labelText = i18n("Network Interface")
        self.lblNetInterface.set_markup(labelText)

    def change_autoenable_net_toggle(self, toggle):
        if toggle.get_active():
            if configFile["ONBOOT"] == "no" or not configFile["ONBOOT"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Automatic enabling"))
            else:
                labelText = i18n("Automatic enabling")
        else:
            if configFile["ONBOOT"] == "yes":
                labelText = "<b><i>{}</i></b>".format(i18n("Automatic enabling"))
            else:
                labelText = i18n("Automatic enabling")
        self.lblAutorunNet.set_markup(labelText)

    def change_alt_dhcp(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["DHCP_CLIENT"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Alternative DHCP client"))
        else:
            labelText = i18n("Alternative DHCP client")
        self.lblAltDhcp.set_markup(labelText)

    def change_ip(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["IPADDR"]:
            labelText = "<b><i>{}</i></b>".format(i18n("IP-Adress"))
        else:
            labelText = i18n("IP-Adress")
        self.lblIpAdr.set_markup(labelText)

    def change_mask(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["NETMASK"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Netmask"))
        else:
            labelText = i18n("Netmask")
        self.lblMask.set_markup(labelText)

    def change_rout(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["GATEWAY"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Gateway"))
        else:
            labelText = i18n("Gateway")
        self.lblRout.set_markup(labelText)

    def change_mii_not_supp_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("yes"):
                check = "yes"
            elif model[getIter][1] == i18n("no"):
                check = "no"
            else:
                check = "def"

            if not configFile["MII_NOT_SUPPORTED"] and check == "def":
                labelText = i18n("MII_NOT_SUPPORTED")
            elif configFile["MII_NOT_SUPPORTED"] != check:
                labelText = "<b><i>{}</i></b>".format("MII_NOT_SUPPORTED")
            else:
                labelText = i18n("MII_NOT_SUPPORTED")
        self.lblMiiNotSupp.set_markup(labelText)

    def change_dns_serv(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["DNS1"]:
            labelText = "<b><i>{}</i></b>".format(i18n("DNS-Server"))
        else:
            labelText = i18n("DNS-Server")
        self.lblDnsServ.set_markup(labelText)

    def change_except_fire_tcp(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["IPTABLESOPENPORTSTCP"]:
            labelText = "<b><i>{}</i></b>".format(i18n("TCP firewall exceptions"))
        else:
            labelText = i18n("TCP firewall exceptions")
        self.lblExceptFireTcp.set_markup(labelText)

    def change_except_fire_udp(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["IPTABLESOPENPORTSUDP"]:
            labelText = "<b><i>{}</i></b>".format(i18n("UDP firewall exceptions"))
        else:
            labelText = i18n("UDP firewall exceptions")
        self.lblExeptFireUdp.set_markup(labelText)

    def change_trust_ip(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["IPTABLESTRUSTEDIP"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Trusted IP-Adress"))
        else:
            labelText = i18n("Trusted IP-Adress")
        self.lblTrustIp.set_markup(labelText)

    def change_avahi_toggle(self, toggle):
        if toggle.get_active():
            if configFile["NSSWITCHAVAHI"] == "no" or not configFile["NSSWITCHAVAHI"]:
                labelText = "<b><i>{}</i></b>".format("Avahi")
            else:
                labelText = "Avahi"
        else:
            if configFile["NSSWITCHAVAHI"] == "yes":
                labelText = "<b><i>{}</i></b>".format("Avahi")
            else:
                labelText = "Avahi"
        self.lblAvahi.set_markup(labelText)

    def change_winbind_toggle(self, toggle):
        if toggle.get_active():
            if (
                configFile["NSSWITCHWINBIND"] == "no"
                or not configFile["NSSWITCHWINBIND"]
            ):
                labelText = "<b><i>{}</i></b>".format("Winbind")
            else:
                labelText = "Winbind"
        else:
            if configFile["NSSWITCHWINBIND"] == "yes":
                labelText = "<b><i>{}</i></b>".format("Winbind")
            else:
                labelText = "Winbind"
        self.lblWinbind.set_markup(labelText)

    def change_prim_dns(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["ip"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Primary DNS-server"))
            else:
                labelText = i18n("Primary DNS-server")
            self.lblPrimDnsServ.set_markup(labelText)

    def change_prim_dns_toggle(self, toggle):
        if toggle.get_active():
            if configFile["ip"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("Primary DNS-server"))
            else:
                labelText = i18n("Primary DNS-server")
        else:
            if configFile["ip"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("Primary DNS-server"))
            else:
                labelText = i18n("Primary DNS-server")
        self.lblPrimDnsServ.set_markup(labelText)

    def change_ipv6_toggle(self, toggle):
        if toggle.get_active():
            if configFile["IPV6"] == "no" or not configFile["IPV6"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Enable IPv6"))
            else:
                labelText = i18n("Enable IPv6")
        else:
            if configFile["IPV6"] == "yes":
                labelText = "<b><i>{}</i></b>".format(i18n("Enable IPv6"))
            else:
                labelText = i18n("Enable IPv6")
        self.lblIpV6.set_markup(labelText)

    def change_route_mode_toggle(self, toggle):
        if toggle.get_active():
            if configFile["ROUTER"] == "no" or not configFile["ROUTER"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Modem mode"))
            else:
                labelText = i18n("Modem mode")
        else:
            if configFile["ROUTER"] == "yes":
                labelText = "<b><i>{}</i></b>".format(i18n("Modem mode"))
            else:
                labelText = i18n("Modem mode")
        self.lblRouteMode.set_markup(labelText)

    def change_tor_toggle(self, toggle):
        if toggle.get_active():
            if configFile["TORUSERS"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("Traffic via TOR"))
            else:
                labelText = i18n("Traffic via TOR")
        else:
            if configFile["TORUSERS"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("Traffic via TOR"))
            else:
                labelText = i18n("Traffic via TOR")
        self.lblTraficTor.set_markup(labelText)

    def chane_tor_num_min(self, editable):
        torMinChek = ""
        if self.cbxTraficTor.get_active():
            if configFile["TORUSERS"]:
                torMinChek = configFile["TORUSERS"].split("-")[0]
            else:
                torMinChek = "0"
            if str(editable.get_chars(0, -1)) != torMinChek:
                labelText = "<b><i>{}</i></b>".format(i18n("Traffic via TOR"))
            else:
                labelText = i18n("Traffic via TOR")
            self.lblTraficTor.set_markup(labelText)

    def chane_tor_num_max(self, editable):
        torMaxChek = ""
        if self.cbxTraficTor.get_active():
            if configFile["TORUSERS"]:
                torMaxChek = configFile["TORUSERS"].split("-")[1]
            else:
                torMaxChek = "1"
            if str(editable.get_chars(0, -1)) != torMaxChek:
                labelText = "<b><i>{}</i></b>".format(i18n("Traffic via TOR"))
            else:
                labelText = i18n("Traffic via TOR")
            self.lblTraficTor.set_markup(labelText)

    def change_http_prox(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["HTTP_PROXY"]:
                labelText = "<b><i>{}</i></b>".format(i18n("HTTP-Proxy"))
            else:
                labelText = i18n("HTTP-Proxy")
            self.lblHttpProx.set_markup(labelText)

    def change_http_prox_toggle(self, toggle):
        if toggle.get_active():
            if configFile["HTTP_PROXY"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("HTTP-Proxy"))
            else:
                labelText = i18n("HTTP-Proxy")
        else:
            if configFile["HTTP_PROXY"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("HTTP-Proxy"))
            else:
                labelText = i18n("HTTP-Proxy")
        self.lblHttpProx.set_markup(labelText)

    def change_https_prox(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["HTTPS_PROXY"]:
                labelText = "<b><i>{}</i></b>".format(i18n("HTTPS-Proxy"))
            else:
                labelText = i18n("HTTPS-Proxy")
            self.lblHttpsProx.set_markup(labelText)

    def change_https_prox_toggle(self, toggle):
        if toggle.get_active():
            if configFile["HTTPS_PROXY"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("HTTPS-Proxy"))
            else:
                labelText = i18n("HTTPS-Proxy")
        else:
            if configFile["HTTPS_PROXY"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("HTTPS-Proxy"))
            else:
                labelText = i18n("HTTPS-Proxy")
        self.lblHttpsProx.set_markup(labelText)

    def change_ftp_prox(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["FTP_PROXY"]:
                labelText = "<b><i>{}</i></b>".format(i18n("FTP-Proxy"))
            else:
                labelText = i18n("FTP-Proxy")
            self.lblFtpProx.set_markup(labelText)

    def change_ftp_prox_toggle(self, toggle):
        if toggle.get_active():
            if configFile["FTP_PROXY"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("FTP-Proxy"))
            else:
                labelText = i18n("FTP-Proxy")
        else:
            if configFile["FTP_PROXY"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("FTP-Proxy"))
            else:
                labelText = i18n("FTP-Proxy")
        self.lblFtpProx.set_markup(labelText)

    def change_no_prox(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["NO_PROXY"]:
                labelText = "<b><i>{}</i></b>".format(i18n("Without proxy"))
            else:
                labelText = i18n("Without proxy")
            self.lblNoProx.set_markup(labelText)

    def change_no_prox_toggle(self, toggle):
        if toggle.get_active():
            if configFile["NO_PROXY"] == "":
                labelText = "<b><i>{}</i></b>".format(i18n("Without proxy"))
            else:
                labelText = i18n("Without proxy")
        else:
            if configFile["NO_PROXY"] != "":
                labelText = "<b><i>{}</i></b>".format(i18n("Without proxy"))
            else:
                labelText = i18n("Without proxy")
        self.lblNoProx.set_markup(labelText)

    def change_polipo_prox(self, editable):
        if self.cbxDontConnectPart.get_active():
            if str(editable.get_chars(0, -1)) != configFile["socksParentProxy"][1:-1]:
                labelText = "<b><i>{}</i></b>".format(i18n("Polipo-Proxy"))
            else:
                labelText = i18n("Polipo-Proxy")
            self.lblPolipoProx.set_markup(labelText)

    def change_polipo_prox_toggle(self, toggle):
        if toggle.get_active():
            if (
                configFile["socksParentProxy"] == ""
                and configFile["socksProxyType"] == ""
            ):
                labelText = "<b><i>{}</i></b>".format(i18n("Polipo-Proxy"))
            else:
                labelText = i18n("Polipo-Proxy")
        else:
            if (
                configFile["socksParentProxy"] != ""
                and configFile["socksProxyType"] != ""
            ):
                labelText = "<b><i>{}</i></b>".format(i18n("Polipo-Proxy"))
            else:
                labelText = i18n("Polipo-Proxy")
        self.lblPolipoProx.set_markup(labelText)

    def change_polipo_combo(self, combo):
        if self.cbxPolipoProx.get_active():
            getIter = combo.get_active_iter()
            if getIter:
                model = combo.get_model()

                if not configFile["socksProxyType"] and model[getIter][1] == i18n(
                    "Default"
                ):
                    labelText = i18n("Polipo-Proxy")
                elif configFile["socksProxyType"] != model[getIter][1]:
                    labelText = "<b><i>{}</i></b>".format(i18n("Polipo-Proxy"))
                else:
                    labelText = i18n("Polipo-Proxy")
            self.lblPolipoProx.set_markup(labelText)

    ### Сеть ###

    ### Рабочий стол ###
    def change_de_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("none"):
                check = "none"
            elif model[getIter][1] == i18n("Default"):
                check = "def"
            else:
                check = model[getIter][1]

            if not configFile["DESKTOP"] and check == "def":
                labelText = i18n("Desktop environment")
            elif configFile["DESKTOP"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Desktop environment"))
            else:
                labelText = i18n("Desktop environment")
        self.lblDe.set_markup(labelText)

    def change_dm_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()

            if not configFile["DISPLAYMANAGER"] and model[getIter][1] == i18n(
                "Default"
            ):
                labelText = i18n("Display manager")
            elif configFile["DISPLAYMANAGER"] != model[getIter][1]:
                labelText = "<b><i>{}</i></b>".format(i18n("Display manager"))
            else:
                labelText = i18n("Display manager")
        self.lblDm.set_markup(labelText)

    def change_display_def_user_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()

            if not configFile["DISPLAYMANAGER_DEFAULTUSER"] and model[getIter][
                1
            ] == i18n("Default"):
                labelText = i18n("User of the default graphical environment")
            elif configFile["DISPLAYMANAGER_DEFAULTUSER"] != model[getIter][1]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("User of the default graphical environment")
                )
            else:
                labelText = i18n("User of the default graphical environment")
        self.lblDisplayUserDef.set_markup(labelText)

    def change_theme_combo(self, combo):
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()

            if not configFile["THEME"] and model[getIter][1] == i18n("Default"):
                labelText = i18n("Theme")
            elif configFile["THEME"] != model[getIter][1].lower():
                labelText = "<b><i>{}</i></b>".format(i18n("Theme"))
            else:
                labelText = i18n("Theme")
        self.lblTheme.set_markup(labelText)

    def change_ssever_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Standart"):
                check = "/mnt/livedata/ublinux-data/backgrounds/screensaver/default"
            elif model[getIter][1] == i18n("Default"):
                check = "def"
            else:
                check = "other"

            if not configFile["SSAVERTHEME"] and check == "def":
                labelText = i18n("Screen saver theme")
            elif configFile["SSAVERTHEME"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Screen saver theme"))
            else:
                labelText = i18n("Screen saver theme")
        self.lblScreenSaverTheme.set_markup(labelText)

    def change_source_wllppr_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Default"):
                check = "def"
            elif model[getIter][1] == i18n("Standart"):
                check = "/mnt/livedata/ublinux-data/backgrounds/wallpapers/default"
            elif model[getIter][1] == i18n("Personal"):
                check = self.txtPathWallpaper.get_text()
            else:
                check = "color"

            if not configFile["BACKGROUND"] and check == "def":
                labelText = i18n("Source")
            elif configFile["BACKGROUND"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Source"))
            else:
                labelText = i18n("Source")
        self.lblSourceWallpaper.set_markup(labelText)

    def change_path_wllppr(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["BACKGROUND"]:
            labelText = "<b><i>{}</i></b>".format(i18n("Directory"))
        else:
            labelText = i18n("Directory")
        self.lblPathWallpaper.set_markup(labelText)

    def change_scale_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Default"):
                check = "def"
            elif model[getIter][1] == i18n(
                "Stretch proportionally on background color"
            ):
                check = "0"
            elif model[getIter][1] == i18n("Stretch out of proportion"):
                check = "1"
            elif model[getIter][1] == i18n("Stretch with trim"):
                check = "3"

            if not configFile["BACKGROUNDMODE"] and check == "def":
                labelText = i18n("Scaling")
            elif configFile["BACKGROUNDMODE"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Scaling"))
            else:
                labelText = i18n("Scaling")
        self.lblScaleWallpaper.set_markup(labelText)

    ### Рабочий стол ###

    ### Загрузчик ###
    # def change_aspm(self, combo):
    #     getDefItem = ""
    #     with open("/sys/module/pcie_aspm/parameters/policy") as f:
    #         getDefItemList = f.read().split()

    #     if getDefItemList[0]:
    #         for i in getDefItemList:
    #             if re.search(r'\[[a-zA-Z0-9]*\]', i):
    #                 getDefItem = i18n(i[1:-1])

    #     getIter = combo.get_active_iter()
    #     if getIter:
    #         model = combo.get_model()
    #         if getDefItem != model[getIter][1]:
    #             labelText = '<b><i>{}</i></b>'.format(i18n("ASPM (Active-State Power Management)"))
    #         else:
    #             labelText = i18n("ASPM (Active-State Power Management)")
    #     self.lblAspm.set_markup(labelText)
    ### Загрузчик ###

    ## Оборудование ###
    def change_prop_driver_toggle(self, toggle):
        if toggle.get_active():
            if configFile["FREEVGADRV"] == "no" or not configFile["FREEVGADRV"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("NVIDIA/AMD proprietary driver")
                )
            else:
                labelText = i18n("NVIDIA/AMD proprietary driver")
        else:
            if configFile["FREEVGADRV"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("NVIDIA/AMD proprietary driver")
                )
            else:
                labelText = i18n("NVIDIA/AMD proprietary driver")
        self.lblPropDriver.set_markup(labelText)

    def change_failsafe_amd(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["FAILSAFEATI"]:
            labelText = "<b><i>{}</i></b>".format(i18n("FAILSAFE Driver AMD"))
        else:
            labelText = i18n("FAILSAFE Driver AMD")
        self.lblDriverFailsafeAmd.set_markup(labelText)

    def change_failsafe_nvidia(self, editable):
        if str(editable.get_chars(0, -1)) != configFile["FAILSAFENVIDIA"]:
            labelText = "<b><i>{}</i></b>".format(i18n("FAILSAFE Driver NVIDIA"))
        else:
            labelText = i18n("FAILSAFE Driver NVIDIA")
        self.lblDriverFailsafeNvidia.set_markup(labelText)

    def change_resol_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("auto"):
                check = "auto"
            elif model[getIter][1] == i18n("Default"):
                check = "def"
            else:
                check = model[getIter][1]

            if not configFile["XORG_RES"] and check == "def":
                labelText = i18n("Screen resolution")
            elif configFile["XORG_RES"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Screen resolution"))
            else:
                labelText = i18n("Screen resolution")
        self.lblResolution.set_markup(labelText)

    def change_dpms_toggle(self, toggle):
        if toggle.get_active():
            if configFile["DPMS"] == "no" or not configFile["DPMS"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Do not turn off the screen")
                )
            else:
                labelText = i18n("Do not turn off the screen")
        else:
            if configFile["DPMS"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Do not turn off the screen")
                )
            else:
                labelText = i18n("Do not turn off the screen")
        self.lblDontTurnOffScreen.set_markup(labelText)

    def change_igpu_toggle(self, toggle):
        if toggle.get_active():
            if configFile["INTEGRATEDVGA"] == "no" or not configFile["INTEGRATEDVGA"]:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Discrete video only (AMD/ATI)")
                )
            else:
                labelText = i18n("Discrete video only (AMD/ATI)")
        else:
            if configFile["INTEGRATEDVGA"] == "yes":
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Discrete video only (AMD/ATI)")
                )
            else:
                labelText = i18n("Discrete video only (AMD/ATI)")
        self.lblIgpu.set_markup(labelText)

    def change_exec_prog_combo(self, combo):
        check = ""
        checkType = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if configFile["OPTIRUN"]:
                check = "optirun"
            elif configFile["PRIMUSRUN"]:
                check = "primusrun"

            if model[getIter][1] == "optirun":
                checkType = "optirun"
            elif model[getIter][1] == "primusrun":
                checkType = "primusrun"
            else:
                checkType = "def"

            if checkType == "def":
                labelText = i18n("Running programs via (nVidia)")
            elif check != checkType:
                labelText = "<b><i>{}</i></b>".format(
                    i18n("Running programs via (nVidia)")
                )
            else:
                labelText = i18n("Running programs via (nVidia)")
        self.lblNvidiaRun.set_markup(labelText)

    def change_exec_prog(self, editable):
        check = ""
        if configFile["OPTIRUN"]:
            check = configFile["OPTIRUN"]
        if configFile["PRIMUSRUN"]:
            check = configFile["PRIMUSRUN"]
        if str(editable.get_chars(0, -1)) != check:
            labelText = "<b><i>{}</i></b>".format(i18n("Running programs via (nVidia)"))
        else:
            labelText = i18n("Running programs via (nVidia)")
        self.lblNvidiaRun.set_markup(labelText)

    def change_fix_fps_toggle(self, toggle):
        if toggle.get_active():
            if (
                configFile["export __GL_YIELD"] == ""
                and configFile["export KWIN_TRIPLE_BUFFER"] == ""
            ):
                labelText = "<b><i>{}</i></b>".format(i18n("Fix frame break (nVidia)"))
            else:
                labelText = i18n("Fix frame break (nVidia)")
        else:
            if (
                configFile["export __GL_YIELD"] != ""
                and configFile["export KWIN_TRIPLE_BUFFER"] != ""
            ):
                labelText = "<b><i>{}</i></b>".format(i18n("Fix frame break (nVidia)"))
            else:
                labelText = i18n("Fix frame break (nVidia)")
        self.lblFixCropFps.set_markup(labelText)

    def change_fix_fps_combo(self, combo):
        check = ""
        checkParam = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("1 option. May reduce performance in games"):
                check = "USLEEP"
            elif model[getIter][1] == i18n("2 option. It may not work on every GPU"):
                check = "1"
            if configFile["export __GL_YIELD"] == "":
                checkParam = configFile["export KWIN_TRIPLE_BUFFER"]
            elif configFile["export KWIN_TRIPLE_BUFFER"] == "":
                checkParam = configFile["export __GL_YIELD"]
            if checkParam != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Fix frame break (nVidia)"))
            else:
                labelText = i18n("Fix frame break (nVidia)")
        self.lblFixCropFps.set_markup(labelText)

    def change_pulse_toggle(self, toggle):
        if toggle.get_active():
            if configFile["PULSEAUDIO"] == "no" or not configFile["PULSEAUDIO"]:
                labelText = "<b><i>{}</i></b>".format("PulseAudio")
            else:
                labelText = "PulseAudio"
        else:
            if configFile["PULSEAUDIO"] == "yes":
                labelText = "<b><i>{}</i></b>".format("PulseAudio")
            else:
                labelText = "PulseAudio"
        self.lblPulseAudio.set_markup(labelText)

    def change_printer_combo(self, combo):
        check = ""
        getIter = combo.get_active_iter()
        if getIter:
            model = combo.get_model()
            if model[getIter][1] == i18n("Manual"):
                check = "manual"
            elif model[getIter][1] == i18n("Auto"):
                check = "auto"
            elif model[getIter][1] == i18n("Disabled"):
                check = "disable"
            else:
                check = "def"

            if not configFile["PRINTERADD"] and check == "def":
                labelText = i18n("Addendum")
            elif configFile["PRINTERADD"] != check:
                labelText = "<b><i>{}</i></b>".format(i18n("Addendum"))
            else:
                labelText = i18n("Addendum")
        self.lblAddPrinter.set_markup(labelText)

    def change_parking_head_toggle(self, toggle):
        if toggle.get_active():
            if (
                configFile["CONTROL_HD_POWERMGMT"] == "0"
                or not configFile["CONTROL_HD_POWERMGMT"]
            ):
                labelText = "<b><i>{}</i></b>".format(i18n("Parking heads"))
            else:
                labelText = i18n("Parking heads")
        else:
            if configFile["CONTROL_HD_POWERMGMT"] == "1":
                labelText = "<b><i>{}</i></b>".format(i18n("Parking heads"))
            else:
                labelText = i18n("Parking heads")
        self.lblParkingHead.set_markup(labelText)

    ## Оборудование ###
    ### отслеживание измененных полей ###

    def update_label_after_save(self):
        self.lblCmdline.set_label("CMDLINE")
        self.lblHostname.set_label(i18n("Host Name"))
        self.lblMachinieId.set_label(i18n("Work station ID"))
        self.lblUsers.set_label(i18n("Users"))
        self.lblGroups.set_label(i18n("Users groups (default)"))
        self.lblUserName.set_label(i18n("User name"))
        self.lblPasswd.set_label(i18n("User password"))
        self.lblAutologin.set_label(i18n("Automatic login user"))
        self.lblUpdateHome.set_label(i18n("Update the HOME directory(s)"))
        self.lblDisableTmpfs.set_label(i18n("Disable the use of tmpfs for:"))
        self.lblAutoexec.set_label(i18n("Autorun of user programs"))
        self.lblTimeZone.set_label(i18n("Time zone"))
        self.lblNtpServer.set_label(i18n("NTP server"))
        self.lblLanguage.set_label(i18n("Language"))
        self.lblKeymap.set_label(i18n("Keyboard layout"))
        self.lblFontConsole.set_label(i18n("Console font"))
        self.lblNumLock.set_label(i18n("Num lock on boot"))
        self.lblConnectAllPart.set_label(i18n("Connect all partitions at startup"))
        self.lblDontConnectPart.set_label(
            i18n("Do not connect the specified partitions")
        )
        self.lblUserNtfsOwner.set_label(i18n("Owner user for FAT NTFS"))
        self.lblAutoUpdateSys.set_label(i18n("System update"))
        self.lblAlgCompressDef.set_label(i18n("Default module compression algorithm"))
        self.lblAlgForSaveModul.set_label(
            i18n("Compression algorithm used to save the change to the module")
        )
        self.lblHashingAlgPassDes.set_label(
            i18n("Password hashing algorithm in the system (by default):")
        )

        self.lblNetInterface.set_label(i18n("Network Interface"))
        self.lblAutorunNet.set_label(i18n("Automatic enabling"))
        self.lblAltDhcp.set_label(i18n("Alternative DHCP client"))
        self.lblIpAdr.set_label(i18n("IP-Adress"))
        self.lblMask.set_label(i18n("Netmask"))
        self.lblRout.set_label(i18n("Gateway"))
        self.lblMiiNotSupp.set_label("MII_NOT_SUPPORTED")
        self.lblDnsServ.set_label(i18n("DNS-Server"))
        self.lblExceptFireTcp.set_label(i18n("TCP firewall exceptions"))
        self.lblExeptFireUdp.set_label(i18n("UDP firewall exceptions"))
        self.lblTrustIp.set_label(i18n("Trusted IP-Adress"))
        self.lblAvahi.set_label("Avahi")
        self.lblWinbind.set_label("Winbind")
        self.lblPrimDnsServ.set_label(i18n("Primary DNS-server"))
        self.lblIpV6.set_label(i18n("Enable IPv6"))
        self.lblRouteMode.set_label(i18n("Modem mode"))
        self.lblTraficTor.set_label(i18n("Traffic via TOR"))
        self.lblHttpProx.set_label(i18n("HTTP-Proxy"))
        self.lblHttpsProx.set_label(i18n("HTTPS-Proxy"))
        self.lblFtpProx.set_label(i18n("FTP-Proxy"))
        self.lblNoProx.set_label(i18n("Without proxy"))
        self.lblPolipoProx.set_label(i18n("Polipo-Proxy"))

        self.lblDe.set_label(i18n("Desktop environment"))
        self.lblDm.set_label(i18n("Display manager"))
        self.lblDisplayUserDef.set_label(
            i18n("User of the default graphical environment")
        )
        self.lblTheme.set_label(i18n("Theme"))
        self.lblScreenSaverTheme.set_label(i18n("Screen saver theme"))
        self.lblSourceWallpaper.set_label(i18n("Source"))
        self.lblPathWallpaper.set_label(i18n("Directory"))
        self.lblScaleWallpaper.set_label(i18n("Scaling"))

        self.lblPropDriver.set_label(i18n("NVIDIA/AMD proprietary driver"))
        self.lblDriverFailsafeAmd.set_label(i18n("FAILSAFE Driver AMD"))
        self.lblDriverFailsafeNvidia.set_label(i18n("FAILSAFE Driver NVIDIA"))
        self.lblResolution.set_label(i18n("Screen resolution"))
        self.lblDontTurnOffScreen.set_label(i18n("Do not turn off the screen"))
        self.lblNvidiaRun.set_label(i18n("Running programs via (nVidia)"))
        self.lblIgpu.set_label(i18n("Discrete video only (AMD/ATI)"))
        self.lblFixCropFps.set_label(i18n("Fix frame break (nVidia)"))
        self.lblPulseAudio.set_label("PulseAudio")
        self.lblAddPrinter.set_label(i18n("Addendum"))
        self.lblParkingHead.set_label(i18n("Parking heads"))


if __name__ == "__main__":
    main = Main()
    gtk.main()
