1981 lines
90 KiB
Python
1981 lines
90 KiB
Python
"""
|
|
# Generator CSV
|
|
# Wersja 4.0
|
|
# Autorzy: Mateusz Skoczek
|
|
# Styczeń 2019 - Czerwiec 2020
|
|
# dla ZSP Sobolew
|
|
"""
|
|
|
|
|
|
|
|
|
|
|
|
# ----------------------------------------- # Zmienne # ----------------------------------------- #
|
|
|
|
class VAR:
|
|
programName = 'Generator CSV'
|
|
programVersion = '4.0'
|
|
programCustomer = 'ZSP Sobolew'
|
|
programAuthors = ['Mateusz Skoczek']
|
|
programToW = ['styczeń', 2019, 'wrzesień', 2020]
|
|
|
|
|
|
|
|
|
|
|
|
# --------------------------- # Import wbudowanych bibliotek Pythona # -------------------------- #
|
|
|
|
|
|
# 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
|
|
|
|
|
|
# GUI
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
# ---------------------------------------- # Komunikaty # --------------------------------------- #
|
|
|
|
|
|
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',
|
|
'A0001' : 'Czy chcesz zapisać? Zostanie utworzony nowy plik',
|
|
'A0002' : 'Czy chcesz zapisać? Plik zostanie nadpisany',
|
|
'A0003' : 'Czy chcesz rozpocząć przetwarzanie plików?',
|
|
'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',
|
|
}
|
|
|
|
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.showerror('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 # ------------------------- #
|
|
|
|
appdata = PT.Path.home() / 'Appdata/Roaming'
|
|
|
|
#TODO
|
|
SU.rmtree(str(appdata) + '/Generator CSV')
|
|
#TODO
|
|
if 'Generator CSV' not in [x for x in OS.listdir(appdata)]:
|
|
try:
|
|
OS.mkdir(str(appdata) + '/Generator CSV')
|
|
SU.copy('default-configs/config.cfg', str(appdata) + '\Generator CSV\config.cfg')
|
|
SU.copy('default-configs/style.cfg', str(appdata) + '\Generator CSV\style.cfg')
|
|
OS.mkdir(str(appdata) + '/Generator CSV/format-presets')
|
|
except Exception as exceptInfo:
|
|
MSG('E0001', True, exceptInfo)
|
|
|
|
|
|
|
|
|
|
|
|
# ----------------------------- # Ładowanie pliku konfiguracyjnego # ---------------------------- #
|
|
|
|
class CFG:
|
|
# Funkcje sprawdzające istnienie
|
|
def __checkIfFileExist(self, write):
|
|
if write:
|
|
try:
|
|
file = open((str(appdata) + '\Generator CSV\config.cfg'), 'a')
|
|
except Exception as exceptInfo:
|
|
MSG('E0002', False, exceptInfo)
|
|
return False
|
|
else:
|
|
if not file.writable():
|
|
MSG('E0002', False, 'Plik tylko do odczytu')
|
|
return False
|
|
else:
|
|
return True
|
|
else:
|
|
try:
|
|
open(str(appdata) + '\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 __checkSCA(self, write, record, var):
|
|
if write:
|
|
pass
|
|
else:
|
|
try:
|
|
var = var[1:-2].split(', ')
|
|
var = [x[1:-1] for x in var]
|
|
except:
|
|
return (False, 'Niepoprawne dane - klucz: %s' % record)
|
|
for x in var:
|
|
if len(x) != 1:
|
|
return (False, 'Niepoprawne dane - klucz: %s' % record)
|
|
return [True, var]
|
|
|
|
def __checkI(self, write, record, var):
|
|
if write:
|
|
pass
|
|
else:
|
|
try:
|
|
var = int(var)
|
|
except:
|
|
return (False, 'Niepoprawne dane - klucz: %s' % record)
|
|
return [True, var]
|
|
|
|
def __checkD(self, write, record, var):
|
|
if write:
|
|
pass
|
|
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:
|
|
if x != '*':
|
|
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 R(self, record):
|
|
self.__checkIfFileExist(False)
|
|
content = {}
|
|
for x in CD.open((str(appdata) + '\Generator CSV\config.cfg'), 'r', 'utf-8').read().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]
|
|
return var
|
|
elif var[1] == 'SCA':
|
|
# Single char array
|
|
checkingOutput = self.__checkSCA(False, 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])
|
|
else:
|
|
MSG('E0003', True, 'Nie można rozpoznać typu klucza %s' % record)
|
|
|
|
def W(self):
|
|
pass
|
|
"""
|
|
content = self.R()
|
|
for x in changes:
|
|
content[x] = changes[x]
|
|
contentCheckingOutput = self.__checkContent(True, content)
|
|
if contentCheckingOutput[0]:
|
|
if self.__checkInstance(True):
|
|
with CD.open((str(appdata) + '\Generator CSV\config.cfg'), 'w', 'utf-8') as file:
|
|
contentToSave = contentCheckingOutput[1]
|
|
for x in contentToSave:
|
|
file.write('%s = %s\n' % (x, str(contentToSave[x])))
|
|
else:
|
|
return False
|
|
else:
|
|
MSG('E0004', False, contentCheckingOutput[1])
|
|
"""
|
|
|
|
|
|
CFG = CFG()
|
|
|
|
|
|
|
|
|
|
|
|
# ---------------------------------- # Ładowanie pliku stylu # ---------------------------------- #
|
|
|
|
class GUI:
|
|
# Funkcje sprawdzające istnienie
|
|
def __checkIfFileExist(self):
|
|
try:
|
|
open(str(appdata) + '\Generator CSV\style.cfg')
|
|
except Exception as exceptInfo:
|
|
MSG('E0004', 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ść 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'],
|
|
}
|
|
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]
|
|
|
|
|
|
|
|
def R(self, record):
|
|
self.__checkIfFileExist()
|
|
content = {}
|
|
for x in CD.open((str(appdata) + '\Generator CSV\style.cfg'), 'r', 'utf-8').read().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)
|
|
|
|
|
|
|
|
GUI = GUI()
|
|
|
|
|
|
|
|
|
|
|
|
# ------------------------------- # Zarządzanie plikami formatu # ------------------------------- #
|
|
|
|
class FMT:
|
|
def __checkFolderInstance(self):
|
|
if 'Generator CSV' not in [x for x in OS.listdir(appdata)]:
|
|
OS.mkdir(str(appdata) + '/Generator CSV')
|
|
else:
|
|
if 'format-presets' not in [x for x in OS.listdir(str(appdata) + '\Generator CSV')]:
|
|
OS.mkdir(str(appdata) + '/Generator CSV/format-presets')
|
|
|
|
def __checkContent(self, write, content):
|
|
if write:
|
|
class functions:
|
|
def bool(self, var):
|
|
if var in list(content.keys()):
|
|
if content[var] != True and content[var] != False:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
else:
|
|
if content[var] == False:
|
|
content[var] = '0'
|
|
return [True]
|
|
else:
|
|
content[var] = '1'
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def separator_string(self, var):
|
|
if var in list(content.keys()):
|
|
allowedCharactersInSeparator = CFG.R()['allowedCharactersInSeparator']
|
|
check = content[var]
|
|
check = check.strip('<enter>')
|
|
for x in check:
|
|
if x not in allowedCharactersInSeparator:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def separator_array(self, var):
|
|
if var in list(content.keys()):
|
|
allowedCharactersInSeparator = CFG.R()['allowedCharactersInSeparator']
|
|
check = content[var]
|
|
for x in check:
|
|
x = x.strip('<enter>')
|
|
for y in x:
|
|
if y not in allowedCharactersInSeparator:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
content[var] = str(content[var])
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def integer(self, var):
|
|
if var in list(content.keys()):
|
|
content[var] = str(content[var])
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
functions = functions()
|
|
check = functions.bool('student')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_string('personSeparator')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_string('rowSeparator')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_array('dataSeparators')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('loginRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('loginPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('fnameRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('fnamePositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('lnameRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('lnamePositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('schoolRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('schoolPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('classRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('classPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
return [True, content]
|
|
else:
|
|
class functions:
|
|
def bool(self, var):
|
|
if var in list(content.keys()):
|
|
if content[var] != '0' and content[var] != '1':
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
else:
|
|
if content[var] == '0':
|
|
content[var] = False
|
|
return [True]
|
|
else:
|
|
content[var] = True
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def separator_string(self, var):
|
|
if var in list(content.keys()):
|
|
allowedCharactersInSeparator = CFG.R('allowedCharactersInSeparator')
|
|
check = content[var]
|
|
check = check.strip('<enter>')
|
|
for x in check:
|
|
if x not in allowedCharactersInSeparator:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def separator_array(self, var):
|
|
if var in list(content.keys()):
|
|
allowedCharactersInSeparator = CFG.R('allowedCharactersInSeparator')
|
|
new_contentVar = (content[var])[2:-2].split("', '")
|
|
check = new_contentVar
|
|
for x in check:
|
|
x = x.strip('<enter>')
|
|
for y in x:
|
|
if y not in allowedCharactersInSeparator:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
content[var] = new_contentVar
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
def integer(self, var):
|
|
if var in list(content.keys()):
|
|
try:
|
|
check = int(content[var])
|
|
except:
|
|
return [False, 'Niepoprawne dane - klucz: %s' % var]
|
|
else:
|
|
content[var] = int(content[var])
|
|
return [True]
|
|
else:
|
|
return [False, 'Brak danych - klucz: %s' % var]
|
|
functions = functions()
|
|
check = functions.bool('student')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_string('personSeparator')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_string('rowSeparator')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.separator_array('dataSeparators')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('loginRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('loginPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('fnameRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('fnamePositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('lnameRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('lnamePositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('schoolRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('schoolPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('classRow')
|
|
if not check[0]:
|
|
return check
|
|
check = functions.integer('classPositionInRow')
|
|
if not check[0]:
|
|
return check
|
|
return [True, content]
|
|
|
|
def getList(self):
|
|
self.__checkFolderInstance()
|
|
filesList = OS.listdir(str(appdata) + '/Generator CSV/format-presets')
|
|
formatPresetsList = []
|
|
for x in filesList:
|
|
if x[-4:] == '.fmt':
|
|
formatPresetsList.append(x[:-4])
|
|
else:
|
|
continue
|
|
return formatPresetsList
|
|
|
|
def R(self, preset):
|
|
if preset in self.getList():
|
|
path = str(appdata) + '/Generator CSV/format-presets/%s.fmt' % preset
|
|
file = CD.open(path, 'r', 'utf-8').read().split('\n')
|
|
content = {}
|
|
for x in file:
|
|
x = x.split(' = ')
|
|
try:
|
|
content[x[0]] = (x[1]).strip('\r')
|
|
except:
|
|
continue
|
|
contentCheckingOutput = self.__checkContent(False, content)
|
|
if contentCheckingOutput[0]:
|
|
content = contentCheckingOutput[1]
|
|
else:
|
|
MSG('E0006', False, contentCheckingOutput[1])
|
|
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,
|
|
}
|
|
return content
|
|
|
|
def W(self, preset, content):
|
|
contentCheckingOutput = self.__checkContent(True, content)
|
|
if contentCheckingOutput[0]:
|
|
contentToSave = contentCheckingOutput[1]
|
|
with CD.open(str(appdata) + '/Generator CSV/format-presets/%s.fmt' % preset, 'w', 'utf-8') as file:
|
|
for x in contentToSave:
|
|
file.write(x + ' = ' + content[x] + '\n')
|
|
return True
|
|
else:
|
|
MSG('E0006', False, contentCheckingOutput[1])
|
|
return False
|
|
FMT = FMT()
|
|
|
|
|
|
|
|
|
|
|
|
# ---------------------------------- # Przetwarzanie plików # ----------------------------------- #
|
|
|
|
class dataProcess:
|
|
# Funkcje sprawdzające
|
|
def __checkIfAtLeastOneInputFileIsFilled(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', CFG.R('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 __checkIfCreateOutputFilesIsPossible(self, files):
|
|
for x in files:
|
|
try:
|
|
check = CD.open(x, 'w', CFG.R('outputCoding'))
|
|
except:
|
|
return False
|
|
return true
|
|
|
|
#
|
|
|
|
|
|
|
|
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
|
|
|
|
testOutput = self.__checkIfInputFilesFormatPresetsExist(files[-1])
|
|
checkingOutput.append(testOutput)
|
|
if not testOutput:
|
|
return checkingOutput
|
|
|
|
input = []
|
|
for x in filledFiles:
|
|
input.append(files[x])
|
|
output = files[-1]
|
|
|
|
testOutput = self.__checkIfCreateOutputFilesIsPossible(files[-1])
|
|
checkingOutput.append(testOutput)
|
|
if not testOutput:
|
|
return checkingOutput
|
|
|
|
|
|
dataProcess = dataProcess()
|
|
|
|
|
|
|
|
|
|
|
|
# ------------------------------------------- # GUI # ------------------------------------------- #
|
|
|
|
class mainWindow:
|
|
def __init__(self, master):
|
|
# Okno
|
|
self.master = master
|
|
master.title('%s %s' % (VAR.programName, VAR.programVersion))
|
|
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')
|
|
},
|
|
},
|
|
"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'),
|
|
},
|
|
},
|
|
"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 (1)')
|
|
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 (1)')
|
|
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 (1)')
|
|
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'))#, pady = 5, padx = 10)
|
|
|
|
# "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'))
|
|
|
|
###############################
|
|
|
|
#########################################
|
|
|
|
###################################################
|
|
|
|
# (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'))
|
|
|
|
#############################################################
|
|
|
|
# (2) 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'))
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
|
|
# 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'))
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
# 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:
|
|
pass
|
|
else:
|
|
return
|
|
|
|
# Akcje przycisków - TAB2
|
|
|
|
def loadingButtonAction(self):
|
|
formatFileContent = FMT.R(self.loadingList.get())
|
|
self.loadingList['state'] = TK.DISABLED
|
|
self.loadingButton['state'] = TK.DISABLED
|
|
self.EPOSTypeVar.set(formatFileContent['student'])
|
|
self.EPOSTypeStudentRadiobutton['state'] = TK.NORMAL
|
|
self.EPOSTypeTeacherRadiobutton['state'] = TK.NORMAL
|
|
self.EPOSPersonSeparatorEntry['state'] = TK.NORMAL
|
|
self.EPOSPersonSeparatorVar.set(formatFileContent['personSeparator'])
|
|
self.EPOSRowSeparatorEntry['state'] = TK.NORMAL
|
|
self.EPOSRowSeparatorVar.set(formatFileContent['rowSeparator'])
|
|
self.EPOSDataSeparatorText['state'] = TK.NORMAL
|
|
self.EPOSDataSeparatorText.insert(TK.END, '\n'.join(formatFileContent['dataSeparators']))
|
|
self.EPDLLoginRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLLoginRowVar.set(formatFileContent['loginRow'])
|
|
self.EPDLLoginPosInRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLLoginPosInRowVar.set(formatFileContent['loginPositionInRow'])
|
|
self.EPDLFnameRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLFnameRowVar.set(formatFileContent['fnameRow'])
|
|
self.EPDLFnamePosInRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLFnamePosInRowVar.set(formatFileContent['fnamePositionInRow'])
|
|
self.EPDLLnameRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLLnameRowVar.set(formatFileContent['lnameRow'])
|
|
self.EPDLLnamePosInRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLLnamePosInRowVar.set(formatFileContent['lnamePositionInRow'])
|
|
self.EPDLSchoolRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLSchoolRowVar.set(formatFileContent['schoolRow'])
|
|
self.EPDLSchoolPosInRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLSchoolPosInRowVar.set(formatFileContent['schoolPositionInRow'])
|
|
self.EPDLClassRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLClassRowVar.set(formatFileContent['classRow'])
|
|
self.EPDLClassPosInRowSpinbox['state'] = TK.NORMAL
|
|
self.EPDLClassPosInRowVar.set(formatFileContent['classPositionInRow'])
|
|
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,
|
|
}
|
|
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.editingPresetSaveButton['state'] = TK.DISABLED
|
|
self.editingPresetCancelButton['state'] = TK.DISABLED
|
|
self.loadingList['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" : int(self.EPDLLoginRowSpinbox.get()),
|
|
"loginPositionInRow" : int(self.EPDLLoginPosInRowSpinbox.get()),
|
|
"fnameRow" : int(self.EPDLFnameRowSpinbox.get()),
|
|
"fnamePositionInRow" : int(self.EPDLFnamePosInRowSpinbox.get()),
|
|
"lnameRow" : int(self.EPDLLnameRowSpinbox.get()),
|
|
"lnamePositionInRow" : int(self.EPDLLnamePosInRowSpinbox.get()),
|
|
"schoolRow" : int(self.EPDLSchoolRowSpinbox.get()),
|
|
"schoolPositionInRow" : int(self.EPDLSchoolPosInRowSpinbox.get()),
|
|
"classRow" : int(self.EPDLClassRowSpinbox.get()),
|
|
"classPositionInRow" : int(self.EPDLClassPosInRowSpinbox.get()),
|
|
}
|
|
if not FMT.W(self.loadingList.get(), formatFileContentToSave):
|
|
return
|
|
self.editingPresetClear()
|
|
|
|
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()
|
|
|
|
|
|
|
|
|
|
# Inicjacja okna
|
|
root = TK.Tk()
|
|
windowInit = mainWindow(root)
|
|
root.mainloop() |