generator.pyw

"""
# Generator CSV
# Wersja 4.0
# Autorzy: Mateusz Skoczek
# styczeń 2019 - wrzesień 2020
# dla ZSP Sobolew
"""





# ------------------------------------- # Import bibliotek # ------------------------------------ #

# Biblioteki główne
import sys as SS
import os as OS
import time as TM
import codecs as CD
import pathlib as PT
import shutil as SU


# Biblioteki interfejsu graficznego
import tkinter as TK
from tkinter import ttk as TKttk
from tkinter import messagebox as TKmsb
from tkinter import filedialog as TKfld

from PIL import ImageTk as PLitk
from PIL import Image as PLimg





# --------------------------------- # Główne zmienne globalne # --------------------------------- #

class VAR:
    # Informacje o programie
    programName = 'Generator CSV'
    programVersion = '4.0'
    programVersionStage = ''
    programVersionBuild = '20254'
    programCustomer = 'ZSP Sobolew'
    programAuthors = ['Mateusz Skoczek']
    programToW = ['styczeń', '2019', 'wrzesień', '2020']

    # Dozwolone kodowanie plików
    allowedCoding = ['utf-8', 'ANSI', 'iso-8859-2']

    # Dozwolone znaki
    allowedCharactersInSeparator = ['`', '~', '!', '@', '#', '$', '%', '^', '&', '(', ')', '-', '_', '=', '+', '[', ']', ' ', '?', '/', '>', '.', '<', ',', '"', "'", ':', ';', '|']

    # Katalog APPDATA
    appdataPath = PT.Path.home() / 'Appdata/Roaming'






# -------------------------------------- # Okna dialogowe # ------------------------------------- #

# Lista komunikatów
MSGlist = {
    'E0000' : 'none',
    'E0001' : 'Wystąpił błąd podczas inicjalizacji katalogu z plikami konfiguracyjnymi programu w katalogu %APPDATA%',
    'E0002' : 'Wystąpił błąd podczas ładowania pliku konfiguracyjnego (config.cfg)',
    'E0003' : 'Niepoprawne dane w pliku konfiguracyjnym (config.cfg)',
    'E0004' : 'Wystąpił błąd podczas ładowania pliku stylu (style.cfg)',
    'E0005' : 'Niepoprawne dane w pliku stylu (style.cfg)',
    'E0006' : 'Niepoprawne dane w pliku formatu',
    'E0007' : 'Wymagany przynajmniej jeden plik wejściowy',
    'E0008' : 'Nie można odnaleźć jednego z powyższych plików',
    'E0009' : 'Nie można odnaleźć jednego z powyższych format presetów',
    'E0010' : 'Nie można przetworzyć danych z plików wejściowych z pomocą podanych format presetów',
    'E0011' : 'Niepoprawne dane w plikach wejściowych',
    'E0012' : 'Nie można przetworzyć danych na format wyjściowy',
    'E0013' : 'Nie można utworzyć plików wejściowych',
    'E0014' : 'Nie można zapisać plików wejściowych',
    'E0015' : 'Nie można usunąć wybranych format presetów',
    'E0016' : 'Nie można uruchomić pliku instrukcji (documentation/index.html)',
    'E0017' : 'Nie można zapisać pliku formatu',
    'A0001' : 'Czy chcesz zapisać? Zostanie utworzony nowy plik',
    'A0002' : 'Czy chcesz zapisać? Plik zostanie nadpisany',
    'A0003' : 'Czy chcesz rozpocząć przetwarzanie plików?',
    'A0004' : 'Czy chcesz zapisać?',
    'A0005' : 'Czy na pewno chcesz przywrócić domyślne ustawienia ogólne?',
    'A0006' : 'Czy na pewno chcesz przywrócić domyślne ustawienia wyglądu?',
    'A0007' : 'Czy na pewno chcesz usunąc zaznaczone format presety?',
    'A0008' : 'Nie znaleziono informacji o wersji programu w katalogu programu w APPDATA. Nastąpi zresetowanie katalogu programu w APPDATA oraz utworzenie kopii zapasowej dotychczasowej zawartości. Czy chcesz kontynuować?',
    'A0009' : 'Została zainstalowana nowa wersja programu. Nastąpi zresetowanie katalogu programu w APPDATA oraz utworzenie kopii zapasowej dotychczasowej zawartości. Czy chcesz kontynuować?',
    'I0001' : 'Operacja ukończona pomyślnie',
    'I0002' : 'Aplikacja zostanie zamknięta w celu przeładowania ustawień',
}


# Funkcja odpowiedzialna za wywoływanie komunikatów dialogowych
def MSG(code, terminate, *optionalInfo):
    try:
        optionalInfo[0]
    except:
        optionalInfo = ['']
    
    # Błędy
    if code[0] == 'E':
        TKmsb.showerror('Wystąpił błąd!', '%s\n%s' % (MSGlist[code], optionalInfo[0]))
        if terminate:
            SS.exit(0)
    
    # Informacja
    elif code[0] == 'I':
        TKmsb.showinfo('Informacja', '%s\n%s' % (MSGlist[code], optionalInfo[0]))
        if terminate:
            SS.exit(0)

    # Ostrzeżenie
    elif code[0] == 'W':
        TKmsb.showwarning('Ostrzeżenie', '%s\n%s' % (MSGlist[code], optionalInfo[0]))
        if terminate:
            SS.exit(0)
    
    # Zapytania
    elif code[0] == 'A':
        if TKmsb.askokcancel('Pytanie', '%s\n%s' % (MSGlist[code], optionalInfo[0])):
            return True
        else:
            return False





# ------------------------- # Sprawdzanie katalogu programu w APPDATA # ------------------------- #

class checkAppdata:
    def __init__(self):
        if 'Generator CSV' in [x for x in OS.listdir(VAR.appdataPath)]:
            if 'version' in [x for x in OS.listdir(str(VAR.appdataPath) + '\Generator CSV')]:
                versionFile = CD.open((str(VAR.appdataPath) + r'\Generator CSV\version'), 'r', 'utf-8')
                if versionFile.read() == VAR.programVersionBuild:
                    versionFile.close()
                    if 'config.cfg' not in [x for x in OS.listdir(str(VAR.appdataPath) + '\Generator CSV')]:
                        self.__restoreCFG('config')
                    if 'style.cfg' not in [x for x in OS.listdir(str(VAR.appdataPath) + '\Generator CSV')]:
                        self.__restoreCFG('style')
                    if 'format-presets' not in [x for x in OS.listdir(str(VAR.appdataPath) + '\Generator CSV')]:
                        self.__createFormatPresetsDir()
                else:
                    versionFile.close()
                    if MSG('A0009', False):
                        self.__resetAppdata()
                        MSG('I0002', True)
                    else: SS.exit(0)
            else:
                if MSG('A0008', False):
                    self.__resetAppdata()
                    MSG('I0002', True)
                else: SS.exit(0)
        else: self.__buildAppdata()


    # Budowanie katalogu programu
    def __buildAppdata(self):
        try:
            OS.mkdir(str(VAR.appdataPath) + '\Generator CSV')

            versionFile = CD.open((str(VAR.appdataPath) + r'\Generator CSV\version'), 'w', 'utf-8')
            versionFile.write(VAR.programVersionBuild)
            versionFile.close()
        except Exception as exceptInfo:
            MSG('E0001', True, exceptInfo)

        self.__restoreCFG('config')
        self.__restoreCFG('style')
        self.__createFormatPresetsDir()
    

    # Resetowanie katalogu programu
    def __resetAppdata(self):
        try:
            if 'Generator CSV_old' in [x for x in OS.listdir(str(VAR.appdataPath) + '\Generator CSV')]:
                SU.rmtree(str(VAR.appdataPath) + '\Generator CSV\Generator CSV_old')
            OS.rename((str(VAR.appdataPath) + '\Generator CSV'), (str(VAR.appdataPath) + '\Generator CSV_old'))
        except Exception as exceptInfo:
            MSG('E0001', True, exceptInfo)

        self.__buildAppdata()

        try:
            SU.move((str(VAR.appdataPath) + '\Generator CSV_old'), (str(VAR.appdataPath) + '\Generator CSV\Generator CSV_old'))
        except Exception as exceptInfo:
            MSG('E0001', True, exceptInfo)
    

    # Przywracanie plików konfiguracyjnych
    def __restoreCFG(self, configFileName):
        try:
            SU.copy(('configs\%s.cfg' % configFileName), str(VAR.appdataPath) + ('\Generator CSV\%s.cfg' % configFileName))
        except Exception as exceptInfo:
            MSG('E0001', True, exceptInfo)
    

    # Tworzenie katalogu przechowującego format presety
    def __createFormatPresetsDir(self):
        try:
            OS.mkdir(str(VAR.appdataPath) + r'\Generator CSV\format-presets')
        except Exception as exceptInfo:
            MSG('E0001', True, exceptInfo)



checkAppdata()





# ------------------ # Ładowanie głównego pliku konfiguracyjnego 'config.cfg' # ----------------- #

