623 lines
20 KiB
Python
623 lines
20 KiB
Python
# Geraldo 20190506
|
|
# File originale nel repository di ActiveState su GitBub
|
|
# https://github.com/ActiveState/code/tree/master/recipes/Python/580725_Tkinter_Datepicker_like_jQuery_UI
|
|
|
|
# Log modifiche rispetto all'originale:
|
|
# -------------------------------------
|
|
# 20190506
|
|
# - Trim trailing space
|
|
# - Code style yapf->PEP8
|
|
|
|
# ----------------------------------------------------------------------------------------------------------
|
|
|
|
# Author: Miguel Martinez Lopez
|
|
#
|
|
# Version: 1.0.7
|
|
#
|
|
# Uncomment the next line to see my email
|
|
# print("Author's email: %s"%"61706c69636163696f6e616d656469646140676d61696c2e636f6d".decode("hex")) # noqa
|
|
"""
|
|
These are the default bindings:
|
|
Click button 1 on entry: Show calendar
|
|
Click button 1 outsite calendar and entry: Hide calendar
|
|
Escape: Hide calendar
|
|
CTRL + PAGE UP: Move to the previous month.
|
|
CTRL + PAGE DOWN: Move to the next month.
|
|
CTRL + SHIFT + PAGE UP: Move to the previous year.
|
|
CTRL + SHIFT + PAGE DOWN: Move to the next year.
|
|
CTRL + LEFT: Move to the previous day.
|
|
CTRL + RIGHT: Move to the next day.
|
|
CTRL + UP: Move to the previous week.
|
|
CTRL + DOWN: Move to the next week.
|
|
CTRL + END: Close the datepicker and erase the date.
|
|
CTRL + HOME: Move to the current month.
|
|
CTRL + SPACE: Show date on calendar
|
|
CTRL + Return: Set current selection to entry
|
|
"""
|
|
|
|
import calendar
|
|
import datetime
|
|
|
|
try:
|
|
import Tkinter
|
|
import tkFont
|
|
import ttk
|
|
|
|
from Tkconstants import CENTER, LEFT, N, E, W, S
|
|
from Tkinter import StringVar
|
|
except ImportError: # py3k
|
|
import tkinter as Tkinter
|
|
import tkinter.font as tkFont
|
|
import tkinter.ttk as ttk
|
|
|
|
from tkinter.constants import CENTER, LEFT, N, E, W, S
|
|
from tkinter import StringVar
|
|
|
|
|
|
def get_calendar(locale, fwday):
|
|
# instantiate proper calendar class
|
|
if locale is None:
|
|
return calendar.TextCalendar(fwday)
|
|
else:
|
|
return calendar.LocaleTextCalendar(fwday, locale)
|
|
|
|
|
|
class Calendar(ttk.Frame):
|
|
datetime = calendar.datetime.datetime
|
|
timedelta = calendar.datetime.timedelta
|
|
|
|
def __init__(self,
|
|
master=None,
|
|
year=None,
|
|
month=None,
|
|
firstweekday=calendar.MONDAY,
|
|
locale=None,
|
|
activebackground='#b1dcfb',
|
|
activeforeground='black',
|
|
selectbackground='#003eff',
|
|
selectforeground='white',
|
|
command=None,
|
|
borderwidth=1,
|
|
relief="solid",
|
|
on_click_month_button=None):
|
|
"""
|
|
WIDGET OPTIONS
|
|
|
|
locale, firstweekday, year, month, selectbackground,
|
|
selectforeground, activebackground, activeforeground,
|
|
command, borderwidth, relief, on_click_month_button
|
|
"""
|
|
|
|
if year is None:
|
|
year = self.datetime.now().year
|
|
|
|
if month is None:
|
|
month = self.datetime.now().month
|
|
|
|
self._selected_date = None
|
|
|
|
self._sel_bg = selectbackground
|
|
self._sel_fg = selectforeground
|
|
|
|
self._act_bg = activebackground
|
|
self._act_fg = activeforeground
|
|
|
|
self.on_click_month_button = on_click_month_button
|
|
|
|
self._selection_is_visible = False
|
|
self._command = command
|
|
|
|
ttk.Frame.__init__(
|
|
self, master, borderwidth=borderwidth, relief=relief)
|
|
|
|
self.bind("<FocusIn>",
|
|
lambda event: self.event_generate('<<DatePickerFocusIn>>'))
|
|
self.bind("<FocusOut>",
|
|
lambda event: self.event_generate('<<DatePickerFocusOut>>'))
|
|
|
|
self._cal = get_calendar(locale, firstweekday)
|
|
|
|
# custom ttk styles
|
|
style = ttk.Style()
|
|
style.layout('L.TButton', ([('Button.focus', {
|
|
'children': [('Button.leftarrow', None)]
|
|
})]))
|
|
style.layout('R.TButton', ([('Button.focus', {
|
|
'children': [('Button.rightarrow', None)]
|
|
})]))
|
|
|
|
self._font = tkFont.Font()
|
|
|
|
self._header_var = StringVar()
|
|
|
|
# header frame and its widgets
|
|
hframe = ttk.Frame(self)
|
|
lbtn = ttk.Button(
|
|
hframe, style='L.TButton', command=self._on_press_left_button)
|
|
lbtn.pack(side=LEFT)
|
|
|
|
self._header = ttk.Label(
|
|
hframe, width=15, anchor=CENTER, textvariable=self._header_var)
|
|
self._header.pack(side=LEFT, padx=12)
|
|
|
|
rbtn = ttk.Button(
|
|
hframe, style='R.TButton', command=self._on_press_right_button)
|
|
rbtn.pack(side=LEFT)
|
|
hframe.grid(columnspan=7, pady=4)
|
|
|
|
self._day_labels = {}
|
|
|
|
days_of_the_week = self._cal.formatweekheader(3).split()
|
|
|
|
for i, day_of_the_week in enumerate(days_of_the_week):
|
|
Tkinter.Label(
|
|
self, text=day_of_the_week, background='grey90').grid(
|
|
row=1, column=i, sticky=N + E + W + S)
|
|
|
|
for i in range(6):
|
|
for j in range(7):
|
|
self._day_labels[i, j] = label = Tkinter.Label(
|
|
self, background="white")
|
|
|
|
label.grid(row=i + 2, column=j, sticky=N + E + W + S)
|
|
label.bind("<Enter>",
|
|
lambda event: event.widget.configure(
|
|
background=self._act_bg,
|
|
foreground=self._act_fg))
|
|
label.bind(
|
|
"<Leave>",
|
|
lambda event: event.widget.configure(background="white"))
|
|
|
|
label.bind("<1>", self._pressed)
|
|
|
|
# adjust its columns width
|
|
font = tkFont.Font()
|
|
maxwidth = max(font.measure(text) for text in days_of_the_week)
|
|
for i in range(7):
|
|
self.grid_columnconfigure(i, minsize=maxwidth, weight=1)
|
|
|
|
self._year = None
|
|
self._month = None
|
|
|
|
# insert dates in the currently empty calendar
|
|
self._build_calendar(year, month)
|
|
|
|
def _build_calendar(self, year, month):
|
|
if not (self._year == year and self._month == month):
|
|
self._year = year
|
|
self._month = month
|
|
|
|
# update header text (Month, YEAR)
|
|
header = self._cal.formatmonthname(year, month, 0)
|
|
self._header_var.set(header.title())
|
|
|
|
# update calendar shown dates
|
|
cal = self._cal.monthdayscalendar(year, month)
|
|
|
|
for i in range(len(cal)):
|
|
|
|
week = cal[i]
|
|
fmt_week = [('%02d' % day) if day else '' for day in week]
|
|
|
|
for j, day_number in enumerate(fmt_week):
|
|
self._day_labels[i, j]["text"] = day_number
|
|
|
|
if len(cal) < 6:
|
|
for j in range(7):
|
|
self._day_labels[5, j]["text"] = ""
|
|
|
|
if (self._selected_date is not None
|
|
and self._selected_date.year == self._year
|
|
and self._selected_date.month == self._month):
|
|
self._show_selection()
|
|
|
|
def _find_label_coordinates(self, date):
|
|
first_weekday_of_the_month = (date.weekday() - date.day) % 7
|
|
|
|
return divmod(
|
|
(first_weekday_of_the_month - self._cal.firstweekday) % 7 +
|
|
date.day, 7)
|
|
|
|
def _show_selection(self):
|
|
"""Show a new selection."""
|
|
|
|
i, j = self._find_label_coordinates(self._selected_date)
|
|
|
|
label = self._day_labels[i, j]
|
|
|
|
label.configure(background=self._sel_bg, foreground=self._sel_fg)
|
|
|
|
label.unbind("<Enter>")
|
|
label.unbind("<Leave>")
|
|
|
|
self._selection_is_visible = True
|
|
|
|
def _clear_selection(self):
|
|
"""Show a new selection."""
|
|
i, j = self._find_label_coordinates(self._selected_date)
|
|
|
|
label = self._day_labels[i, j]
|
|
label.configure(background="white", foreground="black")
|
|
|
|
label.bind("<Enter>",
|
|
lambda event: event.widget.configure(
|
|
background=self._act_bg, foreground=self._act_fg))
|
|
label.bind(
|
|
"<Leave>",
|
|
lambda event: event.widget.configure(background="white"))
|
|
|
|
self._selection_is_visible = False
|
|
|
|
# Callback
|
|
|
|
def _pressed(self, evt):
|
|
"""Clicked somewhere in the calendar."""
|
|
|
|
text = evt.widget["text"]
|
|
|
|
if text == "":
|
|
return
|
|
|
|
day_number = int(text)
|
|
|
|
new_selected_date = datetime.datetime(self._year, self._month,
|
|
day_number)
|
|
if self._selected_date != new_selected_date:
|
|
if self._selected_date is not None:
|
|
self._clear_selection()
|
|
|
|
self._selected_date = new_selected_date
|
|
|
|
self._show_selection()
|
|
|
|
if self._command:
|
|
self._command(self._selected_date)
|
|
|
|
def _on_press_left_button(self):
|
|
self.prev_month()
|
|
|
|
if self.on_click_month_button is not None:
|
|
self.on_click_month_button()
|
|
|
|
def _on_press_right_button(self):
|
|
self.next_month()
|
|
|
|
if self.on_click_month_button is not None:
|
|
self.on_click_month_button()
|
|
|
|
def select_prev_day(self):
|
|
"""Updated calendar to show the previous day."""
|
|
if self._selected_date is None:
|
|
self._selected_date = datetime.datetime(self._year, self._month, 1)
|
|
else:
|
|
self._clear_selection()
|
|
self._selected_date = self._selected_date - self.timedelta(days=1)
|
|
|
|
self._build_calendar(
|
|
self._selected_date.year,
|
|
self._selected_date.month) # reconstruct calendar
|
|
|
|
def select_next_day(self):
|
|
"""Update calendar to show the next day."""
|
|
|
|
if self._selected_date is None:
|
|
self._selected_date = datetime.datetime(self._year, self._month, 1)
|
|
else:
|
|
self._clear_selection()
|
|
self._selected_date = self._selected_date + self.timedelta(days=1)
|
|
|
|
self._build_calendar(
|
|
self._selected_date.year,
|
|
self._selected_date.month) # reconstruct calendar
|
|
|
|
def select_prev_week_day(self):
|
|
"""Updated calendar to show the previous week."""
|
|
if self._selected_date is None:
|
|
self._selected_date = datetime.datetime(self._year, self._month, 1)
|
|
else:
|
|
self._clear_selection()
|
|
self._selected_date = self._selected_date - self.timedelta(days=7)
|
|
|
|
self._build_calendar(
|
|
self._selected_date.year,
|
|
self._selected_date.month) # reconstruct calendar
|
|
|
|
def select_next_week_day(self):
|
|
"""Update calendar to show the next week."""
|
|
if self._selected_date is None:
|
|
self._selected_date = datetime.datetime(self._year, self._month, 1)
|
|
else:
|
|
self._clear_selection()
|
|
self._selected_date = self._selected_date + self.timedelta(days=7)
|
|
|
|
self._build_calendar(
|
|
self._selected_date.year,
|
|
self._selected_date.month) # reconstruct calendar
|
|
|
|
def select_current_date(self):
|
|
"""Update calendar to current date."""
|
|
if self._selection_is_visible:
|
|
self._clear_selection()
|
|
|
|
self._selected_date = datetime.datetime.now()
|
|
self._build_calendar(self._selected_date.year,
|
|
self._selected_date.month)
|
|
|
|
def prev_month(self):
|
|
"""Updated calendar to show the previous week."""
|
|
if self._selection_is_visible:
|
|
self._clear_selection()
|
|
|
|
date = self.datetime(self._year, self._month,
|
|
1) - self.timedelta(days=1)
|
|
self._build_calendar(date.year, date.month) # reconstuct calendar
|
|
|
|
def next_month(self):
|
|
"""Update calendar to show the next month."""
|
|
if self._selection_is_visible:
|
|
self._clear_selection()
|
|
|
|
date = self.datetime(self._year, self._month, 1) + self.timedelta(
|
|
days=calendar.monthrange(self._year, self._month)[1] + 1)
|
|
|
|
self._build_calendar(date.year, date.month) # reconstuct calendar
|
|
|
|
def prev_year(self):
|
|
"""Updated calendar to show the previous year."""
|
|
|
|
if self._selection_is_visible:
|
|
self._clear_selection()
|
|
|
|
self._build_calendar(self._year - 1,
|
|
self._month) # reconstruct calendar
|
|
|
|
def next_year(self):
|
|
"""Update calendar to show the next year."""
|
|
|
|
if self._selection_is_visible:
|
|
self._clear_selection()
|
|
|
|
self._build_calendar(self._year + 1,
|
|
self._month) # reconstruct calendar
|
|
|
|
def get_selection(self):
|
|
"""Return a datetime representing the current selected date."""
|
|
return self._selected_date
|
|
|
|
selection = get_selection
|
|
|
|
def set_selection(self, date):
|
|
"""Set the selected date."""
|
|
if self._selected_date is not None and self._selected_date != date:
|
|
self._clear_selection()
|
|
|
|
self._selected_date = date
|
|
|
|
self._build_calendar(date.year, date.month) # reconstruct calendar
|
|
|
|
|
|
# see this URL for date format information:
|
|
# https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior
|
|
|
|
|
|
class Datepicker(ttk.Entry):
|
|
def __init__(self,
|
|
master,
|
|
entrywidth=None,
|
|
entrystyle=None,
|
|
datevar=None,
|
|
dateformat="%Y-%m-%d",
|
|
onselect=None,
|
|
firstweekday=calendar.MONDAY,
|
|
locale=None,
|
|
activebackground='#b1dcfb',
|
|
activeforeground='black',
|
|
selectbackground='#003eff',
|
|
selectforeground='white',
|
|
borderwidth=1,
|
|
relief="solid"):
|
|
|
|
if datevar is not None:
|
|
self.date_var = datevar
|
|
else:
|
|
self.date_var = Tkinter.StringVar()
|
|
|
|
entry_config = {}
|
|
if entrywidth is not None:
|
|
entry_config["width"] = entrywidth
|
|
|
|
if entrystyle is not None:
|
|
entry_config["style"] = entrystyle
|
|
|
|
ttk.Entry.__init__(
|
|
self, master, textvariable=self.date_var, **entry_config)
|
|
|
|
self.date_format = dateformat
|
|
|
|
self._is_calendar_visible = False
|
|
self._on_select_date_command = onselect
|
|
|
|
self.calendar_frame = Calendar(
|
|
self.winfo_toplevel(),
|
|
firstweekday=firstweekday,
|
|
locale=locale,
|
|
activebackground=activebackground,
|
|
activeforeground=activeforeground,
|
|
selectbackground=selectbackground,
|
|
selectforeground=selectforeground,
|
|
command=self._on_selected_date,
|
|
on_click_month_button=lambda: self.focus())
|
|
|
|
self.bind_all("<1>", self._on_click, "+")
|
|
|
|
self.bind("<FocusOut>", lambda event: self._on_entry_focus_out())
|
|
self.bind("<Escape>", lambda event: self.hide_calendar())
|
|
self.calendar_frame.bind("<<DatePickerFocusOut>>",
|
|
lambda event: self._on_calendar_focus_out())
|
|
|
|
# CTRL + PAGE UP: Move to the previous month.
|
|
self.bind("<Control-Prior>",
|
|
lambda event: self.calendar_frame.prev_month())
|
|
|
|
# CTRL + PAGE DOWN: Move to the next month.
|
|
self.bind("<Control-Next>",
|
|
lambda event: self.calendar_frame.next_month())
|
|
|
|
# CTRL + SHIFT + PAGE UP: Move to the previous year.
|
|
self.bind("<Control-Shift-Prior>",
|
|
lambda event: self.calendar_frame.prev_year())
|
|
|
|
# CTRL + SHIFT + PAGE DOWN: Move to the next year.
|
|
self.bind("<Control-Shift-Next>",
|
|
lambda event: self.calendar_frame.next_year())
|
|
|
|
# CTRL + LEFT: Move to the previous day.
|
|
self.bind("<Control-Left>",
|
|
lambda event: self.calendar_frame.select_prev_day())
|
|
|
|
# CTRL + RIGHT: Move to the next day.
|
|
self.bind("<Control-Right>",
|
|
lambda event: self.calendar_frame.select_next_day())
|
|
|
|
# CTRL + UP: Move to the previous week.
|
|
self.bind("<Control-Up>",
|
|
lambda event: self.calendar_frame.select_prev_week_day())
|
|
|
|
# CTRL + DOWN: Move to the next week.
|
|
self.bind("<Control-Down>",
|
|
lambda event: self.calendar_frame.select_next_week_day())
|
|
|
|
# CTRL + END: Close the datepicker and erase the date.
|
|
self.bind("<Control-End>", lambda event: self.erase())
|
|
|
|
# CTRL + HOME: Move to the current month.
|
|
self.bind("<Control-Home>",
|
|
lambda event: self.calendar_frame.select_current_date())
|
|
|
|
# CTRL + SPACE: Show date on calendar
|
|
self.bind("<Control-space>",
|
|
lambda event: self.show_date_on_calendar())
|
|
|
|
# CTRL + Return: Set to entry current selection
|
|
self.bind("<Control-Return>",
|
|
lambda event: self.set_date_from_calendar())
|
|
|
|
def set_date_from_calendar(self):
|
|
if self.is_calendar_visible:
|
|
selected_date = self.calendar_frame.selection()
|
|
|
|
if selected_date is not None:
|
|
self.date_var.set(selected_date.strftime(self.date_format))
|
|
|
|
if self._on_select_date_command is not None:
|
|
self._on_select_date_command(selected_date)
|
|
|
|
self.hide_calendar()
|
|
|
|
@property
|
|
def current_text(self):
|
|
return self.date_var.get()
|
|
|
|
@current_text.setter
|
|
def current_text(self, text):
|
|
return self.date_var.set(text)
|
|
|
|
@property
|
|
def current_date(self):
|
|
try:
|
|
date = datetime.datetime.strptime(self.date_var.get(),
|
|
self.date_format)
|
|
return date
|
|
except ValueError:
|
|
return None
|
|
|
|
@current_date.setter
|
|
def current_date(self, date):
|
|
self.date_var.set(date.strftime(self.date_format))
|
|
|
|
@property
|
|
def is_valid_date(self):
|
|
if self.current_date is None:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def show_date_on_calendar(self):
|
|
date = self.current_date
|
|
if date is not None:
|
|
self.calendar_frame.set_selection(date)
|
|
|
|
self.show_calendar()
|
|
|
|
def show_calendar(self):
|
|
if not self._is_calendar_visible:
|
|
self.calendar_frame.place(in_=self, relx=0, rely=1)
|
|
self.calendar_frame.lift()
|
|
|
|
self._is_calendar_visible = True
|
|
|
|
def hide_calendar(self):
|
|
if self._is_calendar_visible:
|
|
self.calendar_frame.place_forget()
|
|
|
|
self._is_calendar_visible = False
|
|
|
|
def erase(self):
|
|
self.hide_calendar()
|
|
self.date_var.set("")
|
|
|
|
@property
|
|
def is_calendar_visible(self):
|
|
return self._is_calendar_visible
|
|
|
|
def _on_entry_focus_out(self):
|
|
if not str(self.focus_get()).startswith(str(self.calendar_frame)):
|
|
self.hide_calendar()
|
|
|
|
def _on_calendar_focus_out(self):
|
|
if self.focus_get() != self:
|
|
self.hide_calendar()
|
|
|
|
def _on_selected_date(self, date):
|
|
self.date_var.set(date.strftime(self.date_format))
|
|
self.hide_calendar()
|
|
|
|
if self._on_select_date_command is not None:
|
|
self._on_select_date_command(date)
|
|
|
|
def _on_click(self, event):
|
|
str_widget = str(event.widget)
|
|
|
|
if str_widget == str(self):
|
|
if not self._is_calendar_visible:
|
|
self.show_date_on_calendar()
|
|
else:
|
|
if not str_widget.startswith(str(
|
|
self.calendar_frame)) and self._is_calendar_visible:
|
|
self.hide_calendar()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
try:
|
|
from Tkinter import Tk, Frame, Label
|
|
except ImportError:
|
|
from tkinter import Tk, Frame, Label
|
|
|
|
root = Tk()
|
|
root.geometry("500x600")
|
|
|
|
main = Frame(root, pady=15, padx=15)
|
|
main.pack(expand=True, fill="both")
|
|
|
|
Label(main, justify="left", text=__doc__).pack(anchor="w", pady=(0, 15))
|
|
|
|
Datepicker(main).pack(anchor="w")
|
|
|
|
if 'win' not in sys.platform:
|
|
style = ttk.Style()
|
|
style.theme_use('clam')
|
|
|
|
root.mainloop()
|