def show(profiles, show, sorting_criteria):
"""type of profiles to be displayed (active, all, inactive etc.)"""
language_dict = set_options.Options()
language_dict.get_text_dict("compare_profiles_tab")
lang_dict = language_dict.widget_text_dictionary
filtered_profiles = list()
if show == lang_dict["pick_prof_tuple1"]:
for prof in profiles:
if prof['SOLD'] == 'not_sold' and prof['DATE_OF_DEATH'] == '':
filtered_profiles.append(prof)
return sort(filtered_profiles, sorting_criteria, lang_dict)
if show == lang_dict["pick_prof_tuple2"]:
for prof in profiles:
if (prof['SOLD'] == 'not_sold' and prof['DATE_OF_DEATH'] == ''
and prof['GENDER'] == 'female'):
filtered_profiles.append(prof)
return sort(filtered_profiles, sorting_criteria, lang_dict)
if show == lang_dict["pick_prof_tuple3"]:
for prof in profiles:
if (prof['SOLD'] == 'not_sold' and prof['DATE_OF_DEATH'] == ''
and prof['GENDER'] == 'male'):
filtered_profiles.append(prof)
return sort(filtered_profiles, sorting_criteria, lang_dict)
if show == lang_dict["pick_prof_tuple4"]:
for prof in profiles:
if prof['SOLD'] == 'sold' or prof['DATE_OF_DEATH'] != '':
filtered_profiles.append(prof)
return sort(filtered_profiles, sorting_criteria, lang_dict)
if show == lang_dict["pick_prof_tuple5"]:
return sort(profiles, sorting_criteria, lang_dict)
def clear_date_of_birth(profiles):
"""clear dob input"""
language_dict = set_options.Options()
language_dict.get_text_dict("sort_profiles")
lang_dict = language_dict.widget_text_dictionary
curent_date = get_date.get(0)
sorted_profiles = list()
age = 0
for prof in profiles:
if prof["DATE_OF_BIRTH"] != "" and prof["DATE_OF_DEATH"] == "":
age = curent_date['ViewedYear'] - int(prof["DATE_OF_BIRTH"][6:10])
# lower one year if month of birth is lower than actual month
if (int(prof["DATE_OF_BIRTH"][3:5].strip('0')) >
curent_date['ViewedMonth']):
age -= 1
prof["DATE_OF_BIRTH"] = (prof["DATE_OF_BIRTH"] + "(" + str(age) +
lang_dict["age"] + ")")
sorted_profiles.append(prof)
elif prof["DATE_OF_BIRTH"] != "" and prof["DATE_OF_DEATH"] != "":
age = (int(prof["DATE_OF_DEATH"][6:10]) -
int(prof["DATE_OF_BIRTH"][6:10]))
prof["DATE_OF_BIRTH"] = (prof["DATE_OF_BIRTH"] + "(" + str(age) +
lang_dict["age"] + ")")
sorted_profiles.append(prof)
else:
sorted_profiles.append(prof)
return sorted_profiles
def milking_event(date_dict, milking):
"""check milking event"""
language_dict = set_options.Options()
language_dict.get_text_dict("check_calendar_input")
lang_dict = language_dict.widget_text_dictionary
if milking == "":
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox12"])
return "error"
if milking.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox13"])
return "error"
if milking.isdigit() is False:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox14"])
return "error"
if 0 > int(milking) > 8000:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox15"])
return "error"
date_dict['Input1'] = int(milking)
process_calendar_data.save_milking(date_dict)
return "success"
def get_month_name(month_counter):
"""returns name of the month depending on month number"""
language_dict = set_options.Options()
language_dict.get_text_dict("process_calendar_data")
lang_dict = language_dict.widget_text_dictionary
date_dict = get_date.get(month_counter)
if int(date_dict['ViewedMonth']) == 1:
month_name = lang_dict["month1"]
elif int(date_dict['ViewedMonth']) == 2:
month_name = lang_dict["month2"]
elif int(date_dict['ViewedMonth']) == 3:
month_name = lang_dict["month3"]
elif int(date_dict['ViewedMonth']) == 4:
month_name = lang_dict["month4"]
elif int(date_dict['ViewedMonth']) == 5:
month_name = lang_dict["month5"]
elif int(date_dict['ViewedMonth']) == 6:
month_name = lang_dict["month6"]
elif int(date_dict['ViewedMonth']) == 7:
month_name = lang_dict["month7"]
elif int(date_dict['ViewedMonth']) == 8:
month_name = lang_dict["month8"]
elif int(date_dict['ViewedMonth']) == 9:
month_name = lang_dict["month9"]
elif int(date_dict['ViewedMonth']) == 10:
month_name = lang_dict["month10"]
elif int(date_dict['ViewedMonth']) == 11:
month_name = lang_dict["month11"]
elif int(date_dict['ViewedMonth']) == 12:
month_name = lang_dict["month12"]
return month_name
def medicine_event(date_dict, patient, medicine, dosing, withdrawal, note):
"""check medicine event"""
language_dict = set_options.Options()
language_dict.get_text_dict("check_calendar_input")
lang_dict = language_dict.widget_text_dictionary
if patient.find('-') != -1 and medicine.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
return "error"
if dosing.find('-') != -1 and withdrawal.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
return "error"
if note.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
return "error"
if patient == "" and medicine == "":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox5"])
return "error"
if dosing == "":
date_dict["Input3"] = 1
else:
if dosing.isdigit() is False:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox6"])
return "error"
if int(dosing) < 0:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox7"])
return "error"
if int(dosing) > 20:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox8"])
return "error"
if withdrawal != "":
if withdrawal.isdigit() is False:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox9"])
return "error"
if int(withdrawal) < 0:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox10"])
return "error"
if int(withdrawal) > 20:
messagebox.showinfo(lang_dict["messagebox1"],
lang_dict["messagebox11"])
return "error"
date_dict["Input1"] = patient
date_dict["Input2"] = medicine
if dosing == "":
date_dict["Input3"] = 0
else:
date_dict["Input3"] = int(dosing)
if withdrawal == "":
date_dict["Input4"] = 0
else:
date_dict["Input4"] = int(withdrawal)
date_dict["Input5"] = note
process_calendar_data.save_medicine(date_dict)
return "success"
def messages(message_type):
language_dict = set_options.Options()
language_dict.get_text_dict("process_profiles_data")
lang_dict = language_dict.widget_text_dictionary
if message_type == "saved":
messagebox.showinfo(lang_dict["messagebox"], lang_dict["messagebox1"])
if message_type == "name in use":
messagebox.showinfo(lang_dict["messagebox2"], lang_dict["messagebox3"])
if message_type == "id in use":
messagebox.showinfo(lang_dict["messagebox2"], lang_dict["messagebox4"])
def other_event(date_dict, title, note):
"""check other event"""
language_dict = set_options.Options()
language_dict.get_text_dict("check_calendar_input")
lang_dict = language_dict.widget_text_dictionary
if title.find('-') != -1 and note.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
return "error"
date_dict['Input1'] = title
date_dict['Input2'] = note
process_calendar_data.save_other(date_dict)
return "success"
def delete_event(number):
"""takes unique event number and deletes it from txt file"""
language_dict = set_options.Options()
language_dict.get_text_dict("process_calendar_data")
lang_dict = language_dict.widget_text_dictionary
# try to open Calendar.txt and read all lines
# each containing one event to a 'content' list
try:
container = open("Calendar.txt", "r")
content = list()
content = container.readlines()
container.close()
one_event_list = []
list_of_stuff_to_remove = []
# save all events you want to delete to a list
for i in content:
one_event_list = i.split("-")
if one_event_list[len(one_event_list)-1] == number:
list_of_stuff_to_remove.append(i)
# delete those events from your 'content'
for stuff in list_of_stuff_to_remove:
content.remove(stuff)
# rewrite Calendar.txt with events from 'content'
try:
container = open("Calendar.txt", "w")
for line in content:
container.write(line)
except IOError:
messagebox.showinfo(
lang_dict["messagebox3"], lang_dict["messagebox6"])
container.close()
else:
messagebox.showinfo(
lang_dict["messagebox1"], lang_dict["messagebox7"])
container.close()
return
except IOError:
container.close()
return
else:
container.close()
return
def pregnancy_event(date_dict, add_mum, add_dad):
"""check pregnancy event"""
language_dict = set_options.Options()
language_dict.get_text_dict("check_calendar_input")
lang_dict = language_dict.widget_text_dictionary
if add_mum.find('-') != -1 and add_dad.find('-') != -1:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
return "error"
if add_dad == "":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox3"])
return "error"
if add_mum == "":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox4"])
return "error"
date_dict["Input1"] = add_mum
date_dict["Input2"] = add_dad
process_calendar_data.save_pregnancy(date_dict)
return "success"
def save_milking(date_dict):
"""saves milking event"""
language_dict = set_options.Options()
language_dict.get_text_dict("process_calendar_data")
lang_dict = language_dict.widget_text_dictionary
random_num = random.randint(1, 1000000)
try:
container = open("Calendar.txt", "a")
container.write(
str(date_dict['ViewedYear'])+'/' +
str(date_dict['ViewedMonth'])+'/' +
str(date_dict['DayOfTheNewEvent'])+'-'+"MILKING"+'-' +
str(date_dict['Input1'])+'-'+str(random_num)+'\n')
except IOError:
messagebox.showinfo(lang_dict["messagebox3"], lang_dict["messagebox4"])
container.close()
else:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox5"])
container.close()
def clear(profile):
"""clear data from clues pre-inputed in the interface"""
language_dict = set_options.Options()
language_dict.get_text_dict("add_profiles_tab")
lang_dict = language_dict.widget_text_dictionary
if profile["NAME"] == lang_dict["name_entry"]:
profile["NAME"] = ""
if profile["MOTHER"] == lang_dict["name_entry"]:
profile["MOTHER"] = ""
if profile["FATHER"] == lang_dict["name_entry"]:
profile["FATHER"] = ""
if profile["DATE_OF_BIRTH"] == lang_dict["dob_entry"]:
profile["DATE_OF_BIRTH"] = ""
if profile["DATE_OF_DEATH"] == lang_dict["dob_entry"]:
profile["DATE_OF_DEATH"] = ""
return profile
def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.master = master
self.master.title("Goatbook")
self.master.geometry("770x770")
self.master.grid()
rows = 0
while rows < 50:
self.master.rowconfigure(rows, weight=1)
self.master.columnconfigure(rows, weight=1)
rows += 1
notebook = ttk.Notebook(self.master)
notebook.grid(row=0,
column=0,
columnspan=50,
rowspan=49,
sticky="NESW")
language_dict = set_options.Options()
language_dict.get_text_dict("run_me")
lang_dict = language_dict.widget_text_dictionary
profiles_frame = ttk.Frame(notebook)
notebook.add(profiles_frame, text=lang_dict["profiles_frame"])
charts_frame = ttk.Frame(notebook)
notebook.add(charts_frame, text=lang_dict["charts_frame"])
calendar_frame = ttk.Frame(notebook)
notebook.add(calendar_frame, text=lang_dict["calendar_frame"])
options_frame = ttk.Frame(notebook)
notebook.add(options_frame, text=lang_dict["options_frame"])
profiles_menu(profiles_frame, lang_dict)
charts_menu(charts_frame, lang_dict)
calendar(calendar_frame)
options(options_frame, lang_dict)
def messages(message_type):
"""display message, different for each error"""
language_dict = set_options.Options()
language_dict.get_text_dict("check_profiles_input")
lang_dict = language_dict.widget_text_dictionary
if message_type == "empty fields.":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox2"])
elif message_type == "no gender":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox3"])
elif message_type == "less than 30":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox5"])
elif message_type == "capital":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox6"])
elif message_type == "#":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox4"])
elif message_type == "date":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox7"])
elif message_type == "@":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox8"])
elif message_type == "milking":
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox9"])
elif message_type == "success":
messagebox.showinfo(lang_dict["messagebox"], lang_dict["messagebox10"])
def __init__(self, tab, month_counter):
"""
pressing 'next month' reloads __init__ with mounth_counter as 1
and pressing 'prev month' reloads __init__ with mounth_counter as -1
you can go as far as you like in future or past
"""
date_dict = get_date.get(month_counter)
language_dict = set_options.Options()
language_dict.get_text_dict("calendar_tab")
lang_dict = language_dict.widget_text_dictionary
def next_month():
next_month = month_counter + 1
Calendar(tab, next_month)
def previous_month():
prev_month = month_counter - 1
Calendar(tab, prev_month)
calendar_frame = tk.Frame(tab, height=800, width=800)
calendar_frame.place(x=0, y=0)
month_name = process_calendar_data.get_month_name(month_counter)
# "next month" and "previous month" buttons
prev_month_bttn = tk.Button(
calendar_frame, text="<", height=1, command=previous_month,
width=1, font="Helvetica 25 bold", relief=tk.FLAT, takefocus=0)
prev_month_bttn.place(x=160, y=10)
next_month_bttn = tk.Button(
calendar_frame, text=">", height=1, command=next_month, width=1,
font="Helvetica 25 bold", relief=tk.FLAT, takefocus=0)
next_month_bttn.place(x=600, y=10)
month_label = tk.Label(
calendar_frame, text=month_name + " " +
str(date_dict['ViewedYear']), font="Helvetica 20")
month_label.place(x=310, y=20)
mo_label = tk.Label(
calendar_frame, text=lang_dict["mo_label"], font="Helvetica 16")
mo_label.place(x=70, y=60)
tu_label = tk.Label(
calendar_frame, text=lang_dict["tu_label"], font="Helvetica 16")
tu_label.place(x=170, y=60)
we_label = tk.Label(
calendar_frame, text=lang_dict["we_label"], font="Helvetica 16")
we_label.place(x=270, y=60)
th_label = tk.Label(
calendar_frame, text=lang_dict["th_label"], font="Helvetica 16")
th_label.place(x=370, y=60)
fr_label = tk.Label(
calendar_frame, text=lang_dict["fr_label"], font="Helvetica 16")
fr_label.place(x=470, y=60)
sa_label = tk.Label(
calendar_frame, text=lang_dict["sa_label"], font="Helvetica 16")
sa_label.place(x=570, y=60)
su_label = tk.Label(
calendar_frame, text=lang_dict["su_label"], font="Helvetica 16")
su_label.place(x=670, y=60)
# define position of first day(button) on the calendar depending on
# lang_dict['FirstDayOfTheViewedMonth'] - day of the week
# given month starts with
y_orient = 100
if int(date_dict['FirstDayOfTheViewedMonth']) == 0:
x_orient = 60
counter = 1
elif int(date_dict['FirstDayOfTheViewedMonth']) == 1:
x_orient = 160
counter = 2
elif int(date_dict['FirstDayOfTheViewedMonth']) == 2:
x_orient = 260
counter = 3
elif int(date_dict['FirstDayOfTheViewedMonth']) == 3:
x_orient = 360
counter = 4
elif int(date_dict['FirstDayOfTheViewedMonth']) == 4:
x_orient = 460
counter = 5
elif int(date_dict['FirstDayOfTheViewedMonth']) == 5:
x_orient = 560
counter = 6
elif int(date_dict['FirstDayOfTheViewedMonth']) == 6:
x_orient = 660
counter = 7
# next 31 buttons serve as days in calendar
# function below lets know which button triggered add_event_window
day_1_button = CreateButton(
calendar_frame, "01", x_orient, y_orient, tab, month_counter)
day_1_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_1_canvas.event_markers(month_counter, 1)
# using counter i make sure that no more than seven
# buttons(days) are displayed in each row(week)
counter += 1
# if to far right start from beginning
if x_orient == 660:
x_orient = 60
# if not to far right place next button right from last one
else:
x_orient = x_orient+100
# each row has 7 positions, if last button was placed on last position
# in given row - display next button in row bellow
if counter >= 8:
y_orient = 200
day_2_button = CreateButton(
calendar_frame, "02", x_orient, y_orient, tab, month_counter)
day_2_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_2_canvas.event_markers(month_counter, 2)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_3_button = CreateButton(
calendar_frame, "03", x_orient, y_orient, tab, month_counter)
day_3_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_3_canvas.event_markers(month_counter, 3)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_4_button = CreateButton(
calendar_frame, "04", x_orient, y_orient, tab, month_counter)
day_4_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_4_canvas.event_markers(month_counter, 4)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_5_button = CreateButton(
calendar_frame, "05", x_orient, y_orient, tab, month_counter)
day_5_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_5_canvas.event_markers(month_counter, 5)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_6_button = CreateButton(
calendar_frame, "06", x_orient, y_orient, tab, month_counter)
day_6_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_6_canvas.event_markers(month_counter, 6)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_7_button = CreateButton(
calendar_frame, "07", x_orient, y_orient, tab, month_counter)
day_7_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_7_canvas.event_markers(month_counter, 7)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 8:
y_orient = 200
day_8_button = CreateButton(
calendar_frame, "08", x_orient, y_orient, tab, month_counter)
day_8_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_8_canvas.event_markers(month_counter, 8)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_9_button = CreateButton(
calendar_frame, "09", x_orient, y_orient, tab, month_counter)
day_9_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_9_canvas.event_markers(month_counter, 9)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_10_button = CreateButton(
calendar_frame, "10", x_orient, y_orient, tab, month_counter)
day_10_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_10_canvas.event_markers(month_counter, 10)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_11_button = CreateButton(
calendar_frame, "11", x_orient, y_orient, tab, month_counter)
day_11_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_11_canvas.event_markers(month_counter, 11)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_12_button = CreateButton(
calendar_frame, "12", x_orient, y_orient, tab, month_counter)
day_12_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_12_canvas.event_markers(month_counter, 12)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_13_button = CreateButton(
calendar_frame, "13", x_orient, y_orient, tab, month_counter)
day_13_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_13_canvas.event_markers(month_counter, 13)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_14_button = CreateButton(
calendar_frame, "14", x_orient, y_orient, tab, month_counter)
day_14_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_14_canvas.event_markers(month_counter, 14)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 15:
y_orient = 300
day_15_button = CreateButton(
calendar_frame, "15", x_orient, y_orient, tab, month_counter)
day_15_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_15_canvas.event_markers(month_counter, 15)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_16_button = CreateButton(
calendar_frame, "16", x_orient, y_orient, tab, month_counter)
day_16_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_16_canvas.event_markers(month_counter, 16)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_17_button = CreateButton(
calendar_frame, "17", x_orient, y_orient, tab, month_counter)
day_17_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_17_canvas.event_markers(month_counter, 17)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_18_button = CreateButton(
calendar_frame, "18", x_orient, y_orient, tab, month_counter)
day_18_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_18_canvas.event_markers(month_counter, 18)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_19_button = CreateButton(
calendar_frame, "19", x_orient, y_orient, tab, month_counter)
day_19_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_19_canvas.event_markers(month_counter, 19)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_20_button = CreateButton(
calendar_frame, "20", x_orient, y_orient, tab, month_counter)
day_20_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_20_canvas.event_markers(month_counter, 20)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_21_button = CreateButton(
calendar_frame, "21", x_orient, y_orient, tab, month_counter)
day_21_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_21_canvas.event_markers(month_counter, 21)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 22:
y_orient = 400
day_22_button = CreateButton(
calendar_frame, "22", x_orient, y_orient, tab, month_counter)
day_22_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_22_canvas.event_markers(month_counter, 22)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_23_button = CreateButton(
calendar_frame, "23", x_orient, y_orient, tab, month_counter)
day_23_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_23_canvas.event_markers(month_counter, 23)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_24_button = CreateButton(
calendar_frame, "24", x_orient, y_orient, tab, month_counter)
day_24_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_24_canvas.event_markers(month_counter, 24)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
dahy_25_button = CreateButton(
calendar_frame, "25", x_orient, y_orient, tab, month_counter)
day_25_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_25_canvas.event_markers(month_counter, 25)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_26_button = CreateButton(
calendar_frame, "26", x_orient, y_orient, tab, month_counter)
day_26_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_26_canvas.event_markers(month_counter, 26)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_27_button = CreateButton(
calendar_frame, "27", x_orient, y_orient, tab, month_counter)
day_27_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_27_canvas.event_markers(month_counter, 27)
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_28_button = CreateButton(
calendar_frame, "28", x_orient, y_orient, tab, month_counter)
day_28_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_28_canvas.event_markers(month_counter, 28)
if int(date_dict['DaysInViewedMonth']) >= 29:
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 29:
y_orient = 500
day_29_button = CreateButton(
calendar_frame, "29", x_orient, y_orient, tab, month_counter)
day_29_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_29_canvas.event_markers(month_counter, 29)
if int(date_dict['DaysInViewedMonth']) >= 30:
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 36:
y_orient = 600
day_30_button = CreateButton(
calendar_frame, "30", x_orient, y_orient, tab, month_counter)
day_30_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_30_canvas.event_markers(month_counter, 30)
if int(date_dict['DaysInViewedMonth']) >= 31:
counter += 1
if x_orient == 660:
x_orient = 60
else:
x_orient = x_orient+100
if counter >= 36:
y_orient = 600
day_31_button = CreateButton(
calendar_frame, "31", x_orient, y_orient, tab, month_counter)
day_31_canvas = CreateCanvas(calendar_frame, x_orient, y_orient)
day_31_canvas.event_markers(month_counter, 31)
counter += 1
def __init__(self):
def get_profile():
name_and_number = {
"NAME": name_entry.get(),
"ID_NUMBER": id_entry.get()
}
profile = process_profiles_data.get_single_profile(name_and_number)
if profile != "error":
ManipulateProfile().view_profile(profile)
self.find_prof_frame.destroy()
else:
messagebox.showinfo(self.dict["messagebox1"],
self.dict["messagebox2"])
language_dict = set_options.Options()
language_dict.get_text_dict("view_edit_delete_profile")
self.dict = language_dict.widget_text_dictionary
# NEW FRAME
self.find_prof_frame = tk.Frame()
self.find_prof_frame.grid(row=0,
column=0,
columnspan=50,
rowspan=50,
sticky="NESW")
# BUTTONS
back_button = tk.Button(self.find_prof_frame,
text=self.dict["back_button"],
height=2,
width=7,
font="Helvetica 12",
command=self.find_prof_frame.destroy)
back_button.place(x=10, y=10)
search_button = tk.Button(self.find_prof_frame,
text=self.dict["search_button"],
height=2,
width=7,
font="Helvetica 12",
command=get_profile)
search_button.place(x=100, y=10)
# ENTRY
name_entry = tk.Entry(self.find_prof_frame,
width=30,
font="Helvetica 12")
name_entry.place(x=300, y=150)
id_entry = tk.Entry(self.find_prof_frame,
width=30,
font="Helvetica 12")
id_entry.place(x=300, y=190)
# LABELS
help_label = tk.Label(self.find_prof_frame,
text=self.dict["help_label"],
font="Helvetica 12")
help_label.place(x=50, y=100)
name_label = tk.Label(self.find_prof_frame,
text=self.dict["name_label"],
font="Helvetica 12")
name_label.place(x=50, y=150)
id_label = tk.Label(self.find_prof_frame,
text=self.dict["id_label"],
font="Helvetica 12")
id_label.place(x=50, y=190)
def milking_chart():
"""chart containing quantity of milk on y axis and day on x axis"""
language_dict = set_options.Options()
language_dict.get_text_dict("charts_tab")
lang_dict = language_dict.widget_text_dictionary
milking_window = tk.Toplevel(height=1000, width=1000)
milking_window.minsize(width=700, height=410)
rows = 0
while rows < 100:
milking_window.rowconfigure(rows, weight=1)
milking_window.columnconfigure(rows, weight=2)
rows += 1
def on_frame_configure(milking_canvas):
'''Reset the scroll region to encompass the inner frame'''
milking_canvas.configure(scrollregion=milking_canvas.bbox("all"))
milking_label = tk.Label(milking_window, text=lang_dict["milking_label"])
milking_label.grid(row=0, column=1)
# Frame on which canvas and milk quantity is displayed
values_frame = tk.Frame(milking_window, width=700, height=435)
values_frame.grid(row=1,
column=0,
columnspan=15,
rowspan=16,
sticky=tk.W + tk.E + tk.N + tk.S)
# contains drownings for chart and a little frame on the bottom with
# date labels, both canvas and this frame are bind to be scrollable
milking_canvas = tk.Canvas(values_frame,
bg="white",
width=680,
height=435,
scrollregion=(0, 0, 5520, 0))
milking_canvas.place(x=25, y=0)
# little frame on the bottom of canvas, bind with canvas
dates_frame = tk.Frame(milking_canvas, width=5500, height=17)
dates_frame.bind("<Configure>",
lambda event, milking_canvas=milking_canvas:
on_frame_configure(milking_canvas))
milking_canvas.create_window((0, 435), window=dates_frame, anchor="sw")
# create lines showing x and y axis on canvas
milking_canvas.create_line(10, 10, 10, 410)
milking_canvas.create_line(10, 410, 5500, 410)
hbar = tk.Scrollbar(milking_window,
orient=tk.HORIZONTAL,
command=milking_canvas.xview)
hbar.grid(row=17, column=0, columnspan=15, rowspan=15, sticky=tk.W + tk.E)
# get dictionary containing number of the month as key and number of
# days within it as value
monthrange = get_date.get_year_and_monthranges()
# reads all milking events during current year
events = process_calendar_data.get_milking_events()
# get the biggest milking mesurment to adjust the chart
value = 0
if events:
for month in range(1, 13):
for day in range(1, monthrange[str(month)] + 1):
y_m_d = (str(monthrange['CurrentYear']) + '/' + str(month) +
'/' + str(day))
try:
if int(events[y_m_d]) > value:
value = int(events[y_m_d])
except KeyError:
pass
# determine ratio depending on biggest value in milking events
# ratio 8 means that for one unit of milk there are 8
# pixels to display the value with 50 units being max value
if value * 8 <= 400:
ratio = 8
quantity_marks = 16
counter = 16
quantity_label = 2
x_constant = 7
y_constant = 403
ratio = 8
elif value * 4 <= 400:
ratio = 4
quantity_marks = 20
counter = 20
quantity_label = 5
x_constant = 2
y_constant = 408
elif value * 2 <= 400:
ratio = 2
quantity_marks = 20
counter = 10
quantity_label = 10
x_constant = 2
y_constant = 403
elif value * 1 <= 400:
ratio = 1
quantity_marks = 25
counter = 25
quantity_label = 25
x_constant = 2
y_constant = 403
elif value / 2 <= 400:
# ratio -2 means that for one pixel displayed there are 2 units of
# milk with 800 units being max value
ratio = -2
quantity_marks = 25
counter = 25
quantity_label = 50
x_constant = 2
y_constant = 403
elif value / 4 <= 400:
ratio = -4
quantity_marks = 25
counter = 25
quantity_label = 100
x_constant = 0
y_constant = 403
elif value / 8 <= 400:
ratio = -8
quantity_marks = 25
counter = 25
quantity_label = 200
x_constant = 0
y_constant = 403
elif value / 10 <= 400:
ratio = -10
quantity_marks = 25
counter = 25
quantity_label = 250
x_constant = 0
y_constant = 403
elif value / 20 <= 400:
ratio = -20
quantity_marks = 25
counter = 25
quantity_label = 500
x_constant = 0
y_constant = 403
if ratio == 8:
quantity_marks = 16
while counter <= 400:
milking_canvas.create_line(5, 410 - counter, 15, 410 - counter)
milking_canvas.create_line(16,
410 - counter,
5500,
410 - counter,
fill="light gray")
counter += quantity_marks
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetic 8")
label.place(x=x_constant, y=y_constant - quantity_marks)
quantity_marks += 16
quantity_label += 2
elif ratio == 4:
quantity_marks = 20
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 20
quantity_marks = 25
quantity_label = 5
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=2, y=408 - quantity_marks)
quantity_marks += 20
quantity_label += 5
elif ratio == 2:
quantity_marks = 20
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 20
quantity_marks = 20
quantity_label = 10
while quantity_marks <= 400:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=2, y=403 - quantity_marks)
quantity_marks += 20
quantity_label += 10
elif ratio == 1:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 25
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=2, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 25
elif ratio == -2:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 50
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=2, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 50
elif ratio == -4:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 100
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=0, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 100
elif ratio == -8:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 200
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=0, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 200
elif ratio == -10:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 250
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=0, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 250
elif ratio == -20:
quantity_marks = 25
while quantity_marks <= 400:
milking_canvas.create_line(5, 410 - quantity_marks, 15,
410 - quantity_marks)
milking_canvas.create_line(16,
410 - quantity_marks,
5500,
410 - quantity_marks,
fill="light gray")
quantity_marks += 25
quantity_marks = 25
quantity_label = 500
while quantity_marks <= 410:
label = tk.Label(values_frame,
text=quantity_label,
font="Helvetica 8")
label.place(x=0, y=403 - quantity_marks)
quantity_marks += 25
quantity_label += 500
# display bars on canvas
const_x = 11
const_y = 410
for month in range(1, 13):
for day in range(1, monthrange[str(month)] + 1):
y_m_d = str(
monthrange['CurrentYear']) + "/" + str(month) + "/" + str(day)
try:
if ratio > 0:
milking_canvas.create_rectangle(
const_x,
const_y - (int(events[y_m_d]) * ratio),
const_x + 15,
const_y,
width=0,
fill='green')
else:
milking_canvas.create_rectangle(
const_x,
const_y - (int(events[y_m_d]) / (-ratio)),
const_x + 15,
const_y,
width=0,
fill='green')
const_x += 15
except KeyError:
const_x += 15
else:
pass
# display day marks on x axis
date_marks = 18
for i in range(1, 366):
milking_canvas.create_line(date_marks, 405, date_marks, 415)
date_marks += 15
# display day and month unter day marks on x axis
date_label_x = 7
date_label = tk.Label(dates_frame, text='1/1', font="Helvetica 8")
date_label.place(x=date_label_x, y=0)
month = 2
for i in range(1, 12):
if monthrange[str(i)] == 28:
date_label_x += 28 * 15
date_label = tk.Label(dates_frame,
text='1/' + str(month),
font="Helvetica 8")
date_label.place(x=date_label_x, y=0)
if monthrange[str(i)] == 29:
date_label_x += 29 * 15
date_label = tk.Label(dates_frame,
text='1/' + str(month),
font="Helvetica 8")
date_label.place(x=date_label_x, y=0)
if monthrange[str(i)] == 30:
date_label_x += 30 * 15
date_label = tk.Label(dates_frame,
text='1/' + str(month),
font="Helvetica 8")
date_label.place(x=date_label_x, y=0)
if monthrange[str(i)] == 31:
date_label_x += 31 * 15
date_label = tk.Label(dates_frame,
text='1/' + str(month),
font="Helvetica 8")
date_label.place(x=date_label_x, y=0)
month += 1
def save_pregnancy(date_dict):
"""saves pregnancy event"""
language_dict = set_options.Options()
language_dict.get_text_dict("process_calendar_data")
lang_dict = language_dict.widget_text_dictionary
random_num = random.randint(1, 1000000)
try:
container = open("Calendar.txt", "a")
container.write(str(date_dict['ViewedYear'])+'/' +
str(date_dict['ViewedMonth'])+'/' +
str(date_dict['DayOfTheNewEvent'])+'-' +
"PREGNANCY"+'-'+str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-'+str(random_num)+'\n')
# adds "DELIVERY" event 150 days after "PREGNANCY" event
pregnancy_period = 150
pregnancy_period -= (
date_dict['DaysInViewedMonth'] - date_dict['DayOfTheNewEvent'])
timer = 0
counter = date_dict['DistancefromToday']
while timer <= pregnancy_period:
counter += 1
vase = get_date.get(counter)
timer = vase['DaysInViewedMonth']
if timer == pregnancy_period:
messagebox.showinfo(
lang_dict["messagebox1"], lang_dict["messagebox2"] +
str(vase['ViewedYear'])+'/'+str(vase['ViewedMonth'])+'/' +
str(pregnancy_period)+".")
container.write(
str(vase['ViewedYear'])+'/'+str(vase['ViewedMonth'])+'/' +
str(pregnancy_period)+'-'+"DELIVERY"+'-' +
str(date_dict['Input1'])+'-'+str(date_dict['Input2']) +
'-'+str(random_num)+'\n')
return
pregnancy_period -= timer
if pregnancy_period < 0:
messagebox.showinfo(
lang_dict["messagebox1"], lang_dict["messagebox2"] +
str(vase['ViewedYear'])+'/'+str(vase['ViewedMonth']) +
'/'+str(pregnancy_period+timer)+".")
container.write(
str(vase['ViewedYear'])+'/' + str(vase['ViewedMonth']) +
'/'+str(pregnancy_period+timer)+'-'+"DELIVERY"+'-' +
str(date_dict['Input1'])+'-'+str(date_dict['Input2']) +
'-'+str(random_num)+'\n')
return
if timer > pregnancy_period:
if vase['ViewedMonth']+1 < 12:
messagebox.showinfo(
lang_dict["messagebox1"], lang_dict["messagebox2"] +
str(vase['ViewedYear'])+'/' +
str(vase['ViewedMonth']+1) + '/' +
str(pregnancy_period) + ".")
container.write(
str(vase['ViewedYear'])+'/' +
str(vase['ViewedMonth']+1)+'/' +
str(pregnancy_period)+'-'+"DELIVERY"+'-' +
str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-' +
str(random_num)+'\n')
return
else:
messagebox.showinfo(
lang_dict["messagebox1"], lang_dict["messagebox2"] +
str(vase['ViewedYear']+1)+'/'+str(1)+'/' +
str(pregnancy_period)+".")
container.write(
str(vase['ViewedYear'] + 1)+'/'+str(1)+'/' +
str(pregnancy_period)+'-'+"DELIVERY"+'-' +
str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-' +
str(random_num)+'\n')
except IOError:
messagebox.showinfo(lang_dict["messagebox3"], lang_dict["messagebox4"])
container.close()
else:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox5"])
container.close()
def age_pyramid():
"""
age pyramid with males on left and females on the right.
y axis shows age and x axis shows how many goats share it.
display some additional info.
"""
language_dict = set_options.Options()
language_dict.get_text_dict("charts_tab")
lang_dict = language_dict.widget_text_dictionary
print(lang_dict)
pyramid_window = tk.Toplevel(height=500, width=500)
rows = 0
while rows < 50:
pyramid_window.rowconfigure(rows, weight=1)
pyramid_window.columnconfigure(rows, weight=2)
rows += 1
dead_goats = process_profiles_data.count_parameters("DATE_OF_DEATH")
all_goats = process_profiles_data.count_parameters("profiles")
sold_goats = process_profiles_data.count_parameters("SOLD")
age_of_goats = process_profiles_data.age_of_goats()
all_profiles = process_profiles_data.get_all_profiles()
male_goats = sort_profiles.show(all_profiles, lang_dict["show1"],
lang_dict["show3"])
female_goats = sort_profiles.show(all_profiles, lang_dict["show2"],
lang_dict["show3"])
active_profiles = (all_goats - dead_goats) - sold_goats
goat_per_year = (
age_of_goats['m1'] + age_of_goats['m2'] + age_of_goats['m3'] +
age_of_goats['m4'] + age_of_goats['m5'] + age_of_goats['m6'] +
age_of_goats['m7'] + age_of_goats['m8'] + age_of_goats['m9'] +
age_of_goats['m10'] + age_of_goats['m11'] + age_of_goats['m12'] +
age_of_goats['m13'] + age_of_goats['m14'] + age_of_goats['m15'] +
age_of_goats['f1'] + age_of_goats['f2'] + age_of_goats['f3'] +
age_of_goats['f4'] + age_of_goats['f5'] + age_of_goats['f6'] +
age_of_goats['f7'] + age_of_goats['f8'] + age_of_goats['f9'] +
age_of_goats['f10'] + age_of_goats['f11'] + age_of_goats['f12'] +
age_of_goats['f13'] + age_of_goats['f14'] + age_of_goats['f15'])
label_1 = tk.Label(pyramid_window,
text=lang_dict["label_1"] + str(active_profiles),
font="Helvetica 12")
label_1.grid(row=0, column=0, sticky='w')
label_2 = tk.Label(pyramid_window,
font="Helvetica 12",
text=lang_dict["label_21"] + str(goat_per_year) + '/' +
str(active_profiles) + lang_dict["label_22"])
label_2.grid(row=1, column=0, sticky='w')
label_3 = tk.Label(pyramid_window,
font="Helvetica 12",
text=lang_dict["label_3"] +
str(dead_goats + sold_goats))
label_3.grid(row=2, column=0, sticky='w')
main_frame = tk.Frame(pyramid_window, height=370, width=800, bg="white")
main_frame.grid(row=3, column=0)
label_4 = tk.Label(pyramid_window,
text=lang_dict["label_4"] + str(len(male_goats)),
font="Helvetica 12")
label_4.grid(row=4, column=0, sticky='w')
label_5 = tk.Label(pyramid_window,
text=lang_dict["label_5"] + str(len(female_goats)),
font="Helvetica 12")
label_5.grid(row=5, column=0, sticky='w')
# display values under female_canvas
counter = 2
counter2 = 446
for i in range(1, 13):
label = tk.Label(main_frame,
text=str(counter),
font="Helvetica 10",
bg='white')
if counter < 10:
label.place(x=counter2, y=333)
else:
label.place(x=counter2 - 4, y=333)
counter += 2
counter2 += 30
# display values under male_canvas
counter = 2
counter2 = 42
for i in range(1, 13):
label = tk.Label(main_frame,
text=str(counter),
font="Helvetica 10",
bg='white')
if counter < 10:
label.place(x=385 - counter2, y=333)
else:
label.place(x=385 - counter2 - 4, y=333)
counter += 2
counter2 += 30
male_canvas = tk.Canvas(main_frame, height=305, width=385, bg='white')
male_canvas.place(x=0, y=25)
female_canvas = tk.Canvas(main_frame, height=305, width=385, bg='white')
female_canvas.place(x=415, y=25)
label = tk.Label(main_frame, text="15+", font="Helvetica 12", bg='white')
label.place(x=385, y=25)
counter = 45
counter2 = 14
for i in range(1, 15):
label = tk.Label(main_frame,
text=str(counter2),
font="Helvetica 12",
bg='white')
if counter2 > 9:
label.place(x=390, y=counter)
else:
label.place(x=395, y=counter)
counter += 20
counter2 -= 1
male_label = tk.Label(main_frame,
text=lang_dict["male_label"],
font="Helvetica 12",
bg='white')
male_label.place(x=170, y=0)
female_label = tk.Label(main_frame,
text=lang_dict["female_label"],
font="Helvetica 12",
bg='white')
female_label.place(x=570, y=0)
age_label = tk.Label(main_frame,
text=lang_dict["age_label"],
font="Helvetica 12",
bg='white')
age_label.place(x=385, y=0)
# display stuff on male Canvas
# Y axis
male_canvas.create_line(380, 0, 380, 305)
# X axis
male_canvas.create_line(0, 300, 385, 300)
# display bars on male_canvas
const_1 = 20
const_2 = 0
for i in range(1, 16):
if age_of_goats["m" + str(i)] != 0:
male_canvas.create_rectangle(380 - 15 * age_of_goats["m" + str(i)],
300 - const_1,
380,
300 - const_2,
width=0,
fill='CadetBlue1')
const_1 += 20
const_2 += 20
# display marks on y axis
date_marks = 10
for i in range(1, 16):
male_canvas.create_line(375, date_marks, 385, date_marks)
date_marks += 20
# display marks on x axis (male canvas)
age_marks = 20
for i in range(1, 25):
male_canvas.create_line(385 - age_marks, 295, 385 - age_marks, 305)
male_canvas.create_line(385 - age_marks,
294,
385 - age_marks,
0,
fill="light gray")
age_marks += 15
# display stuff on female Canvas
female_canvas.create_line(7, 0, 7, 305)
female_canvas.create_line(0, 300, 385, 300)
# display bars on female_canvas
const_1 = 20
const_2 = 0
for i in range(1, 16):
if age_of_goats["f" + str(i)] != 0:
female_canvas.create_rectangle(7 + 15 * age_of_goats["f" + str(i)],
300 - const_1,
8,
301 - const_2,
width=0,
fill='pink1')
const_1 += 20
const_2 += 20
# display marks on Y axis (female canvas)
date_marks = 10
for i in range(1, 16):
female_canvas.create_line(0, date_marks, 12, date_marks)
date_marks += 20
# display marks on x axis (female canvas)
age_marks = 22
for i in range(1, 25):
female_canvas.create_line(0 + age_marks, 295, 0 + age_marks, 305)
female_canvas.create_line(0 + age_marks,
294,
0 + age_marks,
0,
fill="light gray")
age_marks += 15
def __init__(self):
"""
create frame visible to all methods call methods containing
widgets
"""
add_prof_frame = tk.Frame()
add_prof_frame.grid(row=0,
column=0,
columnspan=50,
rowspan=50,
sticky="NESW")
language_dict = set_options.Options()
language_dict.get_text_dict("add_profiles_tab")
lang_dict = language_dict.widget_text_dictionary
# BUTTONS
back_button = tk.Button(add_prof_frame,
text=lang_dict["back_button"],
height=2,
width=7,
font="Helvetica 12",
command=add_prof_frame.destroy)
def save():
profile_dict = {
"NAME": name_entry.get(),
"GENDER": gender_var.get(),
"DATE_OF_BIRTH": dob_entry.get(),
"DATE_OF_DEATH": dod_entry.get(),
"ID_NUMBER": id_entry.get(),
"MOTHER": mother_entry.get(),
"FATHER": father_entry.get(),
"CHARACTERISTICS": chara_scrolled.get("1.0", "end-1c"),
"HISTORY_OF_DISEASE": disease_scrolled.get("1.0", "end-1c"),
"SOLD": sold_var.get(),
"SOLD_INFO": sold_info_scrolled.get("1.0", "end-1c"),
"BOUGHT": bought_var.get(),
"BOUGHT_INFO": bought_info_scrolled.get("1.0", "end-1c"),
"MILKING": "",
"FAT_CONTENT": ""
}
if process_profiles_data.save_profile(profile_dict) == "success":
add_prof_frame.destroy()
save_button = tk.Button(add_prof_frame,
text=lang_dict["save_button"],
height=2,
width=7,
font="Helvetica 12",
command=save)
help_button = tk.Button(add_prof_frame,
text=lang_dict["help_button"],
height=1,
width=3,
font="Helvetica 12")
# BUTTONS LAYOUT
back_button.place(x=10, y=10)
save_button.place(x=100, y=10)
help_button.place(x=190, y=27)
# LABELS
name_label = tk.Label(add_prof_frame,
text=lang_dict["name_label"],
font="Helvetica 12")
id_label = tk.Label(add_prof_frame,
text=lang_dict["id_label"],
font="Helvetica 12")
gender_label = tk.Label(add_prof_frame,
text=lang_dict["gender_label"],
font="Helvetica 12")
dob_label = tk.Label(add_prof_frame,
text=lang_dict["dob_label"],
font="Helvetica 12")
dod_label = tk.Label(add_prof_frame,
text=lang_dict["dod_label"],
font="Helvetica 12")
mother_label = tk.Label(add_prof_frame,
text=lang_dict["mother_label"],
font="Helvetica 12")
father_label = tk.Label(add_prof_frame,
text=lang_dict["father_label"],
font="Helvetica 12")
chara_label = tk.Label(add_prof_frame,
text=lang_dict["chara_label"],
font="Helvetica 12")
disease_label = tk.Label(add_prof_frame,
text=lang_dict["disease_label"],
font="Helvetica 12")
sold_label = tk.Label(add_prof_frame,
text=lang_dict["sold_label"],
font="Helvetica 12")
sold_info_label = tk.Label(add_prof_frame,
text=lang_dict["sold_info_label"],
font="Helvetica 12")
bought_label = tk.Label(add_prof_frame,
text=lang_dict["bought_label"],
font="Helvetica 12")
bought_info_label = tk.Label(add_prof_frame,
text=lang_dict["bought_info_label"],
font="Helvetica 12")
# lABELS LAYOUT
name_label.place(x=50, y=80)
id_label.place(x=50, y=120)
gender_label.place(x=50, y=160)
dob_label.place(x=50, y=200)
dod_label.place(x=50, y=240)
mother_label.place(x=50, y=280)
father_label.place(x=50, y=320)
chara_label.place(x=50, y=360)
disease_label.place(x=50, y=455)
sold_label.place(x=50, y=550)
sold_info_label.place(x=50, y=590)
bought_label.place(x=50, y=650)
bought_info_label.place(x=50, y=690)
# ENTRIES
# insert clue about inputed data format and
# then make it disapear after clicking on entry
def name_reset(*args):
if name_entry.get() == lang_dict["name_entry"]:
name_entry.delete(0, tk.END)
name_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
name_entry.insert(0, lang_dict["name_entry"])
name_entry.bind("<Button-1>", name_reset)
id_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
def dob_reset(*args):
if dob_entry.get() == lang_dict["dob_entry"]:
dob_entry.delete(0, tk.END)
dob_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
dob_entry.insert(0, lang_dict["dob_entry"])
dob_entry.bind("<Button-1>", dob_reset)
def dod_reset(*args):
if dod_entry.get() == lang_dict["dod_entry"]:
dod_entry.delete(0, tk.END)
dod_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
dod_entry.insert(0, lang_dict["dod_entry"])
dod_entry.bind("<Button-1>", dod_reset)
def mum_reset(*args):
if mother_entry.get() == lang_dict["mother_entry"]:
mother_entry.delete(0, tk.END)
mother_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
mother_entry.insert(0, lang_dict["mother_entry"])
mother_entry.bind("<Button-1>", mum_reset)
def dad_reset(*args):
if father_entry.get() == lang_dict["father_entry"]:
father_entry.delete(0, tk.END)
father_entry = tk.Entry(add_prof_frame, width=30, font="Helvetica 12")
father_entry.insert(0, lang_dict["father_entry"])
father_entry.bind("<Button-1>", dad_reset)
# ENTRIES LAYOUT
name_entry.place(x=200, y=80)
id_entry.place(x=200, y=120)
dob_entry.place(x=200, y=200)
dod_entry.place(x=200, y=240)
mother_entry.place(x=200, y=280)
father_entry.place(x=200, y=320)
# RADIOBUTTONS
# use radiobuttons to activate or deactivate
# some of the ScrolledText widgets
def sold():
sold_info_scrolled.configure(state=tk.NORMAL)
def not_sold():
sold_info_scrolled.configure(state=tk.DISABLED)
def bought():
bought_info_scrolled.configure(state=tk.NORMAL)
def not_bought():
bought_info_scrolled.configure(state=tk.DISABLED)
# set "not_sold", "not_bought",and "female" gender as default
gender_var = tk.StringVar()
male_radiobutton = tk.Radiobutton(add_prof_frame,
text=lang_dict["male_radiobutton"],
variable=gender_var,
value="male",
font="Helvetica 12")
male_radiobutton.deselect()
female_radiobutton = tk.Radiobutton(
add_prof_frame,
text=lang_dict["female_radiobutton"],
variable=gender_var,
value="female",
font="Helvetica 12")
female_radiobutton.select()
sold_var = tk.StringVar()
sold_radiobutton = tk.Radiobutton(add_prof_frame,
text=lang_dict["sold_radiobutton"],
variable=sold_var,
value="sold",
font="Helvetica 12",
command=sold)
sold_radiobutton.deselect()
not_sold_radiobutton = tk.Radiobutton(
add_prof_frame,
text=lang_dict["not_sold_radiobutton"],
variable=sold_var,
value="not_sold",
font="Helvetica 12",
command=not_sold)
not_sold_radiobutton.select()
bought_var = tk.StringVar()
bought_radiobutton = tk.Radiobutton(
add_prof_frame,
text=lang_dict["bought_radiobutton"],
variable=bought_var,
value="bought",
font="Helvetica 12",
command=bought)
bought_radiobutton.deselect()
not_bought_radiobutton = tk.Radiobutton(
add_prof_frame,
text=lang_dict["not_bought_radiobutton"],
variable=bought_var,
value="not_bought",
font="Helvetica 12",
command=not_bought)
not_bought_radiobutton.select()
# RADIOBUTTONS LAYOUT
male_radiobutton.place(x=200, y=160)
female_radiobutton.place(x=300, y=160)
sold_radiobutton.place(x=200, y=550)
not_sold_radiobutton.place(x=300, y=550)
bought_radiobutton.place(x=200, y=650)
not_bought_radiobutton.place(x=300, y=650)
# SCROLLEDTEXT
# "sold_info_scrolled" and "bought_info_scrolled" disabled by
# default, you can activate and deactivate them with radiobuttons
chara_scrolled = sc.ScrolledText(add_prof_frame,
width=60,
height=4,
font="Helvetica 12")
disease_scrolled = sc.ScrolledText(add_prof_frame,
width=60,
height=4,
font="Helvetica 12")
sold_info_scrolled = sc.ScrolledText(add_prof_frame,
width=60,
height=2,
font="Helvetica 12")
bought_info_scrolled = sc.ScrolledText(add_prof_frame,
width=60,
height=2,
font="Helvetica 12")
bought_info_scrolled.configure(state=tk.DISABLED)
sold_info_scrolled.configure(state=tk.DISABLED)
# SCROLLEDTEXT LAYOUT
chara_scrolled.place(x=200, y=360)
disease_scrolled.place(x=200, y=455)
sold_info_scrolled.place(x=200, y=590)
bought_info_scrolled.place(x=200, y=690)
def __init__(self):
def refresh():
populate_frame(parameters_window, gender_var.get(), dob_var.get(),
milking_var.get(), fat_var.get(), lang_dict)
populate_scroled_frame(parameters_window, pick_prof_spinbox.get(),
sort_prof_spinbox.get(), gender_var.get(),
dob_var.get(), milking_var.get(),
fat_var.get(), lang_dict)
language_dict = set_options.Options()
language_dict.get_text_dict("compare_profiles_tab")
lang_dict = language_dict.widget_text_dictionary
# NEW WINDOW
parameters_window = tk.Toplevel(height=650, width=800)
# LABELS
show_prof_label = tk.Label(parameters_window,
text=lang_dict["show_prof_label"],
font="Helvetica 12")
sort_by_label = tk.Label(parameters_window,
text=lang_dict["sort_by_label"],
font="Helvetica 12")
# SPINBOXES
pick_prof_tuple = (lang_dict["pick_prof_tuple1"],
lang_dict["pick_prof_tuple2"],
lang_dict["pick_prof_tuple3"],
lang_dict["pick_prof_tuple4"],
lang_dict["pick_prof_tuple5"])
pick_prof_spinbox = tk.Spinbox(parameters_window,
font="Helvetica 12",
state="readonly",
width=11,
values=pick_prof_tuple)
sort_prof_tuple = (lang_dict["sort_prof_tuple1"],
lang_dict["sort_prof_tuple2"],
lang_dict["sort_prof_tuple3"],
lang_dict["sort_prof_tuple4"],
lang_dict["sort_prof_tuple5"],
lang_dict["sort_prof_tuple6"],
lang_dict["sort_prof_tuple7"])
sort_prof_spinbox = tk.Spinbox(parameters_window,
font="Helvetica 12",
state="readonly",
width=11,
values=sort_prof_tuple)
# CHECK BOXES
checkbox_label = tk.Label(parameters_window,
text=lang_dict["checkbox_label"],
font="Helvetica 12")
gender_var = tk.StringVar()
gender_checkbutton = tk.Checkbutton(
parameters_window,
text=lang_dict["gender_checkbutton"],
font="Helvetica 12",
variable=gender_var,
onvalue="yes",
offvalue="")
dob_var = tk.StringVar()
dob_checkbutton = tk.Checkbutton(parameters_window,
text=lang_dict["dob_checkbutton"],
font="Helvetica 12",
variable=dob_var,
onvalue="yes",
offvalue="")
milking_var = tk.StringVar()
milking_checkbutton = tk.Checkbutton(
parameters_window,
text=lang_dict["milking_checkbutton"],
font="Helvetica 12",
variable=milking_var,
onvalue="yes",
offvalue="")
fat_var = tk.StringVar()
fat_content_checkbutton = tk.Checkbutton(
parameters_window,
text=lang_dict["fat_checkbutton"],
font="Helvetica 12",
variable=fat_var,
onvalue="yes",
offvalue="")
# BUTTONS
apply_button = tk.Button(parameters_window,
text=lang_dict["apply_button"],
font="Helvetica 12",
height=2,
width=7,
command=refresh)
close_button = tk.Button(parameters_window,
text=lang_dict["close_button"],
font="Helvetica 12",
height=2,
width=7,
command=parameters_window.destroy)
help_button = tk.Button(parameters_window,
text=lang_dict["help_button"],
height=1,
width=3,
font="Helvetica 12")
# LAYOUT
# labels
show_prof_label.place(x=10, y=10)
sort_by_label.place(x=150, y=10)
# spinboxes
pick_prof_spinbox.place(x=10, y=50)
sort_prof_spinbox.place(x=150, y=50)
# checkboxes
checkbox_label.place(x=300, y=10)
gender_checkbutton.place(x=300, y=30)
dob_checkbutton.place(x=300, y=55)
milking_checkbutton.place(x=450, y=30)
fat_content_checkbutton.place(x=450, y=55)
# buttons
apply_button.place(x=600, y=30)
close_button.place(x=710, y=590)
help_button.place(x=550, y=607)
def save_medicine(date_dict):
"""saves medicine event"""
language_dict = set_options.Options()
language_dict.get_text_dict("process_calendar_data")
lang_dict = language_dict.widget_text_dictionary
random_num = random.randint(1, 1000000)
try:
container = open("Calendar.txt", "a")
dosing_days_counter = date_dict['Input3']
medicine_counter = 0
day_counter = 0
def add_withdrawal(year, month, day, days_in_month, months_in_future):
day_counter = 0
withdrawal_counter = 1
withdrawal_days_counter = date_dict['Input4']
while withdrawal_days_counter > 0:
if day+withdrawal_counter <= days_in_month:
container.write(
str(year)+'/'+str(month)+'/' +
str(day+withdrawal_counter)+'-'+"WITHDRAWAL" +
'-'+str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-'+str(date_dict['Input3']) +
'-'+str(date_dict['Input4'] + 1 - withdrawal_counter) +
'-'+str(date_dict['Input5'])+'-'+str(random_num)+'\n')
withdrawal_counter += 1
withdrawal_days_counter -= 1
else:
vase = get_date.get(months_in_future+1)
container.write(
str(vase['ViewedYear'])+'/'+str(vase['ViewedMonth']) +
'/'+str(1+day_counter)+'-'+"WITHDRAWAL"+'-' +
str(date_dict['Input1'])+'-'+str(date_dict['Input2']) +
'-'+str(date_dict['Input3'])+'-' +
str(date_dict['Input4']+1-withdrawal_counter) +
'-'+str(date_dict['Input5'])+'-'+str(random_num)+'\n')
day_counter += 1
withdrawal_counter += 1
withdrawal_days_counter -= 1
while dosing_days_counter > 0:
if(date_dict['DayOfTheNewEvent'] + medicine_counter <=
date_dict['DaysInViewedMonth']):
container.write(
str(date_dict['ViewedYear'])+'/' +
str(date_dict['ViewedMonth'])+'/' +
str(date_dict['DayOfTheNewEvent']+medicine_counter) +
'-'+"MEDICINE"+'-'+str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-' +
str(date_dict['Input3']-medicine_counter) +
'-'+str(date_dict['Input4'])+'-' +
str(date_dict['Input5'])+'-'+str(random_num)+'\n')
if date_dict['Input4'] != 0 and dosing_days_counter == 1:
add_withdrawal(
date_dict['ViewedYear'], date_dict['ViewedMonth'],
date_dict['DayOfTheNewEvent']+medicine_counter,
date_dict['DaysInViewedMonth'], 0)
medicine_counter += 1
dosing_days_counter -= 1
else:
vase = get_date.get(1)
container.write(
str(vase['ViewedYear'])+'/'+str(vase['ViewedMonth'])+'/' +
str(1+day_counter)+'-'+"MEDICINE"+'-' +
str(date_dict['Input1'])+'-'+str(date_dict['Input2'])+'-' +
str(date_dict['Input3']-medicine_counter)+'-' +
str(date_dict['Input4'])+'-'+str(date_dict['Input5'])+'-' +
str(random_num)+'\n')
if date_dict['Input4'] != 0 and dosing_days_counter == 1:
add_withdrawal(
vase['ViewedYear'], vase['ViewedMonth'], 1 +
day_counter, vase['DaysInViewedMonth'], 1)
day_counter += 1
medicine_counter += 1
dosing_days_counter -= 1
def add_withdrawal(year, month, day, days_in_month, months_in_future):
day_counter = 0
withdrawal_counter = 1
withdrawal_days_counter = date_dict['Input4']
while withdrawal_days_counter > 0:
if day+withdrawal_counter <= days_in_month:
container.write(
str(year)+'/'+str(month)+'/' +
str(day+withdrawal_counter)+'-' +
str(date_dict['EventType'])+'-' +
str(date_dict['Input1'])+'-' +
str(date_dict['Input2']) + '-' +
str(date_dict['Input3']-withdrawal_counter)+'-' +
str(date_dict['Input4'])+'-' +
str(date_dict['Input5'])+'-'+str(random_num)+'\n')
withdrawal_counter += 1
withdrawal_days_counter -= 1
else:
vase = get_date.get(months_in_future+1)
container.write(
str(vase['ViewedYear'])+'/' +
str(vase['ViewedMonth']) + '/' +
str(1+day_counter)+'-'+str(date_dict['EventType'])+'-'+
str(date_dict['Input1'])+'-' +
str(date_dict['Input2'])+'-' +
str(date_dict['Input3']-withdrawal_counter)+'-' +
str(date_dict['Input4'])+'-' +
str(date_dict['Input5'])+'-' +
str(random_num)+'\n')
day_counter += 1
withdrawal_counter += 1
withdrawal_days_counter -= 1
except IOError:
messagebox.showinfo(lang_dict["messagebox3"], lang_dict["messagebox4"])
container.close()
else:
messagebox.showinfo(lang_dict["messagebox1"], lang_dict["messagebox5"])
container.close()
def add_event_window(month_counter, day_of_the_event, tab):
language_dict = set_options.Options()
language_dict.get_text_dict("single_day_view")
lang_dict = language_dict.widget_text_dictionary
month_name = process_calendar_data.get_month_name(month_counter)
date_dict = get_date.get(month_counter)
date_dict['DayOfTheNewEvent'] = day_of_the_event
date_dict['DistancefromToday'] = month_counter
single_day_frame = tk.Frame()
single_day_frame.grid(
row=0, column=0, columnspan=50, rowspan=50, sticky="NESW")
def add_pregnancy():
def save_event():
result = check_calendar_input.pregnancy_event(
date_dict, add_mum.get(), add_dad.get())
if result == "success":
pregnancy_window.destroy()
single_day_frame.destroy()
add_event_window(
month_counter, day_of_the_event, tab)
pregnancy_window = tk.Toplevel(height=230, width=320)
mum_label = tk.Label(
pregnancy_window, text=lang_dict["mum_label"], font="Helvetica 12")
mum_label.place(x=10, y=50)
dad_label = tk.Label(
pregnancy_window, text=lang_dict["dad_label"], font="Helvetica 12")
dad_label.place(x=10, y=100)
add_mum = tk.Entry(pregnancy_window, width=20, font="Helvetica 12")
add_mum.place(x=105, y=50)
add_dad = tk.Entry(pregnancy_window, width=20, font="Helvetica 12")
add_dad.place(x=105, y=100)
save = tk.Button(
pregnancy_window, text=lang_dict["save"], height=1, width=6,
font="Helvetica 12", command=save_event)
save.place(x=170, y=190)
close = tk.Button(
pregnancy_window, text=lang_dict["close"], height=1, width=6,
font="Helvetica 12", command=pregnancy_window.destroy)
close.place(x=243, y=190)
def add_medicine():
def save_event():
result = check_calendar_input.medicine_event(
date_dict,
add_treated_goat.get(),
add_medicine_entry.get(),
add_dosing_period.get(),
add_withdrawal_period.get(),
add_note.get('1.0', 'end-1c'))
if result == "success":
medicine_window.destroy()
single_day_frame.destroy()
add_event_window(
month_counter, day_of_the_event, tab)
medicine_window = tk.Toplevel(single_day_frame, height=460, width=390)
treated_goat = tk.Label(
medicine_window, text=lang_dict["treated_goat"],
font="Helvetica 12")
treated_goat.place(x=10, y=10)
add_treated_goat = tk.Entry(
medicine_window, width=35, font="Heletica 12")
add_treated_goat.place(x=10, y=35)
medicine = tk.Label(
medicine_window, text=lang_dict["medicine"], font="Helvetica 12")
medicine.place(x=10, y=75)
add_medicine_entry = tk.Entry(
medicine_window, width=17, font="Helvetica 12")
add_medicine_entry.place(x=170, y=75)
dosing_period = tk.Label(
medicine_window, text=lang_dict["dosing_period"],
font="Helvetica 12")
dosing_period.place(x=10, y=120)
withdrawal_period = tk.Label(
medicine_window, text=lang_dict["withdrawal_period"],
font="Helvetica 12")
withdrawal_period.place(x=10, y=170)
note = tk.Label(
medicine_window, text=lang_dict["note"], font="Helvetica 12")
note.place(x=10, y=220)
add_dosing_period = tk.Entry(
medicine_window, width=5, font="Helvetica 12")
add_dosing_period.place(x=275, y=120)
add_withdrawal_period = tk.Entry(
medicine_window, width=5, font="Helvetica 12")
add_withdrawal_period.place(x=275, y=170)
add_note = sc.ScrolledText(
medicine_window, width=35, height=7, font="Helvetica 12")
add_note.place(x=10, y=245)
save = tk.Button(
medicine_window, text=lang_dict["save"], height=1, width=6,
font="Helvetica 12", command=save_event)
save.place(x=240, y=420)
close = tk.Button(
medicine_window, text=lang_dict["close"], height=1, width=6,
font="Helvetica 12", command=medicine_window.destroy)
close.place(x=313, y=420)
def add_milking():
def save_event():
result = check_calendar_input.milking_event(
date_dict, addMilk.get())
if result == "success":
milkingWindow.destroy()
single_day_frame.destroy()
add_event_window(
month_counter, day_of_the_event, tab)
milkingWindow = tk.Toplevel(single_day_frame, height=175, width=250)
milking = tk.Label(
milkingWindow, text=lang_dict["milking"], font="Helvetica 12")
milking.place(x=10, y=50)
addMilk = tk.Entry(milkingWindow, width=5, font="Helvetica 12")
addMilk.place(x=180, y=50)
save = tk.Button(
milkingWindow, text=lang_dict["save"], height=1, width=6,
font="Helvetica 12", command=save_event)
save.place(x=100, y=135)
close = tk.Button(
milkingWindow, text=lang_dict["close"], height=1, width=6,
font="Helvetica 12", command=milkingWindow.destroy)
close.place(x=173, y=135)
def add_other():
def save_event():
result = check_calendar_input.other_event(
date_dict, addTitle.get(), add_note.get('1.0', 'end-1c'))
if result == "success":
other_window.destroy()
single_day_frame.destroy()
add_event_window(
month_counter, day_of_the_event, tab)
other_window = tk.Toplevel(single_day_frame, height=350, width=390)
title = tk.Label(
other_window, text=lang_dict["title"], font="Helvetica 12")
title.place(x=10, y=50)
note = tk.Label(
other_window, text=lang_dict["note"], font="Helvetica 12")
note.place(x=10, y=100)
addTitle = tk.Entry(other_window, width=15, font="Helvetica 12")
addTitle.place(x=200, y=50)
add_note = sc.ScrolledText(
other_window, width=35, height=7, font="Helvetica 12")
add_note.place(x=10, y=125)
save = tk.Button(
other_window, text=lang_dict["save"], height=1, width=6,
font="Helvetica 12", command=save_event)
save.place(x=240, y=310)
close = tk.Button(
other_window, text=lang_dict["close"], height=1, width=6,
font="Helvetica 12", command=other_window.destroy)
close.place(x=313, y=310)
def help_window():
other_window = tk.Toplevel(single_day_frame, height=100, width=420)
advice = tk.Label(
other_window, text=lang_dict["advice"],
font="Helvetica 12")
advice.place(x=10, y=20)
# kills the day - view frame
# displays reseted month view frame
def backButton():
calendar_tab.Calendar(tab, month_counter)
single_day_frame.destroy()
a = (str(date_dict['ViewedYear']) + "/" + str(date_dict['ViewedMonth'])
+ "/" + str(day_of_the_event))
list__of_events = process_calendar_data.get_event(a)
back = tk.Button(
single_day_frame, text=lang_dict["back"], height=2, width=7,
font="Helvetica 12", command=backButton)
back.place(x=10, y=10)
pregnancy = tk.Button(
single_day_frame, text=lang_dict["pregnancy"], height=2, width=9,
font="Helvetica 12", bg="hot pink", command=add_pregnancy)
pregnancy.place(x=105, y=10)
medicine_button = tk.Button(
single_day_frame, text=lang_dict["medicine_button"], height=2, width=8,
font="Helvetica 12", bg="blue", command=add_medicine)
medicine_button.place(x=215, y=10)
daily_milking = tk.Button(
single_day_frame, text=lang_dict["daily_milking"], height=2, width=10,
font="Helvetica 12", bg="yellow", command=add_milking)
daily_milking.place(x=314, y=10)
other = tk.Button(
single_day_frame, text=lang_dict["other"], height=2, width=7,
font="Helvetica 12", bg="green2", command=add_other)
other.place(x=435, y=10)
help_button = tk.Button(
single_day_frame, text="?", height=1, width=2,
font="Helvetica 12", command=help_window)
help_button.place(x=530, y=28)
date = tk.Label(
single_day_frame, text=str(day_of_the_event) + " " + month_name + " "
+ str(date_dict['ViewedYear']), font="Helvetica 25 bold")
date.place(x=280, y=100)
def reset():
single_day_frame.destroy
calendar_tab.Calendar(tab, month_counter)
if list__of_events:
def onFrameConfigure(canvas):
'''Reset the scroll region to encompass the inner frame'''
canvas.configure(scrollregion=canvas.bbox("all"))
canvas_scrollregion = 100*len(list__of_events)
canvas = tk.Canvas(
single_day_frame, width=760, height=600,
scrollregion=(0, 0, 0, canvas_scrollregion))
canvas.place(x=0, y=180)
vbar = tk.Scrollbar(
single_day_frame, orient=tk.VERTICAL, command=canvas.yview)
vbar.place(x=750, y=180, height=600)
canvas.config(yscrollcommand=vbar.set)
on_canvas_frame = tk.Frame(
canvas, width=696, height=canvas_scrollregion)
on_canvas_frame.place(x=65, y=0)
on_canvas_frame.bind(
"<Configure>",
lambda event, canvas=canvas: onFrameConfigure(canvas))
canvas.create_window((50, 0), window=on_canvas_frame, anchor="nw")
event_numbers = []
for event in range(len(list__of_events)):
single_event = list__of_events[event].split("-")
event_numbers.append(single_event[len(single_event)-1])
def send(event):
answer = messagebox.askquestion(
lang_dict["messagebox"], lang_dict["messagebox1"],
icon='warning')
if answer == "yes":
calculatedEvent = int(event.y/100)
process_calendar_data.delete_event(
event_numbers[calculatedEvent])
single_day_frame.destroy()
add_event_window(
month_counter, day_of_the_event, tab)
on_canvas_frame.bind("<Button-3>", send)
if single_event[1] == "OTHER":
title = tk.Label(
on_canvas_frame, text=single_event[2],
font="Helvetica 12 bold")
else:
title = tk.Label(
on_canvas_frame, text=single_event[1],
font="Helvetica 12 bold")
title.place(x=10, y=event*100+5)
if single_event[1] == "PREGNANCY":
canvas.create_oval(
10, event * 100 + 10, 30, event * 100 + 30,
fill="hot pink")
label = tk.Label(
on_canvas_frame, text=lang_dict["mum_label"] + ": "
+ single_event[2], font="Helvetica 10")
label.place(x=10, y=event * 100 + 30)
label2 = tk.Label(
on_canvas_frame, text=lang_dict["dad_label"] + ": "
+ single_event[3], font="Helvetica 10")
label2.place(x=10, y=event*100+60)
elif single_event[1] == "MEDICINE":
canvas.create_oval(
10, event * 100 + 10, 30, event * 100 + 30,
fill="blue")
label = tk.Label(
on_canvas_frame, text=lang_dict["label"] + single_event[2],
font="Helvetica 10")
label.place(x=100, y=event*100+5)
label2 = tk.Label(
on_canvas_frame, text=lang_dict["medicine_button"] + ": " +
single_event[3], font="Helvetica 10")
label2.place(x=10, y=event*100+30)
# if not empty(0) place label
if int(single_event[4]) != 0:
# if 1 day - singular, if more - plural
if int(single_event[4]) == 1:
label3 = tk.Label(
on_canvas_frame, text=lang_dict["label1"]
+ single_event[4] + lang_dict["label2"],
font="Helvetica 10")
else:
label3 = tk.Label(
on_canvas_frame, text=lang_dict["label1"]
+ single_event[4]+" days left.",
font="Helvetica 10")
label3.place(x=200, y=event * 100 + 30)
# I don't want withdrawal period to be displayed on
# "medicine" event, remove quotation marks to add this
label5 = tk.Label(
on_canvas_frame, text=single_event[6],
font="Helvetica 10", wraplength=680, justify=tk.LEFT)
label5.place(x=10, y=event*100+50)
elif single_event[1] == "MILKING":
canvas.create_oval(
10, event * 100 + 10, 30,
event * 100 + 30, fill="yellow")
label = tk.Label(
on_canvas_frame, text=lang_dict["label3"]
+ single_event[2], font="Helvetica 10")
label.place(x=10, y=event*100+30)
elif single_event[1] == "OTHER":
canvas.create_oval(
10, event * 100 + 10, 30, event * 100 + 30,
fill="green2")
label = tk.Label(
on_canvas_frame, text=single_event[3],
font="Helvetica 10", wraplength=670, justify=tk.LEFT)
label.place(x=10, y=event * 100 + 30)
elif single_event[1] == "DELIVERY":
canvas.create_oval(
10, event * 100 + 10, 30, event * 100 + 30, fill="red")
if single_event[3] != "":
label = tk.Label(
on_canvas_frame,
text=lang_dict["label4"]
+ single_event[2] + " " + lang_dict["label5"]
+ single_event[3] + lang_dict["label6"],
font="Helvetica 10")
label.place(x=10, y=event*100+30)
else:
label = tk.Label(
on_canvas_frame,
text=lang_dict["label4"]
+ single_event[2] + lang_dict["label5"],
font="Helvetica 10")
label.place(x=10, y=event*100+30)
elif single_event[1] == "WITHDRAWAL":
canvas.create_oval(
10, event * 100 + 10, 30, event * 100 + 30,
fill="black")
label = tk.Label(
on_canvas_frame, text=lang_dict["label"] + single_event[2],
font="Helvetica 10")
label.place(x=140, y=event*100+5)
label2 = tk.Label(
on_canvas_frame, text=lang_dict["label7"]
+ single_event[3], font="Helvetica 10")
label2.place(x=10, y=event * 100 + 30)
# if 1 day - singular, if more - plural
if int(single_event[5]) > 1:
label3 = tk.Label(
on_canvas_frame, text=lang_dict["label8"] +
single_event[5] + " days left.", font="Helvetica 10")
else:
label3 = tk.Label(
on_canvas_frame, text=lang_dict["label8"] +
single_event[5] + " day left.", font="Helvetica 10")
label3.place(x=250, y=event*100+30)
label4 = tk.Label(
on_canvas_frame, text=single_event[6],
font="Helvetica 10", wraplength=680, justify=tk.LEFT)
label4.place(x=10, y=event*100+50)