class CFG:
    def R(self, record):
        self.__checkIfFileExist(False)
        content = {}
        for x in CD.open((str(VAR.appdataPath) + '\Generator CSV\config.cfg'), 'r', 'utf-8').read().strip('\r').split('\n'):
            x = x.split(' = ')
            try:
                name = x[0].split('(')[0]
                var = x[1]
                type = x[0].split('(')[1].strip(')')
                content[name] = [var, type] 
            except:
                continue
        checkingOutput = self.__checkIfRecordExist(content, record)
        if not checkingOutput[0]:
            MSG('E0003', True, checkingOutput[1])
        var = content[record]
        if var[1] == 'S':
            # String
            var = var[0].strip('\r')
            return var
        elif var[1] == 'Sc':
            # Integer
            checkingOutput = self.__checkSc(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0003', True, checkingOutput[1])
        elif var[1] == 'I':
            # Integer
            checkingOutput = self.__checkI(False, record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0003', True, checkingOutput[1])
        elif var[1] == 'D':
            # Date (DD.MM.RRRR HH:MM:SS)
            checkingOutput = self.__checkD(False, record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0003', True, checkingOutput[1])
        elif var[1] == 'MSAs':
            # Multiple Specified Arrays - schoolData
            checkingOutput = self.__checkMSAs(False, record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0003', True, checkingOutput[1])
        elif var[1] == 'B':
            # Boolean
            checkingOutput = self.__checkB(False, record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0003', True, checkingOutput[1])
        else:
            MSG('E0003', True, 'Nie można rozpoznać typu klucza %s' % record)
    
    def W(self, changes):
        self.__checkIfFileExist(True)
        file = CD.open(str(VAR.appdataPath) + '\Generator CSV\config.cfg', 'r', 'utf-8').read().split('\n')
        if file[-1] == '':
            file = file[:-1]
        content = {}
        for x in file:
            x = x.split(' = ')
            try:
                name = x[0].split('(')[0]
                var = x[1]
                type = x[0].split('(')[1].strip(')')
                content[name] = [var, type]
            except Exception as exceptInfo:
                MSG('E0003', False, exceptInfo)
        for x in changes:
            name = x
            var = changes[name]
            type = (content[name])[1]
            if type == 'S':
                # String
                pass
            elif type == 'Sc':
                # Integer
                checkingOutput = self.__checkSc(name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'I':
                # Integer
                checkingOutput = self.__checkI(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'D':
                # Date (DD.MM.RRRR HH:MM:SS)
                checkingOutput = self.__checkD(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'MSAs':
                # Multiple Specified Arrays - schoolData
                checkingOutput = self.__checkMSAs(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'B':
                # Boolean
                checkingOutput = self.__checkB(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            else:
                MSG('E0003', False, 'Nie można rozpoznać typu klucza %s' % name)
                return False
            content[name] = [var, type]
        with CD.open(str(VAR.appdataPath) + '\Generator CSV\config.cfg', 'w', 'utf-8') as file:
            for x in content:
                file.write('%s(%s) = %s\n' % (x, (content[x])[1], (content[x][0])))
        return True


    # Funkcje sprawdzające istnienie
    def __checkIfFileExist(self, write):
        if write:
            try:
                checkAppdata()
                file = open((str(VAR.appdataPath) + '\Generator CSV\config.cfg'), 'a')
            except Exception as exceptInfo:
                MSG('E0002', True, exceptInfo)
                return False
            else:
                if not file.writable():
                    MSG('E0002', False, 'Plik tylko do odczytu')
                    return False
                else:
                    return True
        else:
            try:
                checkAppdata()
                open(str(VAR.appdataPath) + '\Generator CSV\config.cfg')
            except Exception as exceptInfo:
                MSG('E0002', True, exceptInfo)

    def __checkIfRecordExist(self, content, record):
        if record in list(content.keys()):
            return [True]
        else:
            return [False, 'Brak danych - klucz: %s' % record]

    
    # Funkcje sprawdzające poprawność recordu
    def __checkI(self, write, record, var):
        if write:
            try:
                var = int(var)
            except:
                return (False, 'Niepoprawne dane - klucz: %s' % record)
            var = str(var)
        else:
            try:
                var = int(var)
            except:
                return (False, 'Niepoprawne dane - klucz: %s' % record)
        return [True, var]
    
    def __checkD(self, write, record, var):
        if write:
            varX = ''
            if var['D'] == None:
                varX += '*'
            else:
                try:
                    var['D'] = int(var['D'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['D']) > 31 or int(var['D']) < 1:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                day = str(var['D'])
                if len(day) == 1:
                    day = '0' + day
                varX += day
            varX += '.'
            if var['M'] == None:
                varX += '*'
            else:
                try:
                    var['M'] = int(var['M'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['M']) > 12 or int(var['M']) < 1:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                month = str(var['M'])
                if len(month) == 1:
                    month = '0' + month
                varX += month
            varX += '.'
            if var['Y'] == None:
                varX += '*'
            else:
                try:
                    var['Y'] = int(var['Y'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['Y']) == 0:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                varX += str(var['Y'])
            varX += ' '
            if var['h'] == None:
                varX += '*'
            else:
                try:
                    var['h'] = int(var['h'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['h']) > 23 or int(var['h']) < 1:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                hour = str(var['h'])
                if len(hour) == 1:
                    hour = '0' + hour
                varX += hour
            varX += ':'
            if var['m'] == None:
                varX += '*'
            else:
                try:
                    var['m'] = int(var['m'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['m']) > 59 or int(var['m']) < 0:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                minute = str(var['m'])
                if len(minute) == 1:
                    minute = '0' + minute
                varX += minute
            varX += ':'
            if var['s'] == None:
                varX += '*'
            else:
                try:
                    var['s'] = int(var['s'])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if int(var['s']) > 59 or int(var['s']) < 0:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                seconds = str(var['s'])
                if len(seconds) == 1:
                    seconds = '0' + seconds
                varX += seconds
            var = varX
        else:
            varToReturn = {}
            var = var.split(' ')
            try:
                var[0] = var[0].split('.')
                var[1] = var[1].split(':')
                var = var[0] + var[1]
                dateLabels = ['D', 'M', 'Y', 'h', 'm', 's']
                if len(var) != len(dateLabels):
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                index = 0
                for x in var:
                    x = x.strip('\r')
                    if x != '*':
                        try:
                            x = int(x)
                        except:
                            return (False, 'Niepoprawne dane - klucz: %s' % record)
                        varToReturn[dateLabels[index]] = int(x)
                    else:
                        varToReturn[dateLabels[index]] = None
                    index += 1
            except:
                return (False, 'Niepoprawne dane - klucz: %s' % record)
            var = varToReturn
        return [True, var]

    def __checkMSAs(self, write, record, var):
        if write:
            varX = []
            while var.count(''):
                var.remove('')
            for x in var:
                check = x.split(' | ')
                if len(check) != 3:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                try:
                    checkX = int(check[1])
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                if not (check[2] == '0' or check[2] == '1'):
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                x = x.replace(' | ', ', ')
                x = '[' + x + ']'
                varX.append(x)
            var = '|'.join(varX)
        else:
            var = var.split('|')
            var = [x.strip('\r').strip('[').strip(']').split(', ') for x in var]
            newVar = []
            for x in var:
                if len(x) != 3:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                try:
                    if x[2] == '0':
                        x[2] = False
                    elif x[2] == '1':
                        x[2] = True
                    else:
                        return (False, 'Niepoprawne dane - klucz: %s' % record)
                    x = [x[0], int(x[1]), x[2]]
                    newVar.append(x)
                except:
                    return (False, 'Niepoprawne dane - klucz: %s' % record)
                var = newVar
        return [True, var]

    def __checkSc(self, record, var):
        var = var.strip('\r')
        if var not in VAR.allowedCoding:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]
    
    def __checkB(self, write, record, var):
        if write:
            if var:
                var = '1'
            else:
                var = '0'
        else:
            try:
                var = int(var)
            except:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
            if var != 0 and var != 1:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
            else:
                if var == 0:
                    var = False
                else:
                    var = True
        return [True, var]



CFG = CFG()





# -------------------- # Ładowanie pliku konfiguracyjnego stylu 'style.cfg' # ------------------- #

class GUI:
    # Odczytywanie pojedyńczej zmiennej z pliku
    def R(self, record):
        self.__checkIfFileExist()
        content = {}
        for x in CD.open((str(VAR.appdataPath) + '\Generator CSV\style.cfg'), 'r', 'utf-8').read().strip('\r').split('\n'):
            x = x.split(' = ')
            try:
                name = x[0].split('(')[0]
                var = x[1]
                type = x[0].split('(')[1].strip(')')
                content[name] = [var.strip('\r'), type] 
            except:
                continue
        checkingOutput = self.__checkIfRecordExist(content, record)
        if not checkingOutput[0]:
            MSG('E0005', True, checkingOutput[1])
        var = content[record]
        if var[1] == 'I':
            # Integer
            checkingOutput = self.__checkI(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        elif var[1] == 'B':
            # Boolean
            checkingOutput = self.__checkB(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        elif var[1] == 'C':
            # Color
            checkingOutput = self.__checkC(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        elif var[1] == 'P':
            # Path
            checkingOutput = self.__checkP(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        elif (var[1])[:2] == 'FA':
            # From Array
            checkingOutput = self.__checkFA(record, var[0], (var[1])[2:])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        elif var[1] == 'F':
            # Font
            checkingOutput = self.__checkF(record, var[0])
            if checkingOutput[0]:
                return checkingOutput[1]
            else:
                MSG('E0005', True, checkingOutput[1])
        else:
            MSG('E0005', True, 'Nie można rozpoznać typu klucza %s' % record)
    
    # Funkcje sprawdzające istnienie
    def __checkIfFileExist(self):
        try:
            checkAppdata()
            open(str(VAR.appdataPath) + '\Generator CSV\style.cfg')
        except Exception as exceptInfo:
            checkAppdata()
    
    def __checkIfRecordExist(self, content, record):
        if record in list(content.keys()):
            return [True]
        else:
            return [False, 'Brak danych - klucz: %s' % record]
    

    # Funkcje sprawdzające poprawność rekordu
    def __checkI(self, record, var):
        try:
            var = int(var)
        except:
            return (False, 'Niepoprawne dane - klucz: %s' % record)
        return [True, var]
    
    def __checkB(self, record, var):
        try:
            var = int(var)
        except:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        if var != 0 and var != 1:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        else:
            if var == 0:
                var = False
            else:
                var = True
        return [True, var]
    
    def __checkC(self, record, var):
        if len(var) != 7:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        else:
            if var[0] != '#':
                return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]
    
    def __checkP(self, record, var):
        try:
            check = open(var)
        except:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]
    
    def __checkFA(self, record, var, array):
        arrays = {
            'position' : ['nw', 'ne', 'en', 'es', 'se', 'sw', 'ws', 'wn'],
            'anchor' : ['center', 'nw', 'n', 'ne', 'w', 'e', 'sw', 's', 'se'],
            'relief' : ['flat', 'raised', 'sunken', 'groove', 'ridge'],
            'fill' : ['x', 'y', 'both'],
            'activestyle' : ['dotbox', 'none', 'underline']
        }
        if var not in arrays[array]:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]
    
    def __checkF(self, record, var):
        try:
            check = int(var.split(';')[1])
        except:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        else:
            var = (var.split(';')[0], int(var.split(';')[1]))
        return [True, var]



GUI = GUI()





# ------------------------------- # Zarządzanie plikami formatu # ------------------------------- #

class FMT:
    # Odczytywanie pojedyńczej zmiennej z pliku
    def R(self, preset, record):
        self.__checkIfFolderExist()
        if preset in self.getList():
            path = str(VAR.appdataPath) + '/Generator CSV/format-presets/%s.fmt' % preset
            file = CD.open(path, 'r', 'utf-8').read().strip('\r').split('\n')
            content = {}
            for x in file:
                x = x.split(' = ')
                try:
                    name = x[0].split('(')[0]
                    var = x[1]
                    type = x[0].split('(')[1].strip(')')
                    content[name] = [var, type] 
                except:
                    continue
            checkingOutput = self.__checkIfRecordExist(content, record)
            if not checkingOutput[0]:
                MSG('E0006', False, checkingOutput[1])
            var = content[record]
            if var[1] == 'B':
                # Boolean
                checkingOutput = self.__checkB(False, record, var[0])
                if checkingOutput[0]:
                    return checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
            elif var[1] == 'Ss':
                # String - separator
                checkingOutput = self.__checkSs(record, var[0])
                if checkingOutput[0]:
                    return checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
            elif var[1] == 'As':
                # Array - separator
                checkingOutput = self.__checkAs(False, record, var[0])
                if checkingOutput[0]:
                    return checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
            elif var[1] == 'I':
                # Integer
                checkingOutput = self.__checkI(False, record, var[0])
                if checkingOutput[0]:
                    return checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
            elif var[1] == 'Sc':
                # Integer
                checkingOutput = self.__checkSc(record, var[0])
                if checkingOutput[0]:
                    return checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
            else:
                MSG('E0006', True, 'Nie można rozpoznać typu klucza %s' % record)
        else:
            content = {
                "student" : True,
                "personSeparator" : '',
                "rowSeparator" : '',
                "dataSeparators" : [],
                "loginRow" : 0,
                "loginPositionInRow" : 0,
                "fnameRow" : 0,
                "fnamePositionInRow" : 0,
                "lnameRow" : 0,
                "lnamePositionInRow" : 0,
                "schoolRow" : 0,
                "schoolPositionInRow" : 0,
                "classRow" : 0,
                "classPositionInRow" : 0,
                "inputCoding" : 'utf-8',
            }
            var = content[record]
        return var

    # Zapisywanie zmian w pliku
    def W(self, preset, changes):
        self.__checkIfFolderExist()
        if preset in self.getList():
            file = CD.open(str(VAR.appdataPath) + '/Generator CSV/format-presets/%s.fmt' % preset, 'r', 'utf-8').read().split('\n')
            if file[-1] == '':
                file = file[:-1]
            content = {}
            for x in file:
                x = x.split(' = ')
                try:
                    name = x[0].split('(')[0]
                    var = x[1]
                    type = x[0].split('(')[1].strip(')')
                    content[name] = [var, type]
                except Exception as exceptInfo:
                    MSG('E0006', False, exceptInfo)
        else:
            content = {
                "student" : ['1', 'B'],
                "personSeparator" : ['', 'Ss'],
                "rowSeparator" : ['', 'Ss'],
                "dataSeparators" : ['', 'As'],
                "loginRow" : ['0', 'I'],
                "loginPositionInRow" : ['0', 'I'],
                "fnameRow" : ['0', 'I'],
                "fnamePositionInRow" : ['0', 'I'],
                "lnameRow" : ['0', 'I'],
                "lnamePositionInRow" : ['0', 'I'],
                "schoolRow" : ['0', 'I'],
                "schoolPositionInRow" : ['0', 'I'],
                "classRow" : ['0', 'I'],
                "classPositionInRow" : ['0', 'I'],
                "inputCoding" : ['utf-8', 'Sc']
            }
        for x in changes:
            name = x
            var = changes[name]
            type = (content[name])[1]
            if type == 'B':
                checkingOutput = self.__checkB(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'Ss':
                checkingOutput = self.__checkSs(name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'As':
                checkingOutput = self.__checkAs(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'I':
                # Integer
                checkingOutput = self.__checkI(True, name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            elif type == 'Sc':
                checkingOutput = self.__checkSc(name, var)
                if checkingOutput[0]:
                    var = checkingOutput[1]
                else:
                    MSG('E0006', False, checkingOutput[1])
                    return False
            else:
                MSG('E0006', False, 'Nie można rozpoznać typu klucza %s' % name)
                return False
            content[name] = [var, type]
        try:
            with CD.open(str(VAR.appdataPath) + '/Generator CSV/format-presets/%s.fmt' % preset, 'w', 'utf-8') as file:
                for x in content:
                    file.write('%s(%s) = %s\n' % (x, (content[x])[1], (content[x][0])))
        except Exception as exceptInfo:
            MSG('E0017', False, exceptInfo)
            return False
        return True

    
    # Funkcja zwracająca listę presetów
    def getList(self):
        self.__checkIfFolderExist()
        filesList = OS.listdir(str(VAR.appdataPath) + '/Generator CSV/format-presets')
        formatPresetsList = []
        for x in filesList:
            if x[-4:] == '.fmt':
                formatPresetsList.append(x[:-4])
            else:
                continue
        return formatPresetsList


    # Funkcje sprawdzające istnienie
    def __checkIfFolderExist(self):
        checkAppdata()

    def __checkIfRecordExist(self, content, record):
        if record in list(content.keys()):
            return [True]
        else:
            return [False, 'Brak danych - klucz: %s' % record]

    
    # Funkcje sprawdzające poprawność rekordu
    def __checkB(self, write, record, var):
        if write:
            if var == True:
                var = '1'
            elif var == False:
                var = '0'
            else:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
        else:
            try:
                var = int(var)
            except:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
            if var != 0 and var != 1:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
            else:
                if var == 0:
                    var = False
                else:
                    var = True
        return [True, var]

    def __checkSs(self, record, var):
        check = var
        check = check.strip('<enter>')
        for x in check:
            if x not in VAR.allowedCharactersInSeparator:
                return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]
    
    def __checkAs(self, write, record, var):
        if write:
            check = var
            for x in check:
                x = x.strip('<enter>')
                for y in x:
                    if y not in VAR.allowedCharactersInSeparator:
                        return [False, 'Niepoprawne dane - klucz: %s' % record]
            var = str(var)
        else:
            new_contentVar = (var)[2:-2].split("', '")
            check = new_contentVar
            for x in check:
                x = x.strip('<enter>')
                for y in x:
                    if y not in VAR.allowedCharactersInSeparator:
                        return [False, 'Niepoprawne dane - klucz: %s' % record]
            var = new_contentVar
        return [True, var]
    
    def __checkI(self, write, record, var):
        if write:
            try:
                var = int(var)
            except:
                return (False, 'Niepoprawne dane - klucz: %s' % record)                
            var = str(var)
        else:
            try:
                var = int(var)
            except:
                return (False, 'Niepoprawne dane - klucz: %s' % record)
        return [True, var]
    
    def __checkSc(self, record, var):
        if var not in VAR.allowedCoding:
            return [False, 'Niepoprawne dane - klucz: %s' % record]
        return [True, var]



FMT = FMT()





# ---------------------------------- # Przetwarzanie plików # ----------------------------------- #

class dataProcess:
    def start(self, files):
        checkingOutput = []

        testOutput = self.__checkIfAtLeastOneInputFileIsFilled(files[:-1])
        checkingOutput.append(testOutput[0])
        if not testOutput[0]:
            return checkingOutput
        filledFiles = testOutput[1]

        testOutput = self.__checkIfInputFilesIsReadable(files[:-1], filledFiles)
        checkingOutput.append(testOutput)
        if not testOutput:
            return checkingOutput

        testOutput = self.__checkIfInputFilesFormatPresetsExist(files[:-1], filledFiles)
        checkingOutput.append(testOutput)
        if not testOutput:
            return checkingOutput

        input = []
        for x in filledFiles:
            input.append(files[x])
        output = files[-1]
        
        try:
            data = self.__getData(input)
        except:
            checkingOutput.append(False)
            return checkingOutput
        else:
            checkingOutput.append(True)
        
        for x in data:
            student = x[0]
            login = x[1]
            loginCheckingOutput = self.__checkLogin(login, student)
            if not loginCheckingOutput[0]:
                loginCheckingOutput[1] = loginCheckingOutput[1] + str(x[1:])
                checkingOutput.append(loginCheckingOutput)
                return checkingOutput
            fname = x[2]
            fnameCheckingOutput = self.__checkFname(fname)
            if not fnameCheckingOutput[0]:
                fnameCheckingOutput[1] = fnameCheckingOutput[1] + str(x[1:])
                checkingOutput.append(fnameCheckingOutput)
                return checkingOutput
            lname = x[3]
            lnameCheckingOutput = self.__checkLname(lname)
            if not lnameCheckingOutput[0]:
                lnameCheckingOutput[1] = lnameCheckingOutput[1] + str(x[1:])
                checkingOutput.append(lnameCheckingOutput)
                return checkingOutput
            if student:
                school = x[4]
                schoolCheckingOutput = self.__checkSchool(school)
                if not schoolCheckingOutput[0]:
                    schoolCheckingOutput[1] = schoolCheckingOutput[1] + str(x[1:])
                    checkingOutput.append(schoolCheckingOutput)
                    return checkingOutput
                classX = x[5]
                classCheckingOutput = self.__checkClass(classX, school)
                if not classCheckingOutput[0]:
                    classCheckingOutput[1] = classCheckingOutput[1] + str(x[1:])
                    checkingOutput.append(classCheckingOutput)
                    return checkingOutput
        checkingOutput.append([True])
        amount = len(data)
        
        try:
            data = self.__processData(data)
        except:
            checkingOutput.append(False)
            return checkingOutput
        else:
            checkingOutput.append(True)

        testOutput = self.__checkIfCreatingOutputFilesIsPossible(files[-1])
        checkingOutput.append(testOutput)
        if not testOutput:
            return checkingOutput
        
        try:
            self.__saveData(output, data)
        except:
            checkingOutput.append([False])
            return checkingOutput
        else:
            checkingOutput.append([True, amount])
            return checkingOutput
    

    # Funkcje sprawdzające istnienie
    def __checkIfAtLeastOneInputFileIsFilled(self, files):
        filledFiles = []
        index = 0
        for x in files:
            if not (x[0] == '' or x[1] == ''):
                filledFiles.append(index)
            index += 1
        if len(filledFiles) != 0:
            return [True, filledFiles]
        else:
            return [False]

    def __checkIfInputFilesIsReadable(self, files, filledFiles):
        for x in filledFiles:
            try:
                check = CD.open((files[x])[0], 'r', FMT.R((files[x])[1], 'inputCoding'))
            except:
                return False
        return True
    
    def __checkIfInputFilesFormatPresetsExist(self, files, filledFiles):
        for x in filledFiles:
            if (files[x])[1] not in FMT.getList():
                return False
        return True

    def __checkIfCreatingOutputFilesIsPossible(self, files):
        if files[0] == files[1]:
            return False
        try:
            check = CD.open(files[0], 'w', CFG.R('mailOutputCoding'))
            check = CD.open(files[1], 'w', CFG.R('officeOutputCoding'))
        except:
            return False
        return True
    

    # Funkcje sprawdzające poprawność
    def __checkLogin(self, var, student):
        if student and var[-1] != 'u':
            return [False, 'Brak końcówki "u" w loginie ucznia: ']
        if student:
            try:
                x = int(var[:-1])
            except:
                return [False, 'Niedozwolone znaki w loginie osoby: ']
        else:
            try:
                x = int(var)
            except:
                return [False, 'Niedozwolone znaki w loginie osoby: ']
        return [True]

    def __checkFname(self, var):
        if not var.isalpha():
            return [False, 'Niedozwolone znaki w imieniu osoby: ']
        return [True]

    def __checkLname(self, var):
        if not var.isalpha():
            return [False, 'Niedozwolone znaki w nazwisku osoby: ']
        return [True]
    
    def __checkSchool(self, var):
        allowedSchools = [x[0] for x in CFG.R('schoolData')]
        if var not in allowedSchools:
            return [False, 'Niewspierana szkoła w danych osoby: ']
        return [True]

    def __checkClass(self, var, school):
        if len(var) != 2:
            return [False, 'Niepoprawny format klasy w danych osoby: ']
        if not var[0].isdigit():
            return [False, 'Niepoprawny format klasy w danych osoby: ']
        if not var[1].isalpha():
            return [False, 'Niepoprawny format klasy w danych osoby: ']
        schoolData = {}
        for x in CFG.R('schoolData'):
            schoolData[x[0]] = x[1]
        if int(var[0]) == 0 or int(var[0]) > schoolData[school]:
            return [False, 'Numer klasy nie zgadza się z ilością klas szkoły w danych osoby: ']
        return [True]



    # Funkcje operujące na danych
    def __getData(self, input):
        data = []
        for x in input:
            path = x[0]
            format = x[1]
            personSeparator = FMT.R(format, 'personSeparator').replace('<enter>', '\r\n')
            linesSeparator = FMT.R(format, 'rowSeparator').replace('<enter>', '\r\n')
            dataSeparators = [x.replace('<enter>', '\n') for x in FMT.R(format, 'dataSeparators')]
            loginLocation = [FMT.R(format, 'loginRow'), FMT.R(format, 'loginPositionInRow')]
            fnameLocation = [FMT.R(format, 'fnameRow'), FMT.R(format, 'fnamePositionInRow')]
            lnameLocation = [FMT.R(format, 'lnameRow'), FMT.R(format, 'lnamePositionInRow')]
            schoolLocation = [FMT.R(format, 'schoolRow'), FMT.R(format, 'schoolPositionInRow')]
            classLocation = [FMT.R(format, 'classRow'), FMT.R(format, 'classPositionInRow')]
            student = FMT.R(format, 'student')
            file =  CD.open(path, 'r', FMT.R(format, 'inputCoding')).read().split(personSeparator)
            for x in file:
                lines = x.split(linesSeparator)
                dataX = []
                for line in lines:
                    line = [line]
                    for a in dataSeparators:
                        line2 = []
                        for b in line:
                            line2 += b.split(a)
                        line = line2
                    dataX.append(line)
                login = dataX[loginLocation[0] - 1][loginLocation[1] - 1]
                fname = dataX[fnameLocation[0] - 1][fnameLocation[1] - 1]
                lname = dataX[lnameLocation[0] - 1][lnameLocation[1] - 1]
                if student:
                    school = dataX[schoolLocation[0] - 1][schoolLocation[1] - 1]
                    classX = dataX[classLocation[0] - 1][classLocation[1] - 1]
                    data.append([student, login, fname, lname, school, classX])
                else:
                    data.append([student, login, fname, lname])
        return data
    
    def __processData(self, data):
        mailData = []
        officeData = []
        schoolData = {}
        for x in CFG.R('schoolData'):
            schoolData[x[0]] = [x[1], x[2]]
        for x in data:
            mail = ''
            office = ''
            mail += x[2].lower().replace('ę', 'e').replace('ó', 'o').replace('ą', 'a').replace('ś', 's').replace('ł', 'l').replace('ż', 'z').replace('ź', 'z').replace('ć', 'c').replace('ń', 'n')
            mail += '.'
            mail += x[3].lower().replace('ę', 'e').replace('ó', 'o').replace('ą', 'a').replace('ś', 's').replace('ł', 'l').replace('ż', 'z').replace('ź', 'z').replace('ć', 'c').replace('ń', 'n')
            if x[0]:
                classIndicator = ''
                actualYear = TM.localtime()
                schoolDuration = (schoolData[x[4]])[0]
                if actualYear[1] < CFG.R('schoolyearStart')['M'] or (actualYear[1] == CFG.R('schoolyearStart')['M'] and actualYear[2] < CFG.R('schoolyearStart')['D']):
                    yearOfGraduation = actualYear[0] + (schoolDuration - int((x[5])[0]))
                else:
                    yearOfGraduation = actualYear[0] + (schoolDuration - int((x[5])[0])) + 1
                mail += str(yearOfGraduation)
                if (schoolData[x[4]])[1]:
                    mail += x[4].lower()
                else:
                    mail += (x[5])[1].lower()
            mail += '@'
            mail += CFG.R('domain')
            office += mail
            mail += ','
            mail += x[1]
            mail += ':'
            mail += (x[2])[0].lower().replace('ę', 'e').replace('ó', 'o').replace('ą', 'a').replace('ś', 's').replace('ł', 'l').replace('ż', 'z').replace('ź', 'z').replace('ć', 'c').replace('ń', 'n').upper()
            mail += (x[3])[0].lower().replace('ę', 'e').replace('ó', 'o').replace('ą', 'a').replace('ś', 's').replace('ł', 'l').replace('ż', 'z').replace('ź', 'z').replace('ć', 'c').replace('ń', 'n').upper()
            mail += ','
            mail += str(CFG.R('quota'))
            office += ','
            office += x[2]
            office += ','
            office += x[3]
            office += ','
            office += '%s %s' % (x[2], x[3])
            office += ','
            if x[0]:
                office += 'uczeń'
            else:
                office += 'nauczyciel'
            office += ','
            if x[0]:
                office += str(yearOfGraduation)
                if (schoolData[x[4]])[1]:
                    office += x[4].lower()
                else:
                    office += (x[5])[1].lower()
            office += ','
            office += ','
            office += ','
            office += ','
            office += ','
            office += ','
            office += ','
            office += ','
            office += ','
            office += CFG.R('country')
            mailData.append(mail)
            officeData.append(office)
        return [mailData, officeData]

    def __saveData(self, output, data):
        mailPath = output[0]
        officePath = output[1]
        mailData = data[0]
        officeData = data[1]
        with CD.open(mailPath, 'w', CFG.R('mailOutputCoding')) as mail:
            if CFG.R('ifHeadlineInMail'):
                mail.write(CFG.R('headlineInMail') + '\n')
            mail.write('\n'.join(mailData))
        with CD.open(officePath, 'w', CFG.R('officeOutputCoding')) as office:
            if CFG.R('ifHeadlineInOffice'):
                office.write(CFG.R('headlineInOffice') + '\n')
            office.write('\n'.join(officeData))



dataProcess = dataProcess()





# ------------------------------------------- # GUI # ------------------------------------------- #

class mainWindow:
    def __init__(self, master):
        # Okno
        self.master = master
        master.title('%s %s %s' % (VAR.programName, VAR.programVersion, VAR.programVersionStage))
        master.geometry('%ix%i' % (GUI.R('windowWidth'), GUI.R('windowHeight')))
        master.resizable(width = GUI.R('windowWidthResizable'), height = GUI.R('windowHeightResizable'))
        master.configure(bg = GUI.R('windowMainBG'))
        master.iconbitmap(GUI.R('mainIcon'))




        # Theme
        TKttk.Style().theme_create("main", parent = "default", settings = {
            "mainMenu.TNotebook": {
                "configure": {
                    "background": GUI.R('mainMenuBG'),
                    "tabposition": GUI.R('mainMenuPosition'),
                    "borderwidth": GUI.R('tabFramesBorderWidth'),
                },
            },
            "mainMenu.TNotebook.Tab": {
                "configure": {
                    "background": GUI.R('unselectedTabBG'),
                    "borderwidth": GUI.R('menuTabsBorderWidth'),
                    "padding": GUI.R('menuTabsPadding'),
                },
                "map": {
                    "background": [
                        ("selected", GUI.R('selectedTabBG')),
                        ("disabled", GUI.R('disabledTabBG')),
                    ]
                }
            },
            "mainMenuTabFrame.TFrame": {
                "configure": {
                    "background": GUI.R('tabFrameBG'),
                },
            },
            "tabHeader.TLabel": {
                "configure": {
                    "font": GUI.R('headerFont'),
                    "background": GUI.R('headerBG'),
                    "foreground": GUI.R('headerTextColor'),
                    "padding": GUI.R('headerPadding'),
                    "anchor": GUI.R('headerTextAnchor'),
                },
            },
            "contentTabFrame.TFrame": {
                "configure": {
                    "background": GUI.R('contentTabFrameBG'),
                },
            },
            "layoutFrame.TFrame": {
                "configure": {
                    "background": GUI.R('layoutFrameBG'),
                },
            },
            "label1.TLabel": {
                "configure": {
                    "background": GUI.R('label1BG'),
                    "foreground": GUI.R('label1TextColor'),
                    "font": GUI.R('label1Font'),
                },
            },
            "label2.TLabel": {
                "configure": {
                    "background": GUI.R('label2BG'),
                    "foreground": GUI.R('label2TextColor'),
                    "font" : GUI.R('label2Font')
                },
            },
            "label3.TLabel": {
                "configure": {
                    "background": GUI.R('label3BG'),
                    "foreground": GUI.R('label3TextColor'),
                    "font" : GUI.R('label3Font')
                },
            },
            "label4.TLabel": {
                "configure": {
                    "background": GUI.R('label4BG'),
                    "foreground": GUI.R('label4TextColor'),
                    "font": GUI.R('label4Font'),
                },
            },
            "combobox1.TCombobox": {
                "configure": {
                    "arrowcolor": GUI.R('combobox1ArrowColor'),
                    "background": GUI.R('combobox1ButtonColor'),
                    "bordercolor": GUI.R('combobox1BorderColor'),
                    "fieldbackground": GUI.R('combobox1FieldBackground'),
                    "foreground": GUI.R('combobox1TextColor'),
                    "relief": GUI.R('combobox1Relief'),
                    "borderwidth": GUI.R('combobox1BorderWidth'),
                    "padding": GUI.R('combobox1Padding'),
                },
            },
            "combobox2.TCombobox": {
                "configure": {
                    "arrowcolor": GUI.R('combobox2ArrowColor'),
                    "background": GUI.R('combobox2ButtonColor'),
                    "bordercolor": GUI.R('combobox2BorderColor'),
                    "fieldbackground": GUI.R('combobox2FieldBackground'),
                    "foreground": GUI.R('combobox2TextColor'),
                    "relief": GUI.R('combobox2Relief'),
                    "borderwidth": GUI.R('combobox2BorderWidth'),
                    "padding": GUI.R('combobox2Padding'),
                },
            },
            "button1.TButton": {
                "configure": {
                    "anchor": GUI.R('button1TextAnchor'),
                    "background": GUI.R('button1Background'),
                    "foreground": GUI.R('button1Foreground'),
                    "padding": GUI.R('button1Padding'),
                },
            },
            "button2.TButton": {
                "configure": {
                    "anchor": GUI.R('button2TextAnchor'),
                    "background": GUI.R('button2Background'),
                    "padding": GUI.R('button2Padding'),
                },
            },
            "separator1.TSeparator": {
                "configure": {
                    "background": GUI.R('separator1BG'),
                },
            },
            "spinbox1.TSpinbox": {
                "configure": {
                    "arrowcolor": GUI.R('spinbox1ArrowColor'),
                    "fieldbackground": GUI.R('spinbox1FieldBackground'),
                    "relief": GUI.R('spinbox1Relief'),
                    "borderwidth": GUI.R('spinbox1BorderWidth'),
                    "foreground": GUI.R('spinbox1TextColor'),
                    "background": GUI.R('spinbox1ButtonColor'),
                    "padding" : GUI.R('spinbox1Padding'),
                },
            },
            "entry1.TEntry": {
                "configure": {
                    "fieldbackground": GUI.R('entry1FieldBackground'),
                    "relief": GUI.R('entry1Relief'),
                    "borderwidth": GUI.R('entry1BorderWidth'),
                    "padding": GUI.R('entry1Padding'),
                    "foreground": GUI.R('entry1TextColor'),
                },
            },
        })
        TKttk.Style().theme_use("main")




        # Menu główne
        self.mainMenu = TKttk.Notebook(master, width = master.winfo_width() - (2 * GUI.R('menuTabsPadding') + GUI.R('tabIconsSize')), height = master.winfo_height())
        self.mainMenu.config(style = "mainMenu.TNotebook")
        self.mainMenu.grid(row = 0)

        # Ikona
        self.iconTab = TKttk.Frame(self.mainMenu)
        self.iconTabImg = PLimg.open(GUI.R('iconTabIcon'))
        self.iconTabImg = self.iconTabImg.resize((GUI.R('tabIconsSize'), GUI.R('tabIconsSize')), PLimg.ANTIALIAS)
        self.iconTabImg = PLitk.PhotoImage(self.iconTabImg)
        self.mainMenu.add(self.iconTab, image = self.iconTabImg, state = TK.DISABLED)




        # TAB1 - Generator ####################################################

        self.generateTab = TKttk.Frame(self.mainMenu)
        self.generateTab.config(style = "mainMenuTabFrame.TFrame")
        self.generateTabImg = PLimg.open(GUI.R('generateTabIcon'))
        self.generateTabImg = self.generateTabImg.resize((GUI.R('tabIconsSize'), GUI.R('tabIconsSize')), PLimg.ANTIALIAS)
        self.generateTabImg = PLitk.PhotoImage(self.generateTabImg)
        self.mainMenu.add(self.generateTab, image = self.generateTabImg, state = TK.NORMAL)


        # Nagłówek
        self.generateHeader = TKttk.Label(self.generateTab)
        self.generateHeader.config(style = 'tabHeader.TLabel')
        self.generateHeader.config(text = 'GENERATOR CSV')
        self.generateHeader.pack(fill = GUI.R('headerFill'))


        # Zawartość
        self.generateFrame = TKttk.Frame(self.generateTab)
        self.generateFrame.config(style = 'contentTabFrame.TFrame')
        self.generateFrame.pack(fill = GUI.R('contentTabFrameFill'), expand = GUI.R('contentTabFrameExpand'), padx = GUI.R('tabFramePadding'), pady = GUI.R('tabFramePadding'))


        # (1) Pliki #################################################

        self.generateFilesFrame = TKttk.Frame(self.generateFrame)
        self.generateFilesFrame.config(style = 'layoutFrame.TFrame')
        self.generateFilesFrame.pack(fill = TK.BOTH, expand = 1)

        # (2) Pliki wejściowe #############################

        self.generateInputFilesFrame = TKttk.Frame(self.generateFilesFrame)
        self.generateInputFilesFrame.config(style = 'layoutFrame.TFrame')
        self.generateInputFilesFrame.pack(fill = TK.BOTH, expand = 1, padx = GUI.R('outsidelayoutFramesPadX'))

        # (3) Plik źródłowy 1 ###################

        self.GIF1Frame = TKttk.Frame(self.generateInputFilesFrame)
        self.GIF1Frame.config(style = 'layoutFrame.TFrame')
        self.GIF1Frame.pack(fill = TK.X, expand = 1, pady = int((GUI.R('GIFFrameSeparators')/2)))

        # "Plik źródłowy (1)"
        self.GIF1Label = TKttk.Label(self.GIF1Frame)
        self.GIF1Label.config(style = 'label1.TLabel')
        self.GIF1Label.config(width = GUI.R('generateFilesLabelWidth'))
        self.GIF1Label.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GIF1Label.config(padding = ('0 0 %s 0' % str(2 * GUI.R('generateInputFilesPadding'))))
        self.GIF1Label.config(text = 'Plik źródłowy (1)')
        self.GIF1Label.pack(side = TK.LEFT)

        # Plik żródłowy (1) - Ustawienia
        self.GIF1SFrame = TKttk.Frame(self.GIF1Frame)
        self.GIF1SFrame.config(style = 'layoutFrame.TFrame')
        self.GIF1SFrame.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        # Lokalizacja
        self.GIF1SLocalizationFrame = TKttk.Frame(self.GIF1SFrame)
        self.GIF1SLocalizationFrame.config(style = 'layoutFrame.TFrame')
        self.GIF1SLocalizationFrame.pack(side = TK.TOP, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Entry
        self.GIF1SLocalizationEntryVar = TK.StringVar()
        self.GIF1SLocalizationEntry = TKttk.Entry(self.GIF1SLocalizationFrame)
        self.GIF1SLocalizationEntry.config(style = 'entry1.TEntry')
        self.GIF1SLocalizationEntry.config(textvariable = self.GIF1SLocalizationEntryVar)
        self.GIF1SLocalizationEntry.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Button
        self.GIF1SLocalizationButton = TKttk.Button(self.GIF1SLocalizationFrame)
        self.GIF1SLocalizationButton.config(style = 'button1.TButton')
        self.GIF1SLocalizationButton.config(text = 'Przeglądaj')
        self.GIF1SLocalizationButton.config(command = self.GIF1SLocalizationButtonAction)
        self.GIF1SLocalizationButton.pack(side = TK.RIGHT, padx = GUI.R('generateInputFilesPadding'))

        # Format
        self.GIF1SFormatFrame = TKttk.Frame(self.GIF1SFrame)
        self.GIF1SFormatFrame.config(style = 'layoutFrame.TFrame')
        self.GIF1SFormatFrame.pack(side = TK.BOTTOM, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Format - Label
        self.GIF1SFormatLabel = TKttk.Label(self.GIF1SFormatFrame)
        self.GIF1SFormatLabel.config(style = 'label2.TLabel')
        self.GIF1SFormatLabel.config(text = 'Format')
        self.GIF1SFormatLabel.pack(side = TK.LEFT, padx = GUI.R('generateInputFilesPadding'))

        # Format - Combobox
        self.GIF1SFormatComboboxVar = TK.StringVar()
        self.GIF1SFormatCombobox = TKttk.Combobox(self.GIF1SFormatFrame)
        self.GIF1SFormatCombobox.config(style = 'combobox1.TCombobox')
        self.GIF1SFormatCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox1ListBoxBackground'))
        self.GIF1SFormatCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox1ListBoxForeground'))
        self.GIF1SFormatCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox1ListBoxSelectBackground'))
        self.GIF1SFormatCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox1ListBoxSelectForeground'))
        self.GIF1SFormatCombobox.config(state = 'readonly')
        self.GIF1SFormatCombobox.config(textvariable = self.GIF1SFormatComboboxVar)
        self.GIF1SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF1SFormatCombobox.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        #########################################

        # (3) Plik źródłowy 2 ###################

        self.GIF2Frame = TKttk.Frame(self.generateInputFilesFrame)
        self.GIF2Frame.config(style = 'layoutFrame.TFrame')
        self.GIF2Frame.pack(fill = TK.X, expand = 1, pady = int((GUI.R('GIFFrameSeparators')/2)))

        # "Plik źródłowy (1)"
        self.GIF2Label = TKttk.Label(self.GIF2Frame)
        self.GIF2Label.config(style = 'label1.TLabel')
        self.GIF2Label.config(width = GUI.R('generateFilesLabelWidth'))
        self.GIF2Label.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GIF2Label.config(padding = ('0 0 %s 0' % str(2 * GUI.R('generateInputFilesPadding'))))
        self.GIF2Label.config(text = 'Plik źródłowy (2)')
        self.GIF2Label.pack(side = TK.LEFT)

        # Plik żródłowy (1) - Ustawienia
        self.GIF2SFrame = TKttk.Frame(self.GIF2Frame)
        self.GIF2SFrame.config(style = 'layoutFrame.TFrame')
        self.GIF2SFrame.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        # Lokalizacja
        self.GIF2SLocalizationFrame = TKttk.Frame(self.GIF2SFrame)
        self.GIF2SLocalizationFrame.config(style = 'layoutFrame.TFrame')
        self.GIF2SLocalizationFrame.pack(side = TK.TOP, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Entry
        self.GIF2SLocalizationEntryVar = TK.StringVar()
        self.GIF2SLocalizationEntry = TKttk.Entry(self.GIF2SLocalizationFrame)
        self.GIF2SLocalizationEntry.config(style = 'entry1.TEntry')
        self.GIF2SLocalizationEntry.config(textvariable = self.GIF2SLocalizationEntryVar)
        self.GIF2SLocalizationEntry.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Button
        self.GIF2SLocalizationButton = TKttk.Button(self.GIF2SLocalizationFrame)
        self.GIF2SLocalizationButton.config(style = 'button1.TButton')
        self.GIF2SLocalizationButton.config(text = 'Przeglądaj')
        self.GIF2SLocalizationButton.config(command = self.GIF2SLocalizationButtonAction)
        self.GIF2SLocalizationButton.pack(side = TK.RIGHT, padx = GUI.R('generateInputFilesPadding'))

        # Format
        self.GIF2SFormatFrame = TKttk.Frame(self.GIF2SFrame)
        self.GIF2SFormatFrame.config(style = 'layoutFrame.TFrame')
        self.GIF2SFormatFrame.pack(side = TK.BOTTOM, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Format - Label
        self.GIF2SFormatLabel = TKttk.Label(self.GIF2SFormatFrame)
        self.GIF2SFormatLabel.config(style = 'label2.TLabel')
        self.GIF2SFormatLabel.config(text = 'Format')
        self.GIF2SFormatLabel.pack(side = TK.LEFT, padx = GUI.R('generateInputFilesPadding'))

        # Format - Combobox
        self.GIF2SFormatComboboxVar = TK.StringVar()
        self.GIF2SFormatCombobox = TKttk.Combobox(self.GIF2SFormatFrame)
        self.GIF2SFormatCombobox.config(style = 'combobox1.TCombobox')
        self.GIF2SFormatCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox1ListBoxBackground'))
        self.GIF2SFormatCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox1ListBoxForeground'))
        self.GIF2SFormatCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox1ListBoxSelectBackground'))
        self.GIF2SFormatCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox1ListBoxSelectForeground'))
        self.GIF2SFormatCombobox.config(state = 'readonly')
        self.GIF2SFormatCombobox.config(textvariable = self.GIF2SFormatComboboxVar)
        self.GIF2SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF2SFormatCombobox.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        #########################################

        # (3) Plik źródłowy 3 ###################

        self.GIF3Frame = TKttk.Frame(self.generateInputFilesFrame)
        self.GIF3Frame.config(style = 'layoutFrame.TFrame')
        self.GIF3Frame.pack(fill = TK.X, expand = 1, pady = int((GUI.R('GIFFrameSeparators')/2)))

        # "Plik źródłowy (1)"
        self.GIF3Label = TKttk.Label(self.GIF3Frame)
        self.GIF3Label.config(style = 'label1.TLabel')
        self.GIF3Label.config(width = GUI.R('generateFilesLabelWidth'))
        self.GIF3Label.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GIF3Label.config(padding = ('0 0 %s 0' % str(2 * GUI.R('generateInputFilesPadding'))))
        self.GIF3Label.config(text = 'Plik źródłowy (3)')
        self.GIF3Label.pack(side = TK.LEFT)

        # Plik żródłowy (1) - Ustawienia
        self.GIF3SFrame = TKttk.Frame(self.GIF3Frame)
        self.GIF3SFrame.config(style = 'layoutFrame.TFrame')
        self.GIF3SFrame.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        # Lokalizacja
        self.GIF3SLocalizationFrame = TKttk.Frame(self.GIF3SFrame)
        self.GIF3SLocalizationFrame.config(style = 'layoutFrame.TFrame')
        self.GIF3SLocalizationFrame.pack(side = TK.TOP, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Entry
        self.GIF3SLocalizationEntryVar = TK.StringVar()
        self.GIF3SLocalizationEntry = TKttk.Entry(self.GIF3SLocalizationFrame)
        self.GIF3SLocalizationEntry.config(style = 'entry1.TEntry')
        self.GIF3SLocalizationEntry.config(textvariable = self.GIF3SLocalizationEntryVar)
        self.GIF3SLocalizationEntry.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Button
        self.GIF3SLocalizationButton = TKttk.Button(self.GIF3SLocalizationFrame)
        self.GIF3SLocalizationButton.config(style = 'button1.TButton')
        self.GIF3SLocalizationButton.config(text = 'Przeglądaj')
        self.GIF3SLocalizationButton.config(command = self.GIF3SLocalizationButtonAction)
        self.GIF3SLocalizationButton.pack(side = TK.RIGHT, padx = GUI.R('generateInputFilesPadding'))

        # Format
        self.GIF3SFormatFrame = TKttk.Frame(self.GIF3SFrame)
        self.GIF3SFormatFrame.config(style = 'layoutFrame.TFrame')
        self.GIF3SFormatFrame.pack(side = TK.BOTTOM, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Format - Label
        self.GIF3SFormatLabel = TKttk.Label(self.GIF3SFormatFrame)
        self.GIF3SFormatLabel.config(style = 'label2.TLabel')
        self.GIF3SFormatLabel.config(text = 'Format')
        self.GIF3SFormatLabel.pack(side = TK.LEFT, padx = GUI.R('generateInputFilesPadding'))

        # Format - Combobox
        self.GIF3SFormatComboboxVar = TK.StringVar()
        self.GIF3SFormatCombobox = TKttk.Combobox(self.GIF3SFormatFrame)
        self.GIF3SFormatCombobox.config(style = 'combobox1.TCombobox')
        self.GIF3SFormatCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox1ListBoxBackground'))
        self.GIF3SFormatCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox1ListBoxForeground'))
        self.GIF3SFormatCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox1ListBoxSelectBackground'))
        self.GIF3SFormatCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox1ListBoxSelectForeground'))
        self.GIF3SFormatCombobox.config(state = 'readonly')
        self.GIF3SFormatCombobox.config(textvariable = self.GIF3SFormatComboboxVar)
        self.GIF3SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF3SFormatCombobox.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        #########################################

        # (3) Plik źródłowy 4 ###################

        self.GIF4Frame = TKttk.Frame(self.generateInputFilesFrame)
        self.GIF4Frame.config(style = 'layoutFrame.TFrame')
        self.GIF4Frame.pack(fill = TK.X, expand = 1, pady = int((GUI.R('GIFFrameSeparators')/2)))

        # "Plik źródłowy (1)"
        self.GIF4Label = TKttk.Label(self.GIF4Frame)
        self.GIF4Label.config(style = 'label1.TLabel')
        self.GIF4Label.config(width = GUI.R('generateFilesLabelWidth'))
        self.GIF4Label.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GIF4Label.config(padding = ('0 0 %s 0' % str(2 * GUI.R('generateInputFilesPadding'))))
        self.GIF4Label.config(text = 'Plik źródłowy (4)')
        self.GIF4Label.pack(side = TK.LEFT)

        # Plik żródłowy (1) - Ustawienia
        self.GIF4SFrame = TKttk.Frame(self.GIF4Frame)
        self.GIF4SFrame.config(style = 'layoutFrame.TFrame')
        self.GIF4SFrame.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        # Lokalizacja
        self.GIF4SLocalizationFrame = TKttk.Frame(self.GIF4SFrame)
        self.GIF4SLocalizationFrame.config(style = 'layoutFrame.TFrame')
        self.GIF4SLocalizationFrame.pack(side = TK.TOP, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Entry
        self.GIF4SLocalizationEntryVar = TK.StringVar()
        self.GIF4SLocalizationEntry = TKttk.Entry(self.GIF4SLocalizationFrame)
        self.GIF4SLocalizationEntry.config(style = 'entry1.TEntry')
        self.GIF4SLocalizationEntry.config(textvariable = self.GIF4SLocalizationEntryVar)
        self.GIF4SLocalizationEntry.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        # Lokalizacja - Button
        self.GIF4SLocalizationButton = TKttk.Button(self.GIF4SLocalizationFrame)
        self.GIF4SLocalizationButton.config(style = 'button1.TButton')
        self.GIF4SLocalizationButton.config(text = 'Przeglądaj')
        self.GIF4SLocalizationButton.config(command = self.GIF4SLocalizationButtonAction)
        self.GIF4SLocalizationButton.pack(side = TK.RIGHT, padx = GUI.R('generateInputFilesPadding'))

        # Format
        self.GIF4SFormatFrame = TKttk.Frame(self.GIF4SFrame)
        self.GIF4SFormatFrame.config(style = 'layoutFrame.TFrame')
        self.GIF4SFormatFrame.pack(side = TK.BOTTOM, fill = TK.X, expand = 1, pady = GUI.R('generateInputFilesPadding'))

        # Format - Label
        self.GIF4SFormatLabel = TKttk.Label(self.GIF4SFormatFrame)
        self.GIF4SFormatLabel.config(style = 'label2.TLabel')
        self.GIF4SFormatLabel.config(text = 'Format')
        self.GIF4SFormatLabel.pack(side = TK.LEFT, padx = GUI.R('generateInputFilesPadding'))

        # Format - Combobox
        self.GIF4SFormatComboboxVar = TK.StringVar()
        self.GIF4SFormatCombobox = TKttk.Combobox(self.GIF4SFormatFrame)
        self.GIF4SFormatCombobox.config(style = 'combobox1.TCombobox')
        self.GIF4SFormatCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox1ListBoxBackground'))
        self.GIF4SFormatCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox1ListBoxForeground'))
        self.GIF4SFormatCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox1ListBoxSelectBackground'))
        self.GIF4SFormatCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox1ListBoxSelectForeground'))
        self.GIF4SFormatCombobox.config(state = 'readonly')
        self.GIF4SFormatCombobox.config(textvariable = self.GIF4SFormatComboboxVar)
        self.GIF4SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF4SFormatCombobox.pack(side = TK.LEFT, expand = 1, fill = TK.X, padx = GUI.R('generateInputFilesPadding'))

        #########################################

        ###################################################

        # (2) Separator1 ##################################

        self.generateSeparator1 = TKttk.Separator(self.generateFilesFrame)
        self.generateSeparator1.config(style = 'separator1.TSeparator')
        self.generateSeparator1.config(orient = TK.HORIZONTAL)
        self.generateSeparator1.pack(fill = TK.X, pady = GUI.R('generateHorizontalSeparatorPadY'))

        ###################################################

        # (2) Pliki wyjściowe #############################
    
        self.generateOutputFilesFrame = TKttk.Frame(self.generateFilesFrame)
        self.generateOutputFilesFrame.config(style = 'layoutFrame.TFrame')
        self.generateOutputFilesFrame.pack(fill = TK.X, padx = GUI.R('outsidelayoutFramesPadX'))

        # (3) Poczta ############################

        self.GOFMailFrame = TKttk.Frame(self.generateOutputFilesFrame)
        self.GOFMailFrame.config(style = 'layoutFrame.TFrame')
        self.GOFMailFrame.pack(pady = GUI.R('generateOutputFilesPadding'), fill = TK.X, expand = 1)

        # "Poczta"
        self.GOFMailLabel = TKttk.Label(self.GOFMailFrame)
        self.GOFMailLabel.config(style = 'label1.TLabel')
        self.GOFMailLabel.config(width = GUI.R('generateFilesLabelWidth'))
        self.GOFMailLabel.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GOFMailLabel.config(text = 'Poczta')
        self.GOFMailLabel.pack(side = TK.LEFT)

        # Plik poczty - Lokalizacja (Entry)
        self.GOFMailEntryVar = TK.StringVar()
        self.GOFMailEntry = TKttk.Entry(self.GOFMailFrame)
        self.GOFMailEntry.config(style = 'entry1.TEntry')
        self.GOFMailEntry.config(textvariable = self.GOFMailEntryVar)
        self.GOFMailEntry.pack(padx = 2 * GUI.R('generateOutputFilesPadding'), side = TK.LEFT, fill = TK.X, expand = 1)

        # Plik poczty - Lokalizacja (Button)
        self.GOFMailButton = TKttk.Button(self.GOFMailFrame)
        self.GOFMailButton.config(style = 'button1.TButton')
        self.GOFMailButton.config(text = 'Przeglądaj')
        self.GOFMailButton.config(command = self.GOFMailButtonAction)
        self.GOFMailButton.pack(side = TK.LEFT)
        
        #########################################

        # (3) Office ############################

        self.GOFOfficeFrame = TKttk.Frame(self.generateOutputFilesFrame)
        self.GOFOfficeFrame.config(style = 'layoutFrame.TFrame')
        self.GOFOfficeFrame.pack(pady = GUI.R('generateOutputFilesPadding'), fill = TK.X, expand = 1)

        # "Office"
        self.GOFOfficeLabel = TKttk.Label(self.GOFOfficeFrame)
        self.GOFOfficeLabel.config(style = 'label1.TLabel')
        self.GOFOfficeLabel.config(width = GUI.R('generateFilesLabelWidth'))
        self.GOFOfficeLabel.config(anchor = GUI.R('generateFilesLabelAnchor'))
        self.GOFOfficeLabel.config(text = 'Office')
        self.GOFOfficeLabel.pack(side = TK.LEFT)

        # Plik office - Lokalizacja (Entry)
        self.GOFOfficeEntryVar = TK.StringVar()
        self.GOFOfficeEntry = TKttk.Entry(self.GOFOfficeFrame)
        self.GOFOfficeEntry.config(style = 'entry1.TEntry')
        self.GOFOfficeEntry.config(textvariable = self.GOFOfficeEntryVar)
        self.GOFOfficeEntry.pack(padx = 2 * GUI.R('generateOutputFilesPadding'), side = TK.LEFT, fill = TK.X, expand = 1)

        # Plik office - Lokalizacja (Button)
        self.GOFOfficeButton = TKttk.Button(self.GOFOfficeFrame)
        self.GOFOfficeButton.config(style = 'button1.TButton')
        self.GOFOfficeButton.config(text = 'Przeglądaj')
        self.GOFOfficeButton.config(command = self.GOFOfficeButtonAction)
        self.GOFOfficeButton.pack(side = TK.LEFT)

        #########################################

        ###################################################

        #############################################################

         # (1) Separator2 ###########################################

        self.generateSeparator2 = TKttk.Separator(self.generateFrame)
        self.generateSeparator2.config(style = 'separator1.TSeparator')
        self.generateSeparator2.config(orient = TK.HORIZONTAL)
        self.generateSeparator2.pack(fill = TK.X, pady = GUI.R('generateHorizontalSeparatorPadY'))

        #############################################################

        # (1) Przyciski #############################################

        self.generateButtonsFrame = TKttk.Frame(self.generateFrame)
        self.generateButtonsFrame.config(style = 'layoutFrame.TFrame')
        self.generateButtonsFrame.pack(fill = TK.X, padx = GUI.R('outsidelayoutFramesPadX'))

        # Przycisk "START"
        self.generateStartButton = TKttk.Button(self.generateButtonsFrame)
        self.generateStartButton.config(style = 'button1.TButton')
        self.generateStartButton.config(padding = GUI.R('generateStartButtonPadding'))
        self.generateStartButton.config(text = 'START')
        self.generateStartButton.config(command = self.generateStartButtonAction)
        self.generateStartButton.pack(side = TK.LEFT, fill = TK.X, expand = 1, pady = GUI.R('generateStartButtonPadY'))

        ##############################################################

        #######################################################################




        # TAB3 - Format #######################################################

        self.formatTab = TKttk.Frame(self.mainMenu)
        self.formatTab.config(style = "mainMenuTabFrame.TFrame")
        self.formatTabImg = PLimg.open(GUI.R('formatTabIcon'))
        self.formatTabImg = self.formatTabImg.resize((GUI.R('tabIconsSize'), GUI.R('tabIconsSize')), PLimg.ANTIALIAS)
        self.formatTabImg = PLitk.PhotoImage(self.formatTabImg)
        self.mainMenu.add(self.formatTab, image = self.formatTabImg, state = TK.NORMAL)


        # Nagłówek
        self.formatHeader = TKttk.Label(self.formatTab)
        self.formatHeader.config(style = 'tabHeader.TLabel')
        self.formatHeader.config(text = 'FORMAT DANYCH')
        self.formatHeader.pack(fill = GUI.R('headerFill'))


        # Zawartość
        self.formatFrame = TKttk.Frame(self.formatTab)
        self.formatFrame.config(style = 'contentTabFrame.TFrame')
        self.formatFrame.pack(fill = GUI.R('contentTabFrameFill'), expand = GUI.R('contentTabFrameExpand'), padx = GUI.R('tabFramePadding'), pady = GUI.R('tabFramePadding'))

        
        # (1) Ładowanie presetu #####################################

        self.loadingPresetFrame = TKttk.Frame(self.formatFrame)
        self.loadingPresetFrame.config(style = 'layoutFrame.TFrame')
        self.loadingPresetFrame.pack(fill = TK.X, side = TK.TOP, padx = GUI.R('outsidelayoutFramesPadX'))

        # "Wybierz preset do edycji lub wpisz nazwę nowego"
        self.loadingListLabel = TKttk.Label(self.loadingPresetFrame)
        self.loadingListLabel.config(style = 'label1.TLabel')
        self.loadingListLabel.config(text = 'Wybierz preset do edycji lub wpisz nazwę nowego')
        self.loadingListLabel.pack(side = TK.LEFT)

        # Rozwijana lista presetów
        self.loadingListVar = TK.StringVar()
        self.loadingList = TKttk.Combobox(self.loadingPresetFrame)
        self.loadingList.config(textvariable = self.loadingListVar)
        self.loadingList.config(style = 'combobox2.TCombobox')
        self.loadingList.option_add("*TCombobox*Listbox.background", GUI.R('combobox2ListBoxBackground'))
        self.loadingList.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox2ListBoxForeground'))
        self.loadingList.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox2ListBoxSelectBackground'))
        self.loadingList.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox2ListBoxSelectForeground'))
        self.loadingList.pack(side = TK.LEFT, padx = GUI.R('loadingListPadX'), fill = TK.X, expand = 1)
        self.loadingList['values'] = tuple(FMT.getList())

        # Przycisk "WCZYTAJ"
        self.loadingButton = TKttk.Button(self.loadingPresetFrame)
        self.loadingButton.config(style = 'button1.TButton')
        self.loadingButton.config(command = self.loadingButtonAction)
        self.loadingButton.config(width = GUI.R('loadingButtonWidth'))
        self.loadingButton.config(text = 'WCZYTAJ')
        self.loadingButton.pack(side = TK.RIGHT)

        #############################################################

        # (1) Separator 1 ###########################################

        self.formatSeparator1 = TKttk.Separator(self.formatFrame)
        self.formatSeparator1.config(style = 'separator1.TSeparator')
        self.formatSeparator1.config(orient = TK.HORIZONTAL)
        self.formatSeparator1.pack(fill = TK.X, pady = GUI.R('formatHorizontalSeparatorPadY'))

        #############################################################

        # (1) Edycja presetu ########################################

        self.editingPresetFrame = TKttk.Frame(self.formatFrame)
        self.editingPresetFrame.config(style = 'layoutFrame.TFrame')
        self.editingPresetFrame.pack(fill = TK.BOTH, expand = 1, padx = GUI.R('outsidelayoutFramesPadX'))
        
        # (2) Ustawienia ##################################

        self.editingPresetSettingsFrame = TKttk.Frame(self.editingPresetFrame)
        self.editingPresetSettingsFrame.config(style = 'layoutFrame.TFrame')
        self.editingPresetSettingsFrame.pack(fill = TK.BOTH, expand = 1)

        # (3) Inne ustawienia ###################

        self.editingPresetOSFrame = TKttk.Frame(self.editingPresetSettingsFrame)
        self.editingPresetOSFrame.config(style = 'layoutFrame.TFrame')
        self.editingPresetOSFrame.pack(fill = TK.BOTH, expand = 1, side = TK.LEFT)
        
        # (5) Typ osoby ###############

        self.EPOSTypeFrame = TKttk.Frame(self.editingPresetOSFrame)
        self.EPOSTypeFrame.config(style = 'layoutFrame.TFrame')
        self.EPOSTypeFrame.pack(fill = TK.X, expand = 1, pady = GUI.R('EPOSTypeFramePadY'))

        # "Typ osoby"
        self.EPOSTypeLabel = TKttk.Label(self.EPOSTypeFrame)
        self.EPOSTypeLabel.config(style = 'label1.TLabel')
        self.EPOSTypeLabel.config(width = GUI.R('EPOSLabelWidth'))
        self.EPOSTypeLabel.config(anchor = GUI.R('EPOSLabelAnchor'))
        self.EPOSTypeLabel.config(text = 'Typ osoby')
        self.EPOSTypeLabel.pack(side = TK.LEFT)

        # Radiobutton
        self.EPOSTypeVar = TK.BooleanVar(value = True)

        self.EPOSTypeStudentRadiobutton = TK.Radiobutton(self.EPOSTypeFrame)
        self.EPOSTypeStudentRadiobutton.config(background = GUI.R('radiobutton1Background'))
        self.EPOSTypeStudentRadiobutton.config(foreground = GUI.R('radiobutton1TextColor'))
        self.EPOSTypeStudentRadiobutton.config(selectcolor = GUI.R('radiobutton1IndicatorBackground'))
        self.EPOSTypeStudentRadiobutton.config(activebackground = GUI.R('radiobutton1Background'))
        self.EPOSTypeStudentRadiobutton.config(activeforeground = GUI.R('radiobutton1TextColor'))
        self.EPOSTypeStudentRadiobutton.config(variable = self.EPOSTypeVar)
        self.EPOSTypeStudentRadiobutton.config(value = True)
        self.EPOSTypeStudentRadiobutton.config(state = TK.DISABLED)
        self.EPOSTypeStudentRadiobutton.config(text = 'Uczniowie')
        self.EPOSTypeStudentRadiobutton.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        self.EPOSTypeTeacherRadiobutton = TK.Radiobutton(self.EPOSTypeFrame)
        self.EPOSTypeTeacherRadiobutton.config(background = GUI.R('radiobutton1Background'))
        self.EPOSTypeTeacherRadiobutton.config(foreground = GUI.R('radiobutton1TextColor'))
        self.EPOSTypeTeacherRadiobutton.config(selectcolor = GUI.R('radiobutton1IndicatorBackground'))
        self.EPOSTypeTeacherRadiobutton.config(activebackground = GUI.R('radiobutton1Background'))
        self.EPOSTypeTeacherRadiobutton.config(activeforeground = GUI.R('radiobutton1TextColor'))
        self.EPOSTypeTeacherRadiobutton.config(variable = self.EPOSTypeVar)
        self.EPOSTypeTeacherRadiobutton.config(value = False)
        self.EPOSTypeTeacherRadiobutton.config(state = TK.DISABLED)
        self.EPOSTypeTeacherRadiobutton.config(text = 'Nauczyciele')
        self.EPOSTypeTeacherRadiobutton.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        
        #####################

        # (5) Separator pomiedzy osobami

        self.EPOSPersonSeparatorFrame = TKttk.Frame(self.editingPresetOSFrame)
        self.EPOSPersonSeparatorFrame.config(style = 'layoutFrame.TFrame')
        self.EPOSPersonSeparatorFrame.pack(fill = TK.X, expand = 1, pady = GUI.R('EPOSPersonSeparatorFramePadY'))
        
        # "Separator pomiędzy osobami"
        self.EPOSPersonSeparatorLabel = TKttk.Label(self.EPOSPersonSeparatorFrame)
        self.EPOSPersonSeparatorLabel.config(style = 'label1.TLabel')
        self.EPOSPersonSeparatorLabel.config(width = GUI.R('EPOSLabelWidth'))
        self.EPOSPersonSeparatorLabel.config(anchor = GUI.R('EPOSLabelAnchor'))
        self.EPOSPersonSeparatorLabel.config(text = 'Separator pomiędzy osobami')
        self.EPOSPersonSeparatorLabel.pack(side = TK.LEFT)

        # Entry - Separator pomiedzy osobami
        self.EPOSPersonSeparatorVar = TK.StringVar()
        self.EPOSPersonSeparatorEntry = TKttk.Entry(self.EPOSPersonSeparatorFrame)
        self.EPOSPersonSeparatorEntry.config(style = 'entry1.TEntry')
        self.EPOSPersonSeparatorEntry.config(textvariable = self.EPOSPersonSeparatorVar)
        self.EPOSPersonSeparatorEntry.config(state = TK.DISABLED)
        self.EPOSPersonSeparatorEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        #####################

        # (5) Separator pomiedzy wierszami

        self.EPOSRowSeparatorFrame = TKttk.Frame(self.editingPresetOSFrame)
        self.EPOSRowSeparatorFrame.config(style = 'layoutFrame.TFrame')
        self.EPOSRowSeparatorFrame.pack(fill = TK.X, expand = 1, pady = GUI.R('EPOSRowSeparatorFramePadY'))

        # "Separator pomiędzy wierszami"
        self.EPOSRowSeparatorLabel = TKttk.Label(self.EPOSRowSeparatorFrame)
        self.EPOSRowSeparatorLabel.config(style = 'label1.TLabel')
        self.EPOSRowSeparatorLabel.config(width = GUI.R('EPOSLabelWidth'))
        self.EPOSRowSeparatorLabel.config(anchor = GUI.R('EPOSLabelAnchor'))
        self.EPOSRowSeparatorLabel.config(text = 'Separator pomiędzy wierszami')
        self.EPOSRowSeparatorLabel.pack(side = TK.LEFT)

        # Entry - Separator pomiedzy wierszami
        self.EPOSRowSeparatorVar = TK.StringVar()
        self.EPOSRowSeparatorEntry = TKttk.Entry(self.EPOSRowSeparatorFrame)
        self.EPOSRowSeparatorEntry.config(style = 'entry1.TEntry')
        self.EPOSRowSeparatorEntry.config(textvariable = self.EPOSRowSeparatorVar)
        self.EPOSRowSeparatorEntry.config(state = TK.DISABLED)
        self.EPOSRowSeparatorEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1)

        #####################

        # (5) Separatory pomiedzy danymi

        self.EPOSDataSeparatorFrame = TKttk.Frame(self.editingPresetOSFrame)
        self.EPOSDataSeparatorFrame.config(style = 'layoutFrame.TFrame')
        self.EPOSDataSeparatorFrame.pack(fill = TK.BOTH, expand = 1, pady = GUI.R('EPOSDataSeparatorFramePadY'))

        # "Separatory pomiędzy danymi"
        self.EPOSDataSeparatorLabel = TKttk.Label(self.EPOSDataSeparatorFrame)
        self.EPOSDataSeparatorLabel.config(style = 'label1.TLabel')
        self.EPOSDataSeparatorLabel.config(width = GUI.R('EPOSLabelWidth'))
        self.EPOSDataSeparatorLabel.config(anchor = GUI.R('EPOSLabelAnchor'))
        self.EPOSDataSeparatorLabel.config(text = 'Separatory pomiędzy danymi')
        self.EPOSDataSeparatorLabel.pack(side = TK.LEFT)

        # Entry - Separator pomiedzy wierszami
        self.EPOSDataSeparatorText = TK.Text(self.EPOSDataSeparatorFrame)
        self.EPOSDataSeparatorText.config(state = TK.DISABLED)
        self.EPOSDataSeparatorText.config(background = GUI.R('text1Background'))
        self.EPOSDataSeparatorText.config(foreground = GUI.R('text1TextColor'))
        self.EPOSDataSeparatorText.config(relief = GUI.R('text1Relief'))
        self.EPOSDataSeparatorText.pack(side = TK.TOP, fill = TK.BOTH)

        #####################
        
        ###############################

        # (5) Separator 2 #############

        self.formatSeparator2 = TKttk.Separator(self.editingPresetSettingsFrame)
        self.formatSeparator2.config(style = 'separator1.TSeparator')
        self.formatSeparator2.config(orient = TK.VERTICAL)
        self.formatSeparator2.pack(fill = TK.Y, padx = GUI.R('formatVerticalSeparatorPadY'), side = TK.LEFT)

        ###############################

        # (5) Lokalizacja danych ######

        self.editingPresetDLFrame = TKttk.Frame(self.editingPresetSettingsFrame)
        self.editingPresetDLFrame.config(style = 'layoutFrame.TFrame')
        self.editingPresetDLFrame.pack(fill = TK.BOTH, side = TK.RIGHT)
        self.editingPresetDLFrame.grid_columnconfigure(1, weight = 1)
        self.editingPresetDLFrame.grid_columnconfigure(2, weight = 1)
        
        # C1 - "Wiersz"
        self.EPDLC1Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLC1Label.config(style = 'label1.TLabel')
        self.EPDLC1Label.config(text = 'Wiersz')
        self.EPDLC1Label.grid(row = 0, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # C2 - "Pozycja w wierszu"
        self.EPDLC2Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLC2Label.config(style = 'label1.TLabel')
        self.EPDLC2Label.config(justify = TK.CENTER)
        self.EPDLC2Label.config(text = 'Pozycja\nw wierszu')
        self.EPDLC2Label.grid(row = 0, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # W1 - "Login"
        self.EPDLW1Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLW1Label.config(style = 'label1.TLabel')
        self.EPDLW1Label.config(text = 'Login')
        self.EPDLW1Label.grid(row = 1, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja loginu (wiersz)
        self.EPDLLoginRowVar = TK.IntVar()
        self.EPDLLoginRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLLoginRowSpinbox.config(textvariable = self.EPDLLoginRowVar)
        self.EPDLLoginRowSpinbox.config(from_ = 0)
        self.EPDLLoginRowSpinbox.config(to = 1000000)
        self.EPDLLoginRowSpinbox.config(state = TK.DISABLED)
        self.EPDLLoginRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLLoginRowSpinbox.grid(row = 1, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja loginu (pozycja w wierszu)
        self.EPDLLoginPosInRowVar = TK.IntVar()
        self.EPDLLoginPosInRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLLoginPosInRowSpinbox.config(textvariable = self.EPDLLoginPosInRowVar)
        self.EPDLLoginPosInRowSpinbox.config(from_ = 0)
        self.EPDLLoginPosInRowSpinbox.config(to = 1000000)
        self.EPDLLoginPosInRowSpinbox.config(state = TK.DISABLED)
        self.EPDLLoginPosInRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLLoginPosInRowSpinbox.grid(row = 1, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # W2 - "Imię"
        self.EPDLW2Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLW2Label.config(style = 'label1.TLabel')
        self.EPDLW2Label.config(text = 'Imię')
        self.EPDLW2Label.grid(row = 2, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja imienia (wiersz)
        self.EPDLFnameRowVar = TK.IntVar()
        self.EPDLFnameRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLFnameRowSpinbox.config(textvariable = self.EPDLFnameRowVar)
        self.EPDLFnameRowSpinbox.config(from_ = 0)
        self.EPDLFnameRowSpinbox.config(to = 1000000)
        self.EPDLFnameRowSpinbox.config(state = TK.DISABLED)
        self.EPDLFnameRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLFnameRowSpinbox.grid(row = 2, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja imienia (pozycja w wierszu)
        self.EPDLFnamePosInRowVar = TK.IntVar()
        self.EPDLFnamePosInRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLFnamePosInRowSpinbox.config(textvariable = self.EPDLFnamePosInRowVar)
        self.EPDLFnamePosInRowSpinbox.config(from_ = 0)
        self.EPDLFnamePosInRowSpinbox.config(to = 1000000)
        self.EPDLFnamePosInRowSpinbox.config(state = TK.DISABLED)
        self.EPDLFnamePosInRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLFnamePosInRowSpinbox.grid(row = 2, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # W3 - "Nazwisko"
        self.EPDLW3Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLW3Label.config(style = 'label1.TLabel')
        self.EPDLW3Label.config(text = 'Nazwisko')
        self.EPDLW3Label.grid(row = 3, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja nazwiska (wiersz)
        self.EPDLLnameRowVar = TK.IntVar()
        self.EPDLLnameRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLLnameRowSpinbox.config(textvariable = self.EPDLLnameRowVar)
        self.EPDLLnameRowSpinbox.config(from_ = 0)
        self.EPDLLnameRowSpinbox.config(to = 1000000)
        self.EPDLLnameRowSpinbox.config(state = TK.DISABLED)
        self.EPDLLnameRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLLnameRowSpinbox.grid(row = 3, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja nazwiska (pozycja w wierszu)
        self.EPDLLnamePosInRowVar = TK.IntVar()
        self.EPDLLnamePosInRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLLnamePosInRowSpinbox.config(textvariable = self.EPDLLnamePosInRowVar)
        self.EPDLLnamePosInRowSpinbox.config(from_ = 0)
        self.EPDLLnamePosInRowSpinbox.config(to = 1000000)
        self.EPDLLnamePosInRowSpinbox.config(state = TK.DISABLED)
        self.EPDLLnamePosInRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLLnamePosInRowSpinbox.grid(row = 3, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # W4 - "Szkoła"
        self.EPDLW4Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLW4Label.config(style = 'label1.TLabel')
        self.EPDLW4Label.config(text = 'Szkoła')
        self.EPDLW4Label.grid(row = 4, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja nazwiska (wiersz)
        self.EPDLSchoolRowVar = TK.IntVar()
        self.EPDLSchoolRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLSchoolRowSpinbox.config(textvariable = self.EPDLSchoolRowVar)
        self.EPDLSchoolRowSpinbox.config(from_ = 0)
        self.EPDLSchoolRowSpinbox.config(to = 1000000)
        self.EPDLSchoolRowSpinbox.config(state = TK.DISABLED)
        self.EPDLSchoolRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLSchoolRowSpinbox.grid(row = 4, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja nazwiska (pozycja w wierszu)
        self.EPDLSchoolPosInRowVar = TK.IntVar()
        self.EPDLSchoolPosInRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLSchoolPosInRowSpinbox.config(textvariable = self.EPDLSchoolPosInRowVar)
        self.EPDLSchoolPosInRowSpinbox.config(from_ = 0)
        self.EPDLSchoolPosInRowSpinbox.config(to = 1000000)
        self.EPDLSchoolPosInRowSpinbox.config(state = TK.DISABLED)
        self.EPDLSchoolPosInRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLSchoolPosInRowSpinbox.grid(row = 4, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # W5 - "Klasa"
        self.EPDLW5Label = TKttk.Label(self.editingPresetDLFrame)
        self.EPDLW5Label.config(style = 'label1.TLabel')
        self.EPDLW5Label.config(text = 'Klasa')
        self.EPDLW5Label.grid(row = 5, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        
        # Lokalizacja nazwiska (wiersz)
        self.EPDLClassRowVar = TK.IntVar()
        self.EPDLClassRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLClassRowSpinbox.config(textvariable = self.EPDLClassRowVar)
        self.EPDLClassRowSpinbox.config(from_ = 0)
        self.EPDLClassRowSpinbox.config(to = 1000000)
        self.EPDLClassRowSpinbox.config(state = TK.DISABLED)
        self.EPDLClassRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLClassRowSpinbox.grid(row = 5, column = 1, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))

        # Lokalizacja nazwiska (pozycja w wierszu)
        self.EPDLClassPosInRowVar = TK.IntVar()
        self.EPDLClassPosInRowSpinbox = TKttk.Spinbox(self.editingPresetDLFrame)
        self.EPDLClassPosInRowSpinbox.config(textvariable = self.EPDLClassPosInRowVar)
        self.EPDLClassPosInRowSpinbox.config(from_ = 0)
        self.EPDLClassPosInRowSpinbox.config(to = 1000000)
        self.EPDLClassPosInRowSpinbox.config(state = TK.DISABLED)
        self.EPDLClassPosInRowSpinbox.config(style = 'spinbox1.TSpinbox')
        self.EPDLClassPosInRowSpinbox.grid(row = 5, column = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))

        # Separator
        self.formatSeparator4Frame = TKttk.Frame(self.editingPresetDLFrame)
        self.formatSeparator4Frame.config(style = 'layoutFrame.TFrame')
        self.formatSeparator4Frame.grid(row = 6, column = 0, columnspan = 3)

        self.formatSeparator4 = TKttk.Separator(self.formatSeparator4Frame)
        self.formatSeparator4.config(style = 'separator1.TSeparator')
        self.formatSeparator4.config(orient = TK.HORIZONTAL)
        self.formatSeparator4.pack(padx = GUI.R('formatHorizontalSeparatorPadY'), pady = 10, fill = TK.X, expand = 1)

        # "Kodowanie"
        self.formatInputCodingLabel = TKttk.Label(self.editingPresetDLFrame)
        self.formatInputCodingLabel.config(style = 'label1.TLabel')
        self.formatInputCodingLabel.config(text = 'Kodowanie')
        self.formatInputCodingLabel.grid(row = 7, column = 0, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))

        # Kodowanie - Combobox
        self.formatInputCodingVar = TK.StringVar()
        self.formatInputCodingCombobox = TKttk.Combobox(self.editingPresetDLFrame)
        self.formatInputCodingCombobox.config(textvariable = self.formatInputCodingVar)
        self.formatInputCodingCombobox.config(state = TK.DISABLED)
        self.formatInputCodingCombobox.config(style = 'combobox2.TCombobox')
        self.formatInputCodingCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox2ListBoxBackground'))
        self.formatInputCodingCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox2ListBoxForeground'))
        self.formatInputCodingCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox2ListBoxSelectBackground'))
        self.formatInputCodingCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox2ListBoxSelectForeground'))
        self.formatInputCodingCombobox.grid(row = 7, column = 1, columnspan = 2, padx = GUI.R('EPDataLocalizationPadX'), pady = GUI.R('EPDataLocalizationPadY'))
        self.formatInputCodingCombobox['values'] = tuple(VAR.allowedCoding)

        ###############################

        #########################################

        ###################################################
        
        # (1) Separator 3 ###########################################

        self.formatSeparator3 = TKttk.Separator(self.formatFrame)
        self.formatSeparator3.config(style = 'separator1.TSeparator')
        self.formatSeparator3.config(orient = TK.HORIZONTAL)
        self.formatSeparator3.pack(fill = TK.X, pady = GUI.R('formatHorizontalSeparatorPadY'))

        #############################################################

        # (1) Przyciski #############################################

        self.editingPresetButtonsFrame = TKttk.Frame(self.formatFrame)
        self.editingPresetButtonsFrame.config(style = 'layoutFrame.TFrame')
        self.editingPresetButtonsFrame.pack(fill = TK.X, side = TK.BOTTOM, pady = GUI.R('editingPresetButtonsPadY'))

        # Przycisk 'ZAPISZ'
        self.editingPresetSaveButton = TKttk.Button(self.editingPresetButtonsFrame)
        self.editingPresetSaveButton.config(command = self.editingPresetSaveButtonAction)
        self.editingPresetSaveButton.config(state = TK.DISABLED)
        self.editingPresetSaveButton.config(style = 'button1.TButton')
        self.editingPresetSaveButton.config(width = GUI.R('editingPresetSaveButtonWidth'))
        self.editingPresetSaveButton.config(text = 'ZAPISZ')
        self.editingPresetSaveButton.pack(side = TK.LEFT, expand = 1)

        # Przycisk 'Anuluj'
        self.editingPresetCancelButton = TKttk.Button(self.editingPresetButtonsFrame)
        self.editingPresetCancelButton.config(command = self.editingPresetCancelButtonAction)
        self.editingPresetCancelButton.config(state = TK.DISABLED)
        self.editingPresetCancelButton.config(style = 'button1.TButton')
        self.editingPresetCancelButton.config(width = GUI.R('editingPresetCancelButtonWidth'))
        self.editingPresetCancelButton.config(text = 'Anuluj')
        self.editingPresetCancelButton.pack(side = TK.RIGHT, expand = 1)

        #############################################################

        ######################################################################




        # TAB3 - Ustawienia ##################################################

        self.settingsTab = TKttk.Frame(self.mainMenu)
        self.settingsTab.config(style = "mainMenuTabFrame.TFrame")
        self.settingsTabImg = PLimg.open(GUI.R('settingsTabIcon'))
        self.settingsTabImg = self.settingsTabImg.resize((GUI.R('tabIconsSize'), GUI.R('tabIconsSize')), PLimg.ANTIALIAS)
        self.settingsTabImg = PLitk.PhotoImage(self.settingsTabImg)
        self.mainMenu.add(self.settingsTab, image = self.settingsTabImg, state = TK.NORMAL)


        # Nagłówek
        self.settingsHeader = TKttk.Label(self.settingsTab)
        self.settingsHeader.config(style = 'tabHeader.TLabel')
        self.settingsHeader.config(text = 'USTAWIENIA')
        self.settingsHeader.pack(fill = GUI.R('headerFill'))


        # Zawartość
        self.settingsFrame = TKttk.Frame(self.settingsTab)
        self.settingsFrame.config(style = 'contentTabFrame.TFrame')
        self.settingsFrame.pack(fill = GUI.R('contentTabFrameFill'), expand = GUI.R('contentTabFrameExpand'), padx = GUI.R('tabFramePadding'), pady = GUI.R('tabFramePadding'))

        # (1) Ustwienia #############################################

        self.settingsMainFrame = TKttk.Frame(self.settingsFrame)
        self.settingsMainFrame.config(style = 'layoutFrame.TFrame')
        self.settingsMainFrame.pack(side = TK.TOP, fill = TK.BOTH, expand = 1)

        # (2) Po lewo #####################################

        self.settingsLeftFrame = TKttk.Frame(self.settingsMainFrame)
        self.settingsLeftFrame.config(style = 'layoutFrame.TFrame')
        self.settingsLeftFrame.pack(side = TK.LEFT, fill = TK.BOTH, expand = 1)

        # (3) Kodowanie #########################

        self.settingsCodeFrame = TKttk.Frame(self.settingsLeftFrame)
        self.settingsCodeFrame.config(style = 'layoutFrame.TFrame')
        self.settingsCodeFrame.pack(side = TK.TOP, fill = TK.X)

        # (4) Kodowanie dla pliku poczty

        self.settingsMailCodeFrame = TKttk.Frame(self.settingsCodeFrame)
        self.settingsMailCodeFrame.config(style = 'layoutFrame.TFrame')
        self.settingsMailCodeFrame.pack(side = TK.TOP, fill = TK.X, pady = 6, expand = 1)

        # 'Kodowanie wyjściowe dla pliku poczty'
        self.settingsMailCodeLabel = TKttk.Label(self.settingsMailCodeFrame)
        self.settingsMailCodeLabel.config(style = 'label1.TLabel')
        self.settingsMailCodeLabel.config(width = GUI.R('settingsCodeLabelWidth'))
        self.settingsMailCodeLabel.config(anchor = GUI.R('settingsCodeLabelAnchor'))
        self.settingsMailCodeLabel.config(text = 'Kodowanie wyjściowe dla pliku poczty')
        self.settingsMailCodeLabel.pack(side = TK.LEFT)

        # Kodowanie dla poczty - Combobox
        self.settingsMailCodeVar = TK.StringVar()
        self.settingsMailCodeCombobox = TKttk.Combobox(self.settingsMailCodeFrame)
        self.settingsMailCodeCombobox.config(textvariable = self.settingsMailCodeVar)
        self.settingsMailCodeCombobox.config(style = 'combobox2.TCombobox')
        self.settingsMailCodeCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox2ListBoxBackground'))
        self.settingsMailCodeCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox2ListBoxForeground'))
        self.settingsMailCodeCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox2ListBoxSelectBackground'))
        self.settingsMailCodeCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox2ListBoxSelectForeground'))
        self.settingsMailCodeCombobox.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        self.settingsMailCodeCombobox['values'] = tuple(VAR.allowedCoding)
        self.settingsMailCodeCombobox.set(CFG.R('mailOutputCoding'))

        ###############################

        # (4) Kodowanie dla pliku office

        self.settingsOfficeCodeFrame = TKttk.Frame(self.settingsCodeFrame)
        self.settingsOfficeCodeFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOfficeCodeFrame.pack(side = TK.BOTTOM, fill = TK.X, pady = 6, expand = 1)

        # 'Kodowanie wyjściowe dla pliku office'
        self.settingsOfficeCodeLabel = TKttk.Label(self.settingsOfficeCodeFrame)
        self.settingsOfficeCodeLabel.config(style = 'label1.TLabel')
        self.settingsOfficeCodeLabel.config(width = GUI.R('settingsCodeLabelWidth'))
        self.settingsOfficeCodeLabel.config(anchor = GUI.R('settingsCodeLabelAnchor'))
        self.settingsOfficeCodeLabel.config(text = 'Kodowanie wyjściowe dla pliku office')
        self.settingsOfficeCodeLabel.pack(side = TK.LEFT)

        # Kodowanie dla poczty - Combobox
        self.settingsOfficeCodeVar = TK.StringVar()
        self.settingsOfficeCodeCombobox = TKttk.Combobox(self.settingsOfficeCodeFrame)
        self.settingsOfficeCodeCombobox.config(textvariable = self.settingsOfficeCodeVar)
        self.settingsOfficeCodeCombobox.config(style = 'combobox2.TCombobox')
        self.settingsOfficeCodeCombobox.option_add("*TCombobox*Listbox.background", GUI.R('combobox2ListBoxBackground'))
        self.settingsOfficeCodeCombobox.option_add("*TCombobox*Listbox.foreground", GUI.R('combobox2ListBoxForeground'))
        self.settingsOfficeCodeCombobox.option_add("*TCombobox*Listbox.selectBackground", GUI.R('combobox2ListBoxSelectBackground'))
        self.settingsOfficeCodeCombobox.option_add("*TCombobox*Listbox.selectForeground", GUI.R('combobox2ListBoxSelectForeground'))
        self.settingsOfficeCodeCombobox.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        self.settingsOfficeCodeCombobox['values'] = tuple(VAR.allowedCoding)
        self.settingsOfficeCodeCombobox.set(CFG.R('officeOutputCoding'))

        ###############################

        #########################################

        # (3) Separator #########################

        self.settingsSeparator3 = TKttk.Separator(self.settingsLeftFrame)
        self.settingsSeparator3.config(style = 'separator1.TSeparator')
        self.settingsSeparator3.config(orient = TK.HORIZONTAL)
        self.settingsSeparator3.pack(fill = TK.X, pady = GUI.R('settingsHorizontalSeparatorPadY'))

        #########################################

        # (3) Inne dane #########################

        self.settingsOtherFrame = TKttk.Frame(self.settingsLeftFrame)
        self.settingsOtherFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOtherFrame.pack(fill = TK.X)

        # (4) Domena ##################

        self.settingsOtherDomainFrame = TKttk.Frame(self.settingsOtherFrame)
        self.settingsOtherDomainFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOtherDomainFrame.pack(fill = TK.X, pady = 6, expand = 1)

        # 'Domena (używana w mailu)'
        self.settingsOtherDomainLabel = TKttk.Label(self.settingsOtherDomainFrame)
        self.settingsOtherDomainLabel.config(style = 'label1.TLabel')
        self.settingsOtherDomainLabel.config(width = GUI.R('settingsOtherLabelWidth'))
        self.settingsOtherDomainLabel.config(anchor = GUI.R('settingsOtherLabelAnchor'))
        self.settingsOtherDomainLabel.config(text = 'Domena (używana w mailu)')
        self.settingsOtherDomainLabel.pack(side = TK.LEFT)

        # Domena - Entry
        self.settingsOtherDomainVar = TK.StringVar()
        self.settingsOtherDomainEntry = TKttk.Entry(self.settingsOtherDomainFrame)
        self.settingsOtherDomainEntry.config(style = 'entry1.TEntry')
        self.settingsOtherDomainEntry.config(textvariable = self.settingsOtherDomainVar)
        self.settingsOtherDomainEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        self.settingsOtherDomainVar.set(CFG.R('domain'))

        ###############################

        # (4) Quota ###################

        self.settingsOtherQuotaFrame = TKttk.Frame(self.settingsOtherFrame)
        self.settingsOtherQuotaFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOtherQuotaFrame.pack(fill = TK.X, pady = 6, expand = 1)

        # 'Quota (MB)'
        self.settingsOtherQuotaLabel = TKttk.Label(self.settingsOtherQuotaFrame)
        self.settingsOtherQuotaLabel.config(style = 'label1.TLabel')
        self.settingsOtherQuotaLabel.config(width = GUI.R('settingsOtherLabelWidth'))
        self.settingsOtherQuotaLabel.config(anchor = GUI.R('settingsOtherLabelAnchor'))
        self.settingsOtherQuotaLabel.config(text = 'Quota (MB)')
        self.settingsOtherQuotaLabel.pack(side = TK.LEFT)

        # Domena - Entry
        self.settingsOtherQuotaVar = TK.IntVar()
        self.settingsOtherQuotaSpinbox = TKttk.Spinbox(self.settingsOtherQuotaFrame)
        self.settingsOtherQuotaSpinbox.config(textvariable = self.settingsOtherQuotaVar)
        self.settingsOtherQuotaSpinbox.config(from_ = 0)
        self.settingsOtherQuotaSpinbox.config(to = 10000000000000000000000)
        self.settingsOtherQuotaSpinbox.config(style = 'spinbox1.TSpinbox')
        self.settingsOtherQuotaSpinbox.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        self.settingsOtherQuotaSpinbox.set(CFG.R('quota'))

        ###############################

        # (4) Kraj ##################

        self.settingsOtherCountryFrame = TKttk.Frame(self.settingsOtherFrame)
        self.settingsOtherCountryFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOtherCountryFrame.pack(fill = TK.X, pady = 6, expand = 1)

        # 'Kraj (zapisany w danych na office)'
        self.settingsOtherCountryLabel = TKttk.Label(self.settingsOtherCountryFrame)
        self.settingsOtherCountryLabel.config(style = 'label1.TLabel')
        self.settingsOtherCountryLabel.config(width = GUI.R('settingsOtherLabelWidth'))
        self.settingsOtherCountryLabel.config(anchor = GUI.R('settingsOtherLabelAnchor'))
        self.settingsOtherCountryLabel.config(text = 'Kraj (zapisany w danych na office)')
        self.settingsOtherCountryLabel.pack(side = TK.LEFT)

        # Domena - Entry
        self.settingsOtherCountryVar = TK.StringVar()
        self.settingsOtherCountryEntry = TKttk.Entry(self.settingsOtherCountryFrame)
        self.settingsOtherCountryEntry.config(style = 'entry1.TEntry')
        self.settingsOtherCountryEntry.config(textvariable = self.settingsOtherCountryVar)
        self.settingsOtherCountryEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1)
        self.settingsOtherCountryVar.set(CFG.R('country'))

        ###############################

        # (4) Rozpoczęcie roku szkolnego

        self.settingsOtherDRRSFrame = TKttk.Frame(self.settingsOtherFrame)
        self.settingsOtherDRRSFrame.config(style = 'layoutFrame.TFrame')
        self.settingsOtherDRRSFrame.pack(fill = TK.X, expand = 1, pady = 6)

        # 'Rozpoczęcie roku szkolnego (Dzień | Miesiąc)'
        self.settingsOtherDRRSLabel = TKttk.Label(self.settingsOtherDRRSFrame)
        self.settingsOtherDRRSLabel.config(style = 'label1.TLabel')
        self.settingsOtherDRRSLabel.config(width = GUI.R('settingsOtherLabelWidth'))
        self.settingsOtherDRRSLabel.config(anchor = GUI.R('settingsOtherLabelAnchor'))
        self.settingsOtherDRRSLabel.config(text = 'Rozpoczęcie roku szkolnego (DD | MM)')
        self.settingsOtherDRRSLabel.pack(side = TK.LEFT)

        # Rozpoczęcie roku szkolnego - Miesiąc
        self.settingsOtherDRRSMonthVar = TK.IntVar()
        self.settingsOtherDRRSMonthSpinbox = TKttk.Spinbox(self.settingsOtherDRRSFrame)
        self.settingsOtherDRRSMonthSpinbox.config(textvariable = self.settingsOtherDRRSMonthVar)
        self.settingsOtherDRRSMonthSpinbox.config(from_ = 1)
        self.settingsOtherDRRSMonthSpinbox.config(to = 12)
        self.settingsOtherDRRSMonthSpinbox.config(style = 'spinbox1.TSpinbox')
        self.settingsOtherDRRSMonthSpinbox.pack(side = TK.RIGHT, fill = TK.X, expand = 1, padx = (6, 0))
        self.settingsOtherDRRSMonthSpinbox.set(CFG.R('schoolyearStart')['M'])

        # Rozpoczęcie roku szkolnego - Dzień
        self.settingsOtherDRRSDayVar = TK.IntVar()
        self.settingsOtherDRRSDaySpinbox = TKttk.Spinbox(self.settingsOtherDRRSFrame)
        self.settingsOtherDRRSDaySpinbox.config(textvariable = self.settingsOtherDRRSDayVar)
        self.settingsOtherDRRSDaySpinbox.config(from_ = 1)
        self.settingsOtherDRRSDaySpinbox.config(to = 31)
        self.settingsOtherDRRSDaySpinbox.config(style = 'spinbox1.TSpinbox')
        self.settingsOtherDRRSDaySpinbox.pack(side = TK.RIGHT, fill = TK.X, expand = 1, padx = (0, 6))
        self.settingsOtherDRRSDaySpinbox.set(CFG.R('schoolyearStart')['D'])

        ###############################

        #########################################

        # (3) Separator #########################

        self.settingsSeparator4 = TKttk.Separator(self.settingsLeftFrame)
        self.settingsSeparator4.config(style = 'separator1.TSeparator')
        self.settingsSeparator4.config(orient = TK.HORIZONTAL)
        self.settingsSeparator4.pack(fill = TK.X, pady = GUI.R('settingsHorizontalSeparatorPadY'))

        #########################################

        # (4) Nagłówki ##########################

        self.settingsHeadlinesFrame = TKttk.Frame(self.settingsLeftFrame)
        self.settingsHeadlinesFrame.config(style = 'layoutFrame.TFrame')
        self.settingsHeadlinesFrame.pack(fill = TK.X)

        # (4) Nagłówek poczty #########

        self.settingsHeadlinesMailFrame = TKttk.Frame(self.settingsHeadlinesFrame)
        self.settingsHeadlinesMailFrame.config(style = 'layoutFrame.TFrame')
        self.settingsHeadlinesMailFrame.pack(fill = TK.X, expand = 1, pady = 6)

        # 'Nagłówek dla pliku wyjściowego poczty'
        self.settingsHeadlinesMailLabel = TKttk.Label(self.settingsHeadlinesMailFrame)
        self.settingsHeadlinesMailLabel.config(style = 'label1.TLabel')
        self.settingsHeadlinesMailLabel.config(width = GUI.R('settingsHeadlineLabelWidth'))
        self.settingsHeadlinesMailLabel.config(anchor = GUI.R('settingsHeadlineLabelAnchor'))
        self.settingsHeadlinesMailLabel.config(text = 'Nagłówek dla pliku wyjściowego poczty')
        self.settingsHeadlinesMailLabel.pack(side = TK.LEFT)

        # Nagłówek poczty - checkbutton
        self.settingsHeadlinesMailCheckbuttonVar = TK.BooleanVar()
        self.settingsHeadlinesMailCheckbutton = TK.Checkbutton(self.settingsHeadlinesMailFrame)
        self.settingsHeadlinesMailCheckbutton.config(bg = GUI.R('checkbutton1Background'))
        self.settingsHeadlinesMailCheckbutton.config(fg = GUI.R('checkbutton1TextColor'))
        self.settingsHeadlinesMailCheckbutton.config(selectcolor = GUI.R('checkbutton1IndicatorBackground'))
        self.settingsHeadlinesMailCheckbutton.config(activebackground = GUI.R('checkbutton1Background'))
        self.settingsHeadlinesMailCheckbutton.config(activeforeground = GUI.R('checkbutton1TextColor'))
        self.settingsHeadlinesMailCheckbutton.config(text = 'Umieść w pliku')
        self.settingsHeadlinesMailCheckbutton.config(variable = self.settingsHeadlinesMailCheckbuttonVar)
        self.settingsHeadlinesMailCheckbutton.pack(side = TK.RIGHT, padx = (6, 0))
        self.settingsHeadlinesMailCheckbuttonVar.set(CFG.R('ifHeadlineInMail'))

        # Nagłówek poczty - Entry
        self.settingsHeadlinesMailEntryVar = TK.StringVar()
        self.settingsHeadlinesMailEntry = TKttk.Entry(self.settingsHeadlinesMailFrame)
        self.settingsHeadlinesMailEntry.config(style = 'entry1.TEntry')
        self.settingsHeadlinesMailEntry.config(textvariable = self.settingsHeadlinesMailEntryVar)
        self.settingsHeadlinesMailEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1, padx = (0, 6))
        self.settingsHeadlinesMailEntryVar.set(CFG.R('headlineInMail'))

        ###############################

        # (4) Nagłówek office #########

        self.settingsHeadlinesOfficeFrame = TKttk.Frame(self.settingsHeadlinesFrame)
        self.settingsHeadlinesOfficeFrame.config(style = 'layoutFrame.TFrame')
        self.settingsHeadlinesOfficeFrame.pack(fill = TK.X, expand = 1, pady = 6)

        # 'Nagłówek dla pliku wyjściowego poczty'
        self.settingsHeadlinesOfficeLabel = TKttk.Label(self.settingsHeadlinesOfficeFrame)
        self.settingsHeadlinesOfficeLabel.config(style = 'label1.TLabel')
        self.settingsHeadlinesOfficeLabel.config(width = GUI.R('settingsHeadlineLabelWidth'))
        self.settingsHeadlinesOfficeLabel.config(anchor = GUI.R('settingsHeadlineLabelAnchor'))
        self.settingsHeadlinesOfficeLabel.config(text = 'Nagłówek dla pliku wyjściowego office')
        self.settingsHeadlinesOfficeLabel.pack(side = TK.LEFT)

        # Nagłówek poczty - checkbutton
        self.settingsHeadlinesOfficeCheckbuttonVar = TK.BooleanVar()
        self.settingsHeadlinesOfficeCheckbutton = TK.Checkbutton(self.settingsHeadlinesOfficeFrame)
        self.settingsHeadlinesOfficeCheckbutton.config(bg = GUI.R('checkbutton1Background'))
        self.settingsHeadlinesOfficeCheckbutton.config(fg = GUI.R('checkbutton1TextColor'))
        self.settingsHeadlinesOfficeCheckbutton.config(selectcolor = GUI.R('checkbutton1IndicatorBackground'))
        self.settingsHeadlinesOfficeCheckbutton.config(activebackground = GUI.R('checkbutton1Background'))
        self.settingsHeadlinesOfficeCheckbutton.config(activeforeground = GUI.R('checkbutton1TextColor'))
        self.settingsHeadlinesOfficeCheckbutton.config(text = 'Umieść w pliku')
        self.settingsHeadlinesOfficeCheckbutton.config(variable = self.settingsHeadlinesOfficeCheckbuttonVar)
        self.settingsHeadlinesOfficeCheckbutton.pack(side = TK.RIGHT, padx = (6, 0))
        self.settingsHeadlinesOfficeCheckbuttonVar.set(CFG.R('ifHeadlineInOffice'))

        # Nagłówek poczty - Entry
        self.settingsHeadlinesOfficeEntryVar = TK.StringVar()
        self.settingsHeadlinesOfficeEntry = TKttk.Entry(self.settingsHeadlinesOfficeFrame)
        self.settingsHeadlinesOfficeEntry.config(style = 'entry1.TEntry')
        self.settingsHeadlinesOfficeEntry.config(textvariable = self.settingsHeadlinesOfficeEntryVar)
        self.settingsHeadlinesOfficeEntry.pack(side = TK.RIGHT, fill = TK.X, expand = 1, padx = (0, 6))
        self.settingsHeadlinesOfficeEntryVar.set(CFG.R('headlineInOffice'))

        ###############################

        #########################################

        ###################################################

        # (2) Separator ###################################

        self.settingsSeparator2 = TKttk.Separator(self.settingsMainFrame)
        self.settingsSeparator2.config(style = 'separator1.TSeparator')
        self.settingsSeparator2.config(orient = TK.VERTICAL)
        self.settingsSeparator2.pack(side = TK.LEFT, fill = TK.Y, padx = GUI.R('settingsVerticalSeparatorPadY'))

        ###################################################

        # (2) Dane o szkołach #############################

        self.settingsSchoolDataFrame = TKttk.Frame(self.settingsMainFrame)
        self.settingsSchoolDataFrame.config(style = 'layoutFrame.TFrame')
        self.settingsSchoolDataFrame.pack(side = TK.RIGHT, fill = TK.BOTH)

        # 'Dane o szkołach'
        self.settingsSchoolDataLabel = TKttk.Label(self.settingsSchoolDataFrame)
        self.settingsSchoolDataLabel.config(style = 'label1.TLabel')
        self.settingsSchoolDataLabel.config(anchor = GUI.R('settingsSchoolDataLabelAnchor'))
        self.settingsSchoolDataLabel.config(text = 'Dane o szkołach')
        self.settingsSchoolDataLabel.pack(side = TK.TOP, pady = 6)

        # Label - oznaczenia kolumn
        self.settingsSchoolDataInstructionLabel = TKttk.Label(self.settingsSchoolDataFrame)
        self.settingsSchoolDataInstructionLabel.config(style = 'label3.TLabel')
        self.settingsSchoolDataInstructionLabel.config(anchor = GUI.R('settingsSchoolDataLabelAnchor'))
        self.settingsSchoolDataInstructionLabel.config(text = 'OZNACZENIE SZKOŁY | ILOŚĆ KLAS | CZY OZNACZENIE SZKOŁY W ZNACZNIKU KLASY? (0/1)')
        self.settingsSchoolDataInstructionLabel.pack()

        # Dane o szkołach - Text
        self.settingsSchoolDataText = TK.Text(self.settingsSchoolDataFrame)
        self.settingsSchoolDataText.config(background = GUI.R('text1Background'))
        self.settingsSchoolDataText.config(foreground = GUI.R('text1TextColor'))
        self.settingsSchoolDataText.config(relief = GUI.R('text1Relief'))
        self.settingsSchoolDataText.config(width = 50)
        self.settingsSchoolDataText.pack(pady = 6, fill = TK.Y, expand = 1)
        for x in CFG.R('schoolData'):
            if x[2]:
                x[2] = '1'
            else:
                x[2] = '0'
            x[1] = str(x[1])
            self.settingsSchoolDataText.insert(TK.END, (' | '.join(x) + '\n'))

        ###################################################

        #############################################################
        
        # (1) Separator #############################################

        self.settingsSeparator1 = TKttk.Separator(self.settingsFrame)
        self.settingsSeparator1.config(style = 'separator1.TSeparator')
        self.settingsSeparator1.config(orient = TK.HORIZONTAL)
        self.settingsSeparator1.pack(fill = TK.X, pady = GUI.R('settingsHorizontalSeparatorPadY'))

        #############################################################

        # (1) Przyciski #############################################

        self.settingsButtonsFrame = TKttk.Frame(self.settingsFrame)
        self.settingsButtonsFrame.config(style = 'layoutFrame.TFrame')
        self.settingsButtonsFrame.pack(side = TK.BOTTOM, fill = TK.X, pady = GUI.R('settingsButtonsPadY'))

        # (2) Przyciski ZAPISZ i Anuluj ###################

        self.settingsButtonsSaveCancelFrame = TKttk.Frame(self.settingsButtonsFrame)
        self.settingsButtonsSaveCancelFrame.config(style = 'layoutFrame.TFrame')
        self.settingsButtonsSaveCancelFrame.pack(side = TK.LEFT)

        # Przycisk ZAPISZ
        self.settingsButtonSave = TKttk.Button(self.settingsButtonsSaveCancelFrame)
        self.settingsButtonSave.config(command = self.settingsButtonSaveAction)
        self.settingsButtonSave.config(style = 'button1.TButton')
        self.settingsButtonSave.config(width = GUI.R('settingsButtonSaveWidth'))
        self.settingsButtonSave.config(text = 'ZAPISZ')
        self.settingsButtonSave.pack(side = TK.LEFT, padx = 6)

        # Przycisk Anuluj
        self.settingsButtonCancel = TKttk.Button(self.settingsButtonsSaveCancelFrame)
        self.settingsButtonCancel.config(command = self.settingsButtonCancelAction)
        self.settingsButtonCancel.config(style = 'button1.TButton')
        self.settingsButtonCancel.config(width = GUI.R('settingsButtonCancelWidth'))
        self.settingsButtonCancel.config(text = 'Anuluj')
        self.settingsButtonCancel.pack(side = TK.RIGHT, padx = 6)

        ###################################################

        # (2) Inne przyciski ##############################

        self.settingsButtonsOtherFrame = TKttk.Frame(self.settingsButtonsFrame)
        self.settingsButtonsOtherFrame.config(style = 'layoutFrame.TFrame')
        self.settingsButtonsOtherFrame.pack(side = TK.RIGHT)

        # Przycisk "Zarządzaj presetami formatu"
        self.settingsButtonZPF = TKttk.Button(self.settingsButtonsOtherFrame)
        self.settingsButtonZPF.config(command = self.settingsButtonZPFAction)
        self.settingsButtonZPF.config(style = 'button1.TButton')
        self.settingsButtonZPF.config(width = GUI.R('settingsButtonZPFWidth'))
        self.settingsButtonZPF.config(text = 'Zarządzaj presetami formatu')
        self.settingsButtonZPF.pack(side = TK.RIGHT, padx = 6)

        # Przycisk "Przywróć domyślne ustawienia wyglądu"
        self.settingsButtonPDUW = TKttk.Button(self.settingsButtonsOtherFrame)
        self.settingsButtonPDUW.config(command = self.settingsButtonPDUWAction)
        self.settingsButtonPDUW.config(style = 'button1.TButton')
        self.settingsButtonPDUW.config(width = GUI.R('settingsButtonPDUWWidth'))
        self.settingsButtonPDUW.config(text = 'Przywróć domyślne ustawienia wyglądu')
        self.settingsButtonPDUW.pack(side = TK.RIGHT, padx = 6)

        # Przycisk "Przywróć domyślne ustwienia ogólne"
        self.settingsButtonPDUO = TKttk.Button(self.settingsButtonsOtherFrame)
        self.settingsButtonPDUO.config(command = self.settingsButtonPDUOAction)
        self.settingsButtonPDUO.config(style = 'button1.TButton')
        self.settingsButtonPDUO.config(width = GUI.R('settingsButtonPDUOWidth'))
        self.settingsButtonPDUO.config(text = 'Przywróć domyślne ustawienia ogólne')
        self.settingsButtonPDUO.pack(side = TK.RIGHT, padx = 6)

        ###################################################

        #############################################################

        ######################################################################




        # TAB4 - O programie #################################################
        
        self.aboutTab = TKttk.Frame(self.mainMenu)
        self.aboutTab.config(style = "mainMenuTabFrame.TFrame")
        self.aboutTabImg = PLimg.open(GUI.R('aboutTabIcon'))
        self.aboutTabImg = self.aboutTabImg.resize((GUI.R('tabIconsSize'), GUI.R('tabIconsSize')), PLimg.ANTIALIAS)
        self.aboutTabImg = PLitk.PhotoImage(self.aboutTabImg)
        self.mainMenu.add(self.aboutTab, image = self.aboutTabImg, state = TK.NORMAL)


        # Nagłówek
        self.aboutHeader = TKttk.Label(self.aboutTab)
        self.aboutHeader.config(style = 'tabHeader.TLabel')
        self.aboutHeader.config(text = 'O PROGRAMIE')
        self.aboutHeader.pack(fill = GUI.R('headerFill'))


        # Zawartość
        self.aboutFrame = TKttk.Frame(self.aboutTab)
        self.aboutFrame.config(style = 'contentTabFrame.TFrame')
        self.aboutFrame.pack(fill = GUI.R('contentTabFrameFill'), expand = GUI.R('contentTabFrameExpand'), padx = GUI.R('tabFramePadding'), pady = GUI.R('tabFramePadding'))

        # (1) Info & Logo ###########################################

        self.aboutInfoLogoFrame = TKttk.Frame(self.aboutFrame)
        self.aboutInfoLogoFrame.config(style = 'layoutFrame.TFrame')
        self.aboutInfoLogoFrame.pack(fill = TK.BOTH, expand = 1)

        # (2) Logo ########################################

        self.aboutLogoFrame = TKttk.Frame(self.aboutInfoLogoFrame)
        self.aboutLogoFrame.config(style = 'layoutFrame.TFrame')
        self.aboutLogoFrame.pack(fill = TK.BOTH, expand = 1)

        # Logo - Button
        self.aboutLogoButton = TKttk.Button(self.aboutLogoFrame)
        self.aboutLogoButton.config(style = 'button2.TButton')
        self.aboutLogoButtonImg = PLimg.open(GUI.R('aboutLogoButtonImg'))
        self.aboutLogoButtonImg = self.aboutLogoButtonImg.resize((GUI.R('aboutLogoButtonImgSize'), GUI.R('aboutLogoButtonImgSize')), PLimg.ANTIALIAS)
        self.aboutLogoButtonImg = PLitk.PhotoImage(self.aboutLogoButtonImg)
        self.aboutLogoButton.config(image = self.aboutLogoButtonImg)
        self.aboutLogoButton.pack(expand = 1)

        ###################################################

        # (2) Informacje ##################################

        self.aboutInfoFrame = TKttk.Frame(self.aboutInfoLogoFrame)
        self.aboutInfoFrame.config(style = 'layoutFrame.TFrame')
        self.aboutInfoFrame.pack(fill = TK.BOTH, expand = 1)

        # Nazwa programu
        self.aboutInfoProgramNameLabel = TKttk.Label(self.aboutInfoFrame)
        self.aboutInfoProgramNameLabel.config(style = 'label4.TLabel')
        self.aboutInfoProgramNameLabel.config(text = VAR.programName)
        self.aboutInfoProgramNameLabel.pack()

        # Wersja programu
        self.aboutInfoProgramNameLabel = TKttk.Label(self.aboutInfoFrame)
        self.aboutInfoProgramNameLabel.config(style = 'label1.TLabel')
        self.aboutInfoProgramNameLabel.config(text = 'Wersja %s %s (Build %s)' % (VAR.programVersion, VAR.programVersionStage, VAR.programVersionBuild))
        self.aboutInfoProgramNameLabel.pack()

        # (3) Pozostałe informacje ##############

        self.aboutOtherInfoFrame = TKttk.Frame(self.aboutInfoFrame)
        self.aboutOtherInfoFrame.config(style = 'layoutFrame.TFrame')
        self.aboutOtherInfoFrame.pack(pady = GUI.R('aboutOtherInfoFramePadX'))

        # Czas pracy
        self.aboutOIToWLabel = TKttk.Label(self.aboutOtherInfoFrame)
        self.aboutOIToWLabel.config(style = 'label2.TLabel')
        self.aboutOIToWLabel.config(text = '© %s %s - %s %s' % (VAR.programToW[0], VAR.programToW[1], VAR.programToW[2], VAR.programToW[3]))
        self.aboutOIToWLabel.pack()

        # Autorzy
        self.aboutOIAuthorsLabel = TKttk.Label(self.aboutOtherInfoFrame)
        self.aboutOIAuthorsLabel.config(style = 'label2.TLabel')
        self.aboutOIAuthorsLabel.config(text = '\n'.join(VAR.programAuthors))
        self.aboutOIAuthorsLabel.pack()

        # Dla kogo
        self.aboutOICustomerLabel = TKttk.Label(self.aboutOtherInfoFrame)
        self.aboutOICustomerLabel.config(style = 'label2.TLabel')
        self.aboutOICustomerLabel.config(text = 'dla %s' % VAR.programCustomer)
        self.aboutOICustomerLabel.pack()

        #########################################

        ###################################################

        #############################################################

        # (1) Instrukcja ############################################

        self.aboutInstructionFrame = TKttk.Frame(self.aboutFrame)
        self.aboutInstructionFrame.config(style = 'layoutFrame.TFrame')
        self.aboutInstructionFrame.pack(fill = TK.X, side = TK.BOTTOM)

        # Instrukcja - Button
        self.aboutInstructionButton = TKttk.Button(self.aboutInstructionFrame)
        self.aboutInstructionButton.config(command = self.aboutInstructionButtonAction)
        self.aboutInstructionButton.config(style = 'button1.TButton')
        self.aboutInstructionButton.config(width = GUI.R('aboutInstructionButtonWidth'))
        self.aboutInstructionButton.config(text = 'Więcej informacji')
        self.aboutInstructionButton.pack(side = TK.RIGHT)

        #############################################################

        ######################################################################
        


    # Akcje przycisków - TAB1

    def GIF1SLocalizationButtonAction(self):
        filename = str(TKfld.askopenfilename(initialdir = '/', title = "Wybierz plik z danymi"))
        self.GIF1SLocalizationEntryVar.set(filename)

    def GIF2SLocalizationButtonAction(self):
        filename = str(TKfld.askopenfilename(initialdir = '/', title = "Wybierz plik z danymi"))
        self.GIF2SLocalizationEntryVar.set(filename)
    
    def GIF3SLocalizationButtonAction(self):
        filename = str(TKfld.askopenfilename(initialdir = '/', title = "Wybierz plik z danymi"))
        self.GIF3SLocalizationEntryVar.set(filename)

    def GIF4SLocalizationButtonAction(self):
        filename = str(TKfld.askopenfilename(initialdir = '/', title = "Wybierz plik z danymi"))
        self.GIF4SLocalizationEntryVar.set(filename)

    def GOFMailButtonAction(self):
        filename = str(TKfld.asksaveasfilename(initialdir = '/', title = "Wybierz miejsce zapisu pliku csv dla poczty", filetypes = [('Plik CSV', '*.csv')]))
        if not filename:
            return
        if not filename.endswith('.csv'):
            filename += '.csv'
        self.GOFMailEntryVar.set(filename)

    def GOFOfficeButtonAction(self):
        filename = str(TKfld.asksaveasfilename(initialdir = '/', title = "Wybierz miejsce zapisu pliku csv dla Office", filetypes = [('Plik CSV', '*.csv')]))
        if not filename:
            return
        if not filename.endswith('.csv'):
            filename += '.csv'
        self.GOFOfficeEntryVar.set(filename)

    def generateStartButtonAction(self):
        if MSG('A0003', False):
            GIF1SFilename = self.GIF1SLocalizationEntryVar.get()
            GIF1SFormat = self.GIF1SFormatComboboxVar.get()
            GIF2SFilename = self.GIF2SLocalizationEntryVar.get()
            GIF2SFormat = self.GIF2SFormatComboboxVar.get()
            GIF3SFilename = self.GIF3SLocalizationEntryVar.get()
            GIF3SFormat = self.GIF3SFormatComboboxVar.get()
            GIF4SFilename = self.GIF4SLocalizationEntryVar.get()
            GIF4SFormat = self.GIF4SFormatComboboxVar.get()
            GOFMailFilename = self.GOFMailEntryVar.get()
            GOFOfficeFilename = self.GOFOfficeEntryVar.get()
            GIF1 = (GIF1SFilename, GIF1SFormat)
            GIF2 = (GIF2SFilename, GIF2SFormat)
            GIF3 = (GIF3SFilename, GIF3SFormat)
            GIF4 = (GIF4SFilename, GIF4SFormat)
            GOF = (GOFMailFilename, GOFOfficeFilename)
            filesList = (GIF1, GIF2, GIF3, GIF4, GOF)
            output = dataProcess.start(filesList)
            if not output[0]:
                MSG('E0007', False)
            else:
                if not output[1]:
                    MSG('E0008', False)
                else:
                    if not output[2]:
                        MSG('E0009', False)
                    else:
                        if not output[3]:
                            MSG('E0010', False)
                        else:
                            if not (output[4])[0]:
                                MSG('E0011', False, (output[4])[1])
                            else:
                                if not output[5]:
                                    MSG('E0012', False)
                                else:
                                    if not output[6]:
                                        MSG('E0013', False)
                                    else:
                                        if not (output[7])[0]:
                                            MSG('E0014', False)
                                        else:
                                            MSG('I0001', False, 'Przetworzono dane %i osób' % (output[7])[1])
                                            self.GIF1SLocalizationEntryVar.set('')
                                            self.GIF1SFormatComboboxVar.set('')
                                            self.GIF2SLocalizationEntryVar.set('')
                                            self.GIF2SFormatComboboxVar.set('')
                                            self.GIF3SLocalizationEntryVar.set('')
                                            self.GIF3SFormatComboboxVar.set('')
                                            self.GIF4SLocalizationEntryVar.set('')
                                            self.GIF4SFormatComboboxVar.set('')
                                            self.GOFMailEntryVar.set('')
                                            self.GOFOfficeEntryVar.set('')

        else:
            return
        
    # Akcje przycisków - TAB2

    def loadingButtonAction(self):
        self.loadingList['state'] = TK.DISABLED
        self.loadingButton['state'] = TK.DISABLED
        self.EPOSTypeVar.set(FMT.R(self.loadingList.get(), 'student'))
        self.EPOSTypeStudentRadiobutton['state'] = TK.NORMAL
        self.EPOSTypeTeacherRadiobutton['state'] = TK.NORMAL
        self.EPOSPersonSeparatorEntry['state'] = TK.NORMAL
        self.EPOSPersonSeparatorVar.set(FMT.R(self.loadingList.get(), 'personSeparator'))
        self.EPOSRowSeparatorEntry['state'] = TK.NORMAL
        self.EPOSRowSeparatorVar.set(FMT.R(self.loadingList.get(), 'rowSeparator'))
        self.EPOSDataSeparatorText['state'] = TK.NORMAL
        self.EPOSDataSeparatorText.insert(TK.END, '\n'.join(FMT.R(self.loadingList.get(), 'dataSeparators')))
        self.EPDLLoginRowSpinbox['state'] = TK.NORMAL
        self.EPDLLoginRowVar.set(FMT.R(self.loadingList.get(), 'loginRow'))
        self.EPDLLoginPosInRowSpinbox['state'] = TK.NORMAL
        self.EPDLLoginPosInRowVar.set(FMT.R(self.loadingList.get(), 'loginPositionInRow'))
        self.EPDLFnameRowSpinbox['state'] = TK.NORMAL
        self.EPDLFnameRowVar.set(FMT.R(self.loadingList.get(), 'fnameRow'))
        self.EPDLFnamePosInRowSpinbox['state'] = TK.NORMAL
        self.EPDLFnamePosInRowVar.set(FMT.R(self.loadingList.get(), 'fnamePositionInRow'))
        self.EPDLLnameRowSpinbox['state'] = TK.NORMAL
        self.EPDLLnameRowVar.set(FMT.R(self.loadingList.get(), 'lnameRow'))
        self.EPDLLnamePosInRowSpinbox['state'] = TK.NORMAL
        self.EPDLLnamePosInRowVar.set(FMT.R(self.loadingList.get(), 'lnamePositionInRow'))
        self.EPDLSchoolRowSpinbox['state'] = TK.NORMAL
        self.EPDLSchoolRowVar.set(FMT.R(self.loadingList.get(), 'schoolRow'))
        self.EPDLSchoolPosInRowSpinbox['state'] = TK.NORMAL
        self.EPDLSchoolPosInRowVar.set(FMT.R(self.loadingList.get(), 'schoolPositionInRow'))
        self.EPDLClassRowSpinbox['state'] = TK.NORMAL
        self.EPDLClassRowVar.set(FMT.R(self.loadingList.get(), 'classRow'))
        self.EPDLClassPosInRowSpinbox['state'] = TK.NORMAL
        self.EPDLClassPosInRowVar.set(FMT.R(self.loadingList.get(), 'classPositionInRow'))
        self.formatInputCodingCombobox['state'] = 'readonly'
        self.formatInputCodingVar.set(FMT.R(self.loadingList.get(), 'inputCoding'))
        self.editingPresetSaveButton['state'] = TK.NORMAL
        self.editingPresetCancelButton['state'] = TK.NORMAL

    def editingPresetClear(self):
        formatFileContent = {
            "student" : True,
            "personSeparator" : '',
            "rowSeparator" : '',
            "dataSeparators" : [],
            "loginRow" : 0,
            "loginPositionInRow" : 0,
            "fnameRow" : 0,
            "fnamePositionInRow" : 0,
            "lnameRow" : 0,
            "lnamePositionInRow" : 0,
            "schoolRow" : 0,
            "schoolPositionInRow" : 0,
            "classRow" : 0,
            "classPositionInRow" : 0,
            "inputCoding" : '',
        }
        self.loadingList['state'] = TK.NORMAL
        self.loadingButton['state'] = TK.NORMAL
        self.EPOSTypeVar.set(formatFileContent['student'])
        self.EPOSTypeStudentRadiobutton['state'] = TK.DISABLED
        self.EPOSTypeTeacherRadiobutton['state'] = TK.DISABLED
        self.EPOSPersonSeparatorEntry['state'] = TK.DISABLED
        self.EPOSPersonSeparatorVar.set(formatFileContent['personSeparator'])
        self.EPOSRowSeparatorEntry['state'] = TK.DISABLED
        self.EPOSRowSeparatorVar.set(formatFileContent['rowSeparator'])
        self.EPOSDataSeparatorText.delete('1.0', TK.END)
        self.EPOSDataSeparatorText['state'] = TK.DISABLED
        self.EPDLLoginRowSpinbox['state'] = TK.DISABLED
        self.EPDLLoginRowVar.set(formatFileContent['loginRow'])
        self.EPDLLoginPosInRowSpinbox['state'] = TK.DISABLED
        self.EPDLLoginPosInRowVar.set(formatFileContent['loginPositionInRow'])
        self.EPDLFnameRowSpinbox['state'] = TK.DISABLED
        self.EPDLFnameRowVar.set(formatFileContent['fnameRow'])
        self.EPDLFnamePosInRowSpinbox['state'] = TK.DISABLED
        self.EPDLFnamePosInRowVar.set(formatFileContent['fnamePositionInRow'])
        self.EPDLLnameRowSpinbox['state'] = TK.DISABLED
        self.EPDLLnameRowVar.set(formatFileContent['lnameRow'])
        self.EPDLLnamePosInRowSpinbox['state'] = TK.DISABLED
        self.EPDLLnamePosInRowVar.set(formatFileContent['lnamePositionInRow'])
        self.EPDLSchoolRowSpinbox['state'] = TK.DISABLED
        self.EPDLSchoolRowVar.set(formatFileContent['schoolRow'])
        self.EPDLSchoolPosInRowSpinbox['state'] = TK.DISABLED
        self.EPDLSchoolPosInRowVar.set(formatFileContent['schoolPositionInRow'])
        self.EPDLClassRowSpinbox['state'] = TK.DISABLED
        self.EPDLClassRowVar.set(formatFileContent['classRow'])
        self.EPDLClassPosInRowSpinbox['state'] = TK.DISABLED
        self.EPDLClassPosInRowVar.set(formatFileContent['classPositionInRow'])
        self.formatInputCodingCombobox['state'] = TK.DISABLED
        self.formatInputCodingVar.set(formatFileContent['inputCoding'])
        self.editingPresetSaveButton['state'] = TK.DISABLED
        self.editingPresetCancelButton['state'] = TK.DISABLED
        self.loadingList['values'] = tuple(FMT.getList())
    
    def updatePresetListInGenerateTab(self):
        self.GIF1SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF2SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF3SFormatCombobox['values'] = tuple(FMT.getList())
        self.GIF4SFormatCombobox['values'] = tuple(FMT.getList())

    def editingPresetSave(self):
        formatFileContentToSave = {
            "student" : self.EPOSTypeVar.get(),
            "personSeparator" : self.EPOSPersonSeparatorEntry.get(),
            "rowSeparator" : self.EPOSRowSeparatorEntry.get(),
            "dataSeparators" : (self.EPOSDataSeparatorText.get("1.0", TK.END)).split('\n')[:-1],
            "loginRow" : self.EPDLLoginRowSpinbox.get(),
            "loginPositionInRow" : self.EPDLLoginPosInRowSpinbox.get(),
            "fnameRow" : self.EPDLFnameRowSpinbox.get(),
            "fnamePositionInRow" : self.EPDLFnamePosInRowSpinbox.get(),
            "lnameRow" : self.EPDLLnameRowSpinbox.get(),
            "lnamePositionInRow" : self.EPDLLnamePosInRowSpinbox.get(),
            "schoolRow" : self.EPDLSchoolRowSpinbox.get(),
            "schoolPositionInRow" : self.EPDLSchoolPosInRowSpinbox.get(),
            "classRow" : self.EPDLClassRowSpinbox.get(),
            "classPositionInRow" : self.EPDLClassPosInRowSpinbox.get(),
            "inputCoding" : self.formatInputCodingCombobox.get()
        }
        if not FMT.W(self.loadingList.get(), formatFileContentToSave):
            return
        self.editingPresetClear()
        self.updatePresetListInGenerateTab()

    def editingPresetSaveButtonAction(self):
        if self.loadingList.get() not in FMT.getList():
            if MSG('A0001', False):
                self.editingPresetSave()
            else:
                return
        else:
            if MSG('A0002', False):
                self.editingPresetSave()
            else:
                return

    def editingPresetCancelButtonAction(self):
        self.editingPresetClear()
    
    # Akcje przycisków - TAB3

    def settingsReset(self):
        self.settingsMailCodeCombobox.set(CFG.R('mailOutputCoding'))
        self.settingsOfficeCodeCombobox.set(CFG.R('officeOutputCoding'))
        self.settingsOtherDomainVar.set(CFG.R('domain'))
        self.settingsOtherQuotaSpinbox.set(CFG.R('quota'))
        self.settingsOtherCountryVar.set(CFG.R('country'))
        self.settingsOtherDRRSMonthSpinbox.set(CFG.R('schoolyearStart')['M'])
        self.settingsOtherDRRSDaySpinbox.set(CFG.R('schoolyearStart')['D'])
        self.settingsSchoolDataText.delete('1.0', TK.END)
        for x in CFG.R('schoolData'):
            if x[2]:
                x[2] = '1'
            else:
                x[2] = '0'
            x[1] = str(x[1])
            self.settingsSchoolDataText.insert(TK.END, (' | '.join(x) + '\n'))
        self.settingsHeadlinesMailCheckbuttonVar.set(CFG.R('ifHeadlineInMail'))
        self.settingsHeadlinesMailEntryVar.set(CFG.R('headlineInMail'))
        self.settingsHeadlinesOfficeCheckbuttonVar.set(CFG.R('ifHeadlineInOffice'))
        self.settingsHeadlinesOfficeEntryVar.set(CFG.R('headlineInOffice'))

    def settingsButtonSaveAction(self):
        if MSG('A0004', False):
            changes = {}
            changes['mailOutputCoding'] = self.settingsMailCodeCombobox.get()
            changes['officeOutputCoding'] = self.settingsOfficeCodeCombobox.get()
            changes['domain'] = self.settingsOtherDomainVar.get()
            changes['quota'] = self.settingsOtherQuotaSpinbox.get()
            changes['country'] = self.settingsOtherCountryVar.get()
            changes['schoolyearStart'] = {
                'D' : self.settingsOtherDRRSDaySpinbox.get(),
                'M' : self.settingsOtherDRRSMonthSpinbox.get(),
                'Y' : None,
                'h' : None,
                'm' : None,
                's' : None,
            }
            changes['schoolData'] = (self.settingsSchoolDataText.get("1.0", TK.END)).split('\n')
            changes['ifHeadlineInMail'] = self.settingsHeadlinesMailCheckbuttonVar.get()
            changes['headlineInMail'] = self.settingsHeadlinesMailEntryVar.get()
            changes['ifHeadlineInOffice'] = self.settingsHeadlinesOfficeCheckbuttonVar.get()
            changes['headlineInOffice'] = self.settingsHeadlinesOfficeEntryVar.get()
            CFG.W(changes)
            self.settingsReset()
        else:
            return

    def settingsButtonCancelAction(self):
        self.settingsReset()

    def settingsButtonPDUOAction(self):
        if MSG('A0005', False):
            try:
                OS.remove(str(VAR.appdataPath) + '\Generator CSV\config.cfg')
                SU.copy('configs/config.cfg', str(VAR.appdataPath) + '\Generator CSV\config.cfg')
            except Exception as exceptInfo:
                MSG('E0001', True, exceptInfo)
            MSG('I0002', True)
        else:
            return

    def settingsButtonPDUWAction(self):
        if MSG('A0006', False):
            try:
                OS.remove(str(VAR.appdataPath) + '\Generator CSV\style.cfg')
                SU.copy('configs/style.cfg', str(VAR.appdataPath) + '\Generator CSV\style.cfg')
            except Exception as exceptInfo:
                MSG('E0001', True, exceptInfo)
            MSG('I0002', True)
        else:
            return
    
    def deleteSelectedFPButtonAction(self):
        if MSG('A0007', False):
            selected = self.selectFPListbox.curselection()
            for x in selected:
                try:
                    OS.remove(str(VAR.appdataPath) + ('/Generator CSV/format-presets') + ('\%s.fmt' % self.selectFPListbox.get(x)))
                except Exception as exceptInfo:
                    MSG('E0015', True, exceptInfo)
            MSG('I0001', False)
            self.updatePresetListInGenerateTab()
            self.loadingList['values'] = tuple(FMT.getList())
            self.selectFPListbox.delete(0, TK.END)
            for x in FMT.getList():
                self.selectFPListbox.insert(TK.END, x)
        else:
            return

    def settingsButtonZPFAction(self):
        # Pod okno
        self.ZPFWindow = TK.Toplevel(self.master)
        self.ZPFWindow.title("Zarządzanie presetami formatu")
        self.ZPFWindow.geometry('%ix%i' % (GUI.R('ZPFWindowWidth'), GUI.R('ZPFWindowHeight')))
        self.ZPFWindow.resizable(width = GUI.R('ZPFWindowWidthResizable'), height = GUI.R('ZPFWindowHeightResizable'))
        self.ZPFWindow.configure(bg = GUI.R('ZPFWindowMainBG'))
        self.ZPFWindow.iconbitmap(GUI.R('mainIcon'))

        # Wybór format presetu - listbox
        self.selectFPListbox = TK.Listbox(self.ZPFWindow)
        self.selectFPListbox.config(activestyle = GUI.R('listbox1ActiveStyle'))
        self.selectFPListbox.config(bg = GUI.R('listbox1BG'))
        self.selectFPListbox.config(fg = GUI.R('listbox1TextColor'))
        self.selectFPListbox.config(relief = GUI.R('listbox1Relief'))
        self.selectFPListbox.config(bd = GUI.R('listbox1BorderWidth'))
        self.selectFPListbox.config(highlightthickness = GUI.R('listbox1HighlightThickness'))
        self.selectFPListbox.config(selectbackground = GUI.R('listbox1SelectBG'))
        self.selectFPListbox.config(selectmode = TK.MULTIPLE)
        self.selectFPListbox.pack(fill = TK.BOTH, expand = 1, padx = 6, pady = 6)
        for x in FMT.getList():
            self.selectFPListbox.insert(TK.END, x)

        # Usuń zaznaczone - Button
        self.deleteSelectedFPButton = TKttk.Button(self.ZPFWindow)
        self.deleteSelectedFPButton.config(style = 'button1.TButton')
        self.deleteSelectedFPButton.config(text = 'Usuń zaznaczone')
        self.deleteSelectedFPButton.config(command = self.deleteSelectedFPButtonAction)
        self.deleteSelectedFPButton.pack(fill = TK.X, padx = 6, pady = 6)
    
    def aboutInstructionButtonAction(self):
        try:
            OS.startfile('documentation\index.html')
        except Exception as exceptInfo:
            MSG('E0016', False, exceptInfo)




# Inicjacja okna
root = TK.Tk()
windowInit = mainWindow(root)
root.mainloop()