else/Clock/clock.py

import tkinter
import datetime
import math
import time

COLOR_BACKGROUND = '#000'
COLOR_FONT = '#666'
COLOR_DROPDOWN = '#aaa'
COLOR_DROPDOWN_ACTIVE = '#999'

MODE_CLOCK = 'clock'
MODE_COUNTDOWN = 'countdown'
MODE_STOPWATCH = 'stopwatch'

# Monospace fonts work best
FONT = 'Consolas'

# Used for resizing the clock font to fit the frame.
# For consolas, 1.33333 is a good value. It may differ
# for other fonts
FONT_YX_RATIO = 1.33333

MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
MONTHS_DICT = {'jan':1, 'feb':2, 'mar':3, 'apr':4, 'may':5, 'jun':6, 'jul':7, 'aug':8, 'sep':9, 'oct':10, 'nov':11, 'dec':12}

class Clock:
    def __init__(self):
        self.t = tkinter.Tk()
        self.t.configure(bg=COLOR_BACKGROUND)
        self.mode_methods = {
            MODE_CLOCK: self.build_gui_clock,
            MODE_COUNTDOWN: self.build_gui_countdown,
            MODE_STOPWATCH: self.build_gui_stopwatch,
        }
        self.dropstring = tkinter.StringVar(self.t)
        self.dropstring.trace('w', self.trigger_choose_mode)
        modes = list(self.mode_methods.keys())
        modes.sort(key=lambda x: x.lower())
        self.drop = tkinter.OptionMenu(self.t, self.dropstring, *modes)
        self.drop.configure(relief='flat', bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE, direction='below', highlightthickness=0, anchor='w')
        self.drop.pack(fill='x', anchor='n')
        #self.trigger_choose_mode()

        self.frame_applet = tkinter.Frame(self.t, width=400, height=95, bg=COLOR_BACKGROUND)
        self.frame_applet.pack(side='bottom', anchor='s', expand=True, fill='both')
        self.frame_applet.pack_propagate(0)
        self.frame_applet.grid_propagate(0)

        # tkinter elements belonging to any particular applet.
        # They will be destroyed when switching modes.
        # The dropdown and the frame_applet are not included here.
        self.elements = []

        # Instance is used to keep track of how many times we have
        # swapped modes.
        # This is to make sure that any `self.t.after` loops are broken
        # when we leave that mode.
        self.instance = 0
        
        self.dropstring.set(MODE_CLOCK)

        self.t.mainloop()

    @property
    def mode(self):
        return self.drop.cget('text')


    '''clock
     ######   ###        #####     ######   ### ###
    #######   ###       #######   #######   ### ###
    ###       ###       ### ###   ###       #####
    #######   #######   #######   #######   ### ###
     ######   #######    #####     ######   ### ###
    '''
    def build_gui_clock(self):
        '''
        A clock using the system's local time in 24 hour format.
        '''
        def tick_clock():
            if this_instance != self.instance:
                # used to break the "after" loop
                return
            #now = datetime.datetime.now()
            #now = now.strftime('%H:%M:%S')
            now = time.strftime('%H:%M:%S')
            label_clock.configure(text=now)
            self.t.after(1000, tick_clock)
        
        this_instance = self.instance

        label_clock = tkinter.Label(self.frame_applet, text='x', bg=COLOR_BACKGROUND, fg=COLOR_FONT)
        label_clock.pack(anchor='center', expand=True)
        self.elements.append(label_clock)

        tick_clock()
        self.frame_applet.bind('<Configure>', lambda event: self.resize_widget_font(self.frame_applet, label_clock))
        self.resize_widget_font(self.frame_applet, label_clock)


    '''countdown
     ######    #####    ### ###    #####    #######
    #######   #######   ### ###   #######   #######
    ###       ### ###   ### ###   ### ###     ###  
    #######   #######   #######   ### ###     ###  
     ######    #####     #####    ### ###     ###  
    '''
    def build_gui_countdown(self):
        '''
        A timer with two modes:
        1. "in" - countdown a certain amount of time. Ex "5 hours"
           This mode can be paused and resumed and the timer will pick up where it left off

        2. "until" - countdown until a certain moment. Ex "13 august 2015 15:00"
           In this mode, pausing only affects the display. Resuming the clock will skip to
           maintain the correct end time.
        '''
        def toggle_mode():
            reset_countdown()

            if label_countdown.mode is 'until':
                # "in" mode does not need the dd mmm yyyy boxes
                for item in elements_until:
                    item.grid_forget()
                # "in" mode can have arbitrary hours
                spinbox_hour.configure(to=999)
                label_countdown.mode = 'in'
            else:
                spinbox_day.grid(row=0, column=1)
                spinbox_month.grid(row=0, column=2)
                spinbox_year.grid(row=0, column=3)
                spinbox_hour.configure(to=23)
                label_countdown.mode = 'until'
            button_countdownmode.configure(text=label_countdown.mode)
        
        def tick_countdown():
            if this_instance != self.instance:
                return
            if not label_countdown.is_running:
                return
            
            now = time.time()
            if now > label_countdown.destination:
                reset_countdown()
                return

            until_dest = label_countdown.destination - now
            hours, minutes, seconds = self.hms_divmod(until_dest)
            display = '%02d:%02d:%04.1f' % (hours, minutes, seconds)
            display = display.replace('60.0', '00.0')
            previous_size = len(label_countdown.cget('text'))
            label_countdown.configure(text=display)
            if len(display) != previous_size:
                self.resize_widget_font(frame_display, label_countdown)
            self.t.after(100, tick_countdown)

        def start_countdown():
            if label_countdown.mode is 'until':
                if label_countdown.destination is None:
                    try:
                        d = int(spinbox_day.get())
                        mo = MONTHS_DICT[spinbox_month.get().lower()]
                        y = int(spinbox_year.get())
                        h = int(spinbox_hour.get())
                        m = int(spinbox_minute.get())
                        s = int(spinbox_second.get()) 

                        strp = '%d %s %d %d %d %d' % (d, mo, y, h, m, s)
                        strp = datetime.datetime.strptime(strp, '%d %m %Y %H %M %S')
                        label_countdown.destination = strp.timestamp()
                    except ValueError:
                        return
            else:
                now = time.time()
                if label_countdown.destination is None:
                    try:
                        h = int(spinbox_hour.get())
                        m = int(spinbox_minute.get())
                        s = int(spinbox_second.get())
                        label_countdown.destination = now + (3600*h) + (60*m) + (s)
                    except ValueError:
                        return
                else:
                    # check how long we were paused, then increase the
                    # destination by that much so the countdown doesn't skip.
                    backlog = now - label_countdown.backlog
                    label_countdown.destination += backlog
            label_countdown.is_running = True
            button_toggle.configure(text='stop')
            tick_countdown()

        def stop_countdown():
            # Store the timestamp when the countdown was paused
            # so that when it resumes, we know how long we were asleep
            label_countdown.backlog = time.time()
            label_countdown.is_running = False
            button_toggle.configure(text='start')

        def reset_countdown():
            stop_countdown()
            label_countdown.configure(text='00:00:00.0')
            label_countdown.destination = None
            label_countdown.backlog = 0

        def toggle_countdown():
            if label_countdown.is_running:
                stop_countdown()
            else:
                start_countdown()

        def reset_spinboxes():
            for item in (spinbox_hour, spinbox_minute, spinbox_second, spinbox_day, spinbox_month, spinbox_year):
                item.configure(bg=COLOR_BACKGROUND, fg=COLOR_FONT, buttonbackground=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)
                item.delete(0, 'end')

            spinbox_hour.insert(0, 0)
            spinbox_minute.insert(0, 0)
            spinbox_second.insert(0, 0)
            spinbox_day.insert(0, time.strftime('%d'))
            spinbox_month.insert(0, time.strftime('%b').lower())
            spinbox_year.insert(0, time.strftime('%Y'))

        this_instance = self.instance

        elements_until = []

        frame_display = tkinter.Frame(self.frame_applet, bg=COLOR_BACKGROUND)
        frame_controls = tkinter.Frame(self.frame_applet, bg=COLOR_BACKGROUND)
        frame_spinboxes = tkinter.Frame(frame_controls, bg=COLOR_BACKGROUND)
        label_countdown = tkinter.Label(frame_display, text='00:00:00.0', bg=COLOR_BACKGROUND, fg=COLOR_FONT)
        # Although this says 'until', the applet will start in
        # 'in' mode because I use the toggle towards the end to
        # jog everything into place.
        label_countdown.mode = 'until'
        label_countdown.destination = None
        label_countdown.backlog = 0
        label_countdown.is_running = False
        button_countdownmode = tkinter.Button(frame_controls, text='0', command=toggle_mode, bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)
        button_countdownmode.configure(width=5)
        button_toggle = tkinter.Button(frame_controls, text='start', command=toggle_countdown, bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)
        button_reset = tkinter.Button(frame_controls, text='reset', command=reset_countdown, bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)

        spinbox_hour = tkinter.Spinbox(frame_spinboxes, from_=0, to=999, width=3)
        spinbox_minute = tkinter.Spinbox(frame_spinboxes, from_=0, to=59, width=2)
        spinbox_second = tkinter.Spinbox(frame_spinboxes, from_=0, to=59, width=2)
        
        spinbox_day = tkinter.Spinbox(frame_spinboxes, from_=0, to=31, width=2)
        spinbox_month = tkinter.Spinbox(frame_spinboxes, values=MONTHS, width=4)
        spinbox_year = tkinter.Spinbox(frame_spinboxes, from_=2015, to=9999, width=4)

        reset_spinboxes()

        self.frame_applet.rowconfigure(0, weight=1)
        self.frame_applet.columnconfigure(0, weight=1)
        frame_controls.columnconfigure(1, weight=1)

        frame_display.grid(row=0, column=0, sticky='news')
        label_countdown.pack(anchor='center', expand=True)

        frame_controls.grid(row=1, column=0, sticky='ew')
        button_countdownmode.grid(row=0, column=0, sticky='ew')
        frame_spinboxes.grid(row=0, column=1, sticky='ew')
        spinbox_hour.grid(row=0, column=4)
        spinbox_minute.grid(row=0, column=5)
        spinbox_second.grid(row=0, column=6)
        # the day month year spinboxes are gridded
        # during the toggle_mode method.
        button_reset.grid(row=0, column=7)
        button_toggle.grid(row=0, column=8)

        self.elements.append(frame_display)
        self.elements.append(label_countdown)        
        self.elements.append(frame_controls)
        self.elements.append(button_countdownmode)
        self.elements.append(button_toggle)
        self.elements.append(button_reset)
        self.elements.append(frame_spinboxes)
        self.elements.append(spinbox_hour)
        self.elements.append(spinbox_minute)
        self.elements.append(spinbox_second)
        self.elements.append(spinbox_day)
        self.elements.append(spinbox_month)
        self.elements.append(spinbox_year)

        elements_until.append(spinbox_day)
        elements_until.append(spinbox_month)
        elements_until.append(spinbox_year)

        toggle_mode()
        self.frame_applet.bind('<Configure>', lambda event: self.resize_widget_font(frame_display, label_countdown))
        self.t.update()
        self.resize_widget_font(frame_display, label_countdown)


    '''stopwatch
      #####   #######    #####    ###### 
    #######   #######   #######   ### ###
      ###       ###     ### ###   ###### 
    #######     ###     #######   ###    
    #####       ###      #####    ###    
    '''
    def build_gui_stopwatch(self):
        '''
        A timer that counts upward from 0.
        '''
        def tick_stopwatch():
            if this_instance != self.instance:
                return
            if not label_stopwatch.is_running:
                return

            # started_at is reset on every press of the resume button
            # so we keep track of how much was on the clock last time
            # and add it.
            elapsed = time.time() - label_stopwatch.started_at
            elapsed += label_stopwatch.backlog

            hours, minutes, seconds = self.hms_divmod(elapsed)
            #seconds, centi = divmod(seconds, 100)
            display = '%02d:%02d:%06.3f' % (hours, minutes, seconds)
            display = display.replace('60.0', '00.0')
            previous_size = len(label_stopwatch.cget('text'))
            label_stopwatch.configure(text=display)
            if len(display) != previous_size:
                self.resize_widget_font(frame_display, label_stopwatch)
            self.t.after(10, tick_stopwatch)

        def toggle_stopwatch():
            if label_stopwatch.is_running:
                stop_stopwatch()
            else:
                start_stopwatch()

        def stop_stopwatch():
            if label_stopwatch.started_at is not None:
                # This check is important in case we press the "reset"
                # button without having started the clock yet.
                elapsed = time.time() - label_stopwatch.started_at
                # Keep track of how long the clock ran so we can
                # pick up from here when we resume.
                label_stopwatch.backlog += elapsed
            label_stopwatch.started_at = None
            label_stopwatch.is_running = False
            button_toggle.configure(text='start')
        
        def start_stopwatch():
            label_stopwatch.started_at = time.time()
            label_stopwatch.is_running = True
            button_toggle.configure(text='stop')
            tick_stopwatch()

        def reset_stopwatch():
            stop_stopwatch()
            label_stopwatch.backlog = 0
            label_stopwatch.configure(text='00:00:00.000')

        this_instance = self.instance

        frame_display = tkinter.Frame(self.frame_applet, bg=COLOR_BACKGROUND)
        frame_controls = tkinter.Frame(self.frame_applet, bg=COLOR_BACKGROUND)
        label_stopwatch = tkinter.Label(frame_display, text='00:00:00.000', bg=COLOR_BACKGROUND, fg=COLOR_FONT)
        label_stopwatch.started_at = None
        # Backlog keeps track of how much time was on the watch when we stopped it
        # So when we start it again, the counter starts from 0 and we add the backlog
        # to get a total.
        label_stopwatch.backlog = 0
        label_stopwatch.is_running = False
        button_toggle = tkinter.Button(frame_controls, text='start', command=toggle_stopwatch, bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)
        button_reset = tkinter.Button(frame_controls, text='reset', command=reset_stopwatch, bg=COLOR_DROPDOWN, activebackground=COLOR_DROPDOWN_ACTIVE)

        self.frame_applet.rowconfigure(0, weight=1)
        self.frame_applet.columnconfigure(0, weight=1)
        frame_display.grid(row=0, column=0, sticky='news')
        label_stopwatch.pack(anchor='center', expand=True)

        frame_controls.grid(row=1, column=0, sticky='ew')
        frame_controls.columnconfigure(0, weight=1)
        frame_controls.columnconfigure(1, weight=1)
        button_toggle.grid(row=0, column=1, sticky='ew')
        button_reset.grid(row=0, column=0, sticky='ew')
        
        self.elements.append(frame_display)
        self.elements.append(frame_controls)
        self.elements.append(label_stopwatch)
        self.elements.append(button_toggle)
        self.elements.append(button_reset)

        self.frame_applet.bind('<Configure>', lambda event: self.resize_widget_font(frame_display, label_stopwatch))
        # Update so that the window width and height are correct
        # when we call resize_widget_font
        self.t.update()
        self.resize_widget_font(frame_display, label_stopwatch)


    '''other
     #####    #######   ### ###   #######   ###### 
    #######   #######   ### ###   #####     ### ###
    ### ###     ###     #######   ###       ###### 
    #######     ###     ### ###   #####     ### ###
     #####      ###     ### ###   #######   ### ###
    '''

    def delete_applet_elements(self):
        self.frame_applet.unbind('<Configure>')
        for x in range(len(self.elements)):
            self.elements.pop().destroy()
        self.frame_applet.rowconfigure(0, weight=0)
        self.frame_applet.columnconfigure(0, weight=0)

    def resize_widget_font(self, parent, subordinate):
        '''
        Given a frame and a subordinate widget, resize the font of the
        widget to best fit the bounds of the frame.
        '''
        # When initializing the widgets, the width and height is usually 1, 1.
        # Must use t.update to fix everything.
        self.t.update()
        frame_w = parent.winfo_width()
        frame_h = parent.winfo_height()
        #print(frame_w, frame_h)
        text = subordinate.cget('text')
        font = self.font_by_pixels(frame_w, frame_h, text)

        subordinate.configure(font=font)

    def font_by_pixels(self, frame_w, frame_h, text):
        '''
        Given the size of a bounding box, find the best font size
        to fit text in the bounds.
        '''
        lines = text.split('\n')
        label_w = max(len(line) for line in lines)
        label_h = len(lines)

        # Padding to not look dumb
        frame_h -= 20

        # At 72 ppi, 1 point = 1 pixel height
        point_heightbased = int(frame_h / label_h)
        # but width requires involving the ratio
        point_widthbased = int(frame_w * FONT_YX_RATIO / label_w)

        point_smaller = min(point_widthbased, point_heightbased)
        point_smaller = max(point_smaller, 1)
        font = (FONT, point_smaller)

        return font

    def hms_divmod(self, amount):
        hours, minutes = divmod(amount, 3600)
        minutes, seconds = divmod(minutes, 60)

        return (hours, minutes, seconds)

    def trigger_choose_mode(self, *args):
        '''
        This method is fired when the drop-down menu item is selected.
        It will choose which build_gui method to use based on the value
        of the optionmenu text.
        '''
        mode = self.mode
        self.t.title(mode)
        method = self.mode_methods[mode]
        self.instance += 1
        self.delete_applet_elements()
        method()

c = Clock()