# -*- coding: utf-8 -*- """ tkcalendar - Calendar and DateEntry widgets for Tkinter Copyright 2017-2019 Juliette Monsel with contributions from: - Neal Probert (https://github.com/nprobert) - arahorn28 (https://github.com/arahorn28) tkcalendar is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. tkcalendar is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . DateEntry widget """ from sys import platform try: import tkinter as tk from tkinter import ttk except ImportError: import Tkinter as tk import ttk from tkcalendar.calendar_ import Calendar # temporary fix for issue #61 and https://bugs.python.org/issue38661 MAPS = {'winnative': {'focusfill': [('readonly', 'focus', 'SystemHighlight')], 'foreground': [('disabled', 'SystemGrayText'), ('readonly', 'focus', 'SystemHighlightText')], 'selectforeground': [('!focus', 'SystemWindowText')], 'fieldbackground': [('readonly', 'SystemButtonFace'), ('disabled', 'SystemButtonFace')], 'selectbackground': [('!focus', 'SystemWindow')]}, 'clam': {'foreground': [('readonly', 'focus', '#ffffff')], 'fieldbackground': [('readonly', 'focus', '#4a6984'), ('readonly', '#dcdad5')], 'background': [('active', '#eeebe7'), ('pressed', '#eeebe7')], 'arrowcolor': [('disabled', '#999999')]}, 'alt': {'fieldbackground': [('readonly', '#d9d9d9'), ('disabled', '#d9d9d9')], 'arrowcolor': [('disabled', '#a3a3a3')]}, 'default': {'fieldbackground': [('readonly', '#d9d9d9'), ('disabled', '#d9d9d9')], 'arrowcolor': [('disabled', '#a3a3a3')]}, 'classic': {'fieldbackground': [('readonly', '#d9d9d9'), ('disabled', '#d9d9d9')]}, 'vista': {'focusfill': [('readonly', 'focus', 'SystemHighlight')], 'foreground': [('disabled', 'SystemGrayText'), ('readonly', 'focus', 'SystemHighlightText')], 'selectforeground': [('!focus', 'SystemWindowText')], 'selectbackground': [('!focus', 'SystemWindow')]}, 'xpnative': {'focusfill': [('readonly', 'focus', 'SystemHighlight')], 'foreground': [('disabled', 'SystemGrayText'), ('readonly', 'focus', 'SystemHighlightText')], 'selectforeground': [('!focus', 'SystemWindowText')], 'selectbackground': [('!focus', 'SystemWindow')]}} class DateEntry(ttk.Entry): """Date selection entry with drop-down calendar.""" entry_kw = {'exportselection': 1, 'invalidcommand': '', 'justify': 'left', 'show': '', 'cursor': 'xterm', 'style': '', 'state': 'normal', 'takefocus': 'ttk::takefocus', 'textvariable': '', 'validate': 'none', 'validatecommand': '', 'width': 12, 'xscrollcommand': ''} def __init__(self, master=None, **kw): """ Create an entry with a drop-down calendar to select a date. When the entry looses focus, if the user input is not a valid date, the entry content is reset to the last valid date. Keyword Options --------------- usual ttk.Entry options and Calendar options. The Calendar option 'cursor' has been renamed 'calendar_cursor' to avoid name clashes with the corresponding ttk.Entry option. Virtual event ------------- A ``<>`` event is generated each time the user selects a date. """ # sort keywords between entry options and calendar options kw['selectmode'] = 'day' entry_kw = {} style = kw.pop('style', 'DateEntry') for key in self.entry_kw: entry_kw[key] = kw.pop(key, self.entry_kw[key]) entry_kw['font'] = kw.get('font', None) self._cursor = entry_kw['cursor'] # entry cursor kw['cursor'] = kw.pop('calendar_cursor', None) ttk.Entry.__init__(self, master, **entry_kw) self._determine_downarrow_name_after_id = '' # drop-down calendar self._top_cal = tk.Toplevel(self) self._top_cal.withdraw() if platform == "linux": self._top_cal.attributes('-type', 'DROPDOWN_MENU') self._top_cal.overrideredirect(True) self._calendar = Calendar(self._top_cal, **kw) self._calendar.pack() # locale date parsing / formatting self.format_date = self._calendar.format_date self.parse_date = self._calendar.parse_date # style self._theme_name = '' # to detect theme changes self.style = ttk.Style(self) self._setup_style() self.configure(style=style) # add validation to Entry so that only dates in the locale's format # are accepted validatecmd = self.register(self._validate_date) self.configure(validate='focusout', validatecommand=validatecmd) # initially selected date self._date = self._calendar.selection_get() if self._date is None: today = self._calendar.date.today() year = kw.get('year', today.year) month = kw.get('month', today.month) day = kw.get('day', today.day) try: self._date = self._calendar.date(year, month, day) except ValueError: self._date = today self._set_text(self.format_date(self._date)) # --- bindings # reconfigure style if theme changed self.bind('<>', lambda e: self.after(10, self._on_theme_change)) # determine new downarrow button bbox self.bind('', self._determine_downarrow_name) self.bind('', self._determine_downarrow_name) # handle appearence to make the entry behave like a Combobox but with # a drop-down calendar instead of a drop-down list self.bind('', lambda e: self.state(['!active'])) self.bind('', self._on_motion) self.bind('', self._on_b1_press) # update entry content when date is selected in the Calendar self._calendar.bind('<>', self._select) # hide calendar if it looses focus self._calendar.bind('', self._on_focus_out_cal) def __getitem__(self, key): """Return the resource value for a KEY given as string.""" return self.cget(key) def __setitem__(self, key, value): self.configure(**{key: value}) def _setup_style(self, event=None): """Style configuration to make the DateEntry look like a Combobbox.""" self.style.layout('DateEntry', self.style.layout('TCombobox')) self.update_idletasks() conf = self.style.configure('TCombobox') if conf: self.style.configure('DateEntry', **conf) maps = self.style.map('TCombobox') if maps: try: self.style.map('DateEntry', **maps) except tk.TclError: # temporary fix for issue #61 and https://bugs.python.org/issue38661 maps = MAPS.get(self.style.theme_use(), MAPS['default']) self.style.map('DateEntry', **maps) try: self.after_cancel(self._determine_downarrow_name_after_id) except ValueError: # nothing to cancel pass self._determine_downarrow_name_after_id = self.after(10, self._determine_downarrow_name) def _determine_downarrow_name(self, event=None): """Determine downarrow button name.""" try: self.after_cancel(self._determine_downarrow_name_after_id) except ValueError: # nothing to cancel pass if self.winfo_ismapped(): self.update_idletasks() y = self.winfo_height() // 2 x = self.winfo_width() - 10 name = self.identify(x, y) if name: self._downarrow_name = name else: self._determine_downarrow_name_after_id = self.after(10, self._determine_downarrow_name) def _on_motion(self, event): """Set widget state depending on mouse position to mimic Combobox behavior.""" x, y = event.x, event.y if 'disabled' not in self.state(): if self.identify(x, y) == self._downarrow_name: self.state(['active']) ttk.Entry.configure(self, cursor='arrow') else: self.state(['!active']) ttk.Entry.configure(self, cursor=self._cursor) def _on_theme_change(self): theme = self.style.theme_use() if self._theme_name != theme: # the theme has changed, update the DateEntry style to look like a combobox self._theme_name = theme self._setup_style() def _on_b1_press(self, event): """Trigger self.drop_down on downarrow button press and set widget state to ['pressed', 'active'].""" x, y = event.x, event.y if (('disabled' not in self.state()) and self.identify(x, y) == self._downarrow_name): self.state(['pressed']) self.drop_down() def _on_focus_out_cal(self, event): """Withdraw drop-down calendar when it looses focus.""" if self.focus_get() is not None: if self.focus_get() == self: x, y = event.x, event.y if (type(x) != int or type(y) != int or self.identify(x, y) != self._downarrow_name): self._top_cal.withdraw() self.state(['!pressed']) else: self._top_cal.withdraw() self.state(['!pressed']) elif self.grab_current(): # 'active' won't be in state because of the grab x, y = self._top_cal.winfo_pointerxy() xc = self._top_cal.winfo_rootx() yc = self._top_cal.winfo_rooty() w = self._top_cal.winfo_width() h = self._top_cal.winfo_height() if xc <= x <= xc + w and yc <= y <= yc + h: # re-focus calendar so that will be triggered next time self._calendar.focus_force() else: self._top_cal.withdraw() self.state(['!pressed']) else: if 'active' in self.state(): # re-focus calendar so that will be triggered next time self._calendar.focus_force() else: self._top_cal.withdraw() self.state(['!pressed']) def _validate_date(self): """Date entry validation: only dates in locale '%x' format are accepted.""" try: date = self.parse_date(self.get()) self._date = self._calendar.check_date_range(date) if self._date != date: self._set_text(self.format_date(self._date)) return False else: return True except (ValueError, IndexError): self._set_text(self.format_date(self._date)) return False def _select(self, event=None): """Display the selected date in the entry and hide the calendar.""" date = self._calendar.selection_get() if date is not None: self._set_text(self.format_date(date)) self._date = date self.event_generate('<>') self._top_cal.withdraw() if 'readonly' not in self.state(): self.focus_set() def _set_text(self, txt): """Insert text in the entry.""" if 'readonly' in self.state(): readonly = True self.state(('!readonly',)) else: readonly = False self.delete(0, 'end') self.insert(0, txt) if readonly: self.state(('readonly',)) def destroy(self): try: self.after_cancel(self._determine_downarrow_name_after_id) except ValueError: # nothing to cancel pass ttk.Entry.destroy(self) def drop_down(self): """Display or withdraw the drop-down calendar depending on its current state.""" if self._calendar.winfo_ismapped(): self._top_cal.withdraw() else: self._validate_date() date = self.parse_date(self.get()) x = self.winfo_rootx() y = self.winfo_rooty() + self.winfo_height() if self.winfo_toplevel().attributes('-topmost'): self._top_cal.attributes('-topmost', True) else: self._top_cal.attributes('-topmost', False) self._top_cal.geometry('+%i+%i' % (x, y)) self._top_cal.deiconify() self._calendar.focus_set() self._calendar.selection_set(date) def state(self, *args): """ Modify or inquire widget state. Widget state is returned if statespec is None, otherwise it is set according to the statespec flags and then a new state spec is returned indicating which flags were changed. statespec is expected to be a sequence. """ if args: # change cursor depending on state to mimic Combobox behavior states = args[0] if 'disabled' in states or 'readonly' in states: self.configure(cursor='arrow') elif '!disabled' in states or '!readonly' in states: self.configure(cursor='xterm') return ttk.Entry.state(self, *args) def keys(self): """Return a list of all resource names of this widget.""" keys = list(self.entry_kw) keys.extend(self._calendar.keys()) keys.append('calendar_cursor') return list(set(keys)) def cget(self, key): """Return the resource value for a KEY given as string.""" if key in self.entry_kw: return ttk.Entry.cget(self, key) elif key == 'calendar_cursor': return self._calendar.cget('cursor') else: return self._calendar.cget(key) def configure(self, cnf={}, **kw): """ Configure resources of a widget. The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method :meth:`~DateEntry.keys`. """ if not isinstance(cnf, dict): raise TypeError("Expected a dictionary or keyword arguments.") kwargs = cnf.copy() kwargs.update(kw) entry_kw = {} keys = list(kwargs.keys()) for key in keys: if key in self.entry_kw: entry_kw[key] = kwargs.pop(key) font = kwargs.get('font', None) if font is not None: entry_kw['font'] = font self._cursor = str(entry_kw.get('cursor', self._cursor)) if entry_kw.get('state') == 'readonly' and self._cursor == 'xterm' and 'cursor' not in entry_kw: entry_kw['cursor'] = 'arrow' self._cursor = 'arrow' ttk.Entry.configure(self, entry_kw) kwargs['cursor'] = kwargs.pop('calendar_cursor', None) self._calendar.configure(kwargs) if 'date_pattern' in kwargs or 'locale' in kwargs: self._set_text(self.format_date(self._date)) config = configure def set_date(self, date): """ Set the value of the DateEntry to date. date can be a datetime.date, a datetime.datetime or a string in locale '%x' format. """ try: txt = self.format_date(date) except AssertionError: txt = str(date) try: self.parse_date(txt) except Exception: raise ValueError("%r is not a valid date." % date) self._set_text(txt) self._validate_date() def get_date(self): """Return the content of the DateEntry as a datetime.date instance.""" self._validate_date() return self.parse_date(self.get())