348 lines
12 KiB
Python
Executable File
348 lines
12 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
u"""Afficher un chronomètre"""
|
|
|
|
import os, sys, re, subprocess, traceback
|
|
from os import path
|
|
from datetime import date as Date, time as Time
|
|
from datetime import datetime as Datetime, timedelta as Timedelta
|
|
from types import IntType, LongType
|
|
|
|
DEFAULT_SOUND = path.join(path.dirname(__file__), 'lib', 'chrono.wav')
|
|
|
|
def win_playSound(name):
|
|
try: import winsound as s
|
|
except: return
|
|
if name is None:
|
|
s.PlaySound(None, s.SND_ASYNC)
|
|
else:
|
|
scriptdir = path.split(path.abspath(sys.argv[0]))[0]
|
|
soundfile = path.join(scriptdir, name)
|
|
s.PlaySound(soundfile, s.SND_FILENAME + s.SND_ASYNC)
|
|
|
|
def linux_playSound(name):
|
|
subprocess.call(['/usr/bin/aplay', '-Nq', name])
|
|
|
|
def playSound(name=None):
|
|
if os.name == 'nt':
|
|
return win_playSound(name)
|
|
elif sys.platform.startswith('linux'):
|
|
return linux_playSound(name)
|
|
|
|
def isnum(i):
|
|
return type(i) in (IntType, LongType)
|
|
RE_NUM = re.compile(r'\d+$')
|
|
def numof(s):
|
|
if isnum(s): return s
|
|
elif s is None: return None
|
|
elif RE_NUM.match(str(s)) is not None: return int(str(s))
|
|
else: return s
|
|
|
|
DEFAULT_TIMEOUT = '5'
|
|
|
|
RE_DESTHOUR = re.compile(r'@(\d+)(?:[:.](\d+)(?:[:.](\d+))?)?$')
|
|
def parse_desthour(s):
|
|
mo = RE_DESTHOUR.match(s)
|
|
if mo is None: return None
|
|
h, m, s = mo.groups()
|
|
if h is None: h = 0
|
|
if m is None: m = 0
|
|
if s is None: s = 0
|
|
h, m, s = int(h), int(m), int(s)
|
|
src = Datetime.today()
|
|
srcdate = src.date(); srctime = src.time()
|
|
destdate = srcdate; desttime = Time(h, m, s)
|
|
if desttime <= srctime: destdate = destdate + Timedelta(1)
|
|
src = Datetime.combine(srcdate, srctime)
|
|
dest = Datetime.combine(destdate, desttime)
|
|
delta = dest - src
|
|
return delta.total_seconds()
|
|
|
|
RE_TIMEOUT = re.compile(r'(\d+)(?:[:.](\d+)(?:[:.](\d+))?)?$')
|
|
def parse_timeout(s):
|
|
mo = RE_TIMEOUT.match(s)
|
|
if mo is None: return None
|
|
h, m, s = mo.groups()
|
|
if m is None and s is None:
|
|
# M
|
|
m = h
|
|
h = None
|
|
elif s is None:
|
|
# M:S
|
|
s = m
|
|
m = h
|
|
h = None
|
|
else:
|
|
# H:M:S
|
|
pass
|
|
if h is None: h = 0
|
|
if m is None: m = 0
|
|
if s is None: s = 0
|
|
h, m, s = int(h), int(m), int(s)
|
|
return h * 3600 + m * 60 + s
|
|
|
|
class Chrono:
|
|
timeout = None
|
|
date_start = None
|
|
date_end = None
|
|
initial = None
|
|
started = None
|
|
|
|
def __init__(self, timeout=None, start=False):
|
|
self.set_timeout(timeout)
|
|
if start: self.start()
|
|
|
|
def __format(self, delta):
|
|
h = delta.seconds // 3600
|
|
seconds = delta.seconds % 3600
|
|
m = seconds // 60
|
|
s = seconds % 60
|
|
if h > 0: return '%02i:%02i:%02i' % (h, m, s)
|
|
else: return '%02i:%02i' % (m, s)
|
|
|
|
def __delta(self, timeout):
|
|
return Timedelta(seconds=timeout)
|
|
|
|
def set_timeout(self, timeout=None):
|
|
if timeout == '': timeout = None
|
|
if timeout is not None and not isnum(timeout):
|
|
tmp = parse_desthour(str(timeout))
|
|
if tmp is None: tmp = parse_timeout(timeout)
|
|
if tmp is None: tmp = int(timeout) * 60
|
|
timeout = tmp
|
|
if timeout == 0: timeout = None
|
|
self.timeout = timeout
|
|
if timeout is None: self.initial = '00:00'
|
|
else: self.initial = self.__format(self.__delta(timeout))
|
|
|
|
def start(self, timeout=None):
|
|
if timeout is None: timeout = self.timeout
|
|
self.date_start = Datetime.today()
|
|
if timeout is None: self.date_end = None
|
|
else: self.date_end = self.date_start + self.__delta(timeout)
|
|
self.started = True
|
|
|
|
def stop(self):
|
|
self.started = False
|
|
|
|
def is_started(self):
|
|
return self.started
|
|
|
|
def is_end(self):
|
|
return self.started and self.date_end is not None and Datetime.today() >= self.date_end
|
|
|
|
def __repr__(self):
|
|
now = Datetime.today()
|
|
if self.date_end is None: delta = now - self.date_start
|
|
elif now > self.date_end: delta = Timedelta()
|
|
else: delta = self.date_end - now
|
|
return self.__format(delta)
|
|
|
|
def run_chronometre(timeout=None, autostart=False):
|
|
from Tkinter import Tk, Toplevel, Frame, Label, Entry, Button
|
|
import tkMessageBox
|
|
|
|
class Dialog(Toplevel):
|
|
def __init__(self, parent, title=None):
|
|
self.result = None
|
|
self.have_result = False
|
|
|
|
Toplevel.__init__(self, parent)
|
|
self.transient(parent)
|
|
if title: self.title(title)
|
|
self.parent = parent
|
|
|
|
body = Frame(self)
|
|
self.initial_focus = self.body(body)
|
|
body.pack(padx=5, pady=5)
|
|
self.buttonbox()
|
|
self.grab_set()
|
|
if not self.initial_focus: self.initial_focus = self
|
|
self.protocol("WM_DELETE_WINDOW", self.cancel)
|
|
self.geometry("+%d+%d" % (parent.winfo_rootx()+50,
|
|
parent.winfo_rooty()+50))
|
|
self.initial_focus.focus_set()
|
|
self.wait_window(self)
|
|
|
|
def set_result(self, result):
|
|
self.result = result
|
|
self.have_result = True
|
|
|
|
def body(self, master):
|
|
pass
|
|
|
|
def buttonbox(self):
|
|
box = Frame(self)
|
|
w = Button(box, text="OK", width=10, command=self.ok, default='active')
|
|
w.pack(side='left', padx=5, pady=5)
|
|
w = Button(box, text="Annuler", width=10, command=self.cancel)
|
|
w.pack(side='left', padx=5, pady=5)
|
|
self.bind("<Return>", self.ok)
|
|
self.bind("<Escape>", self.cancel)
|
|
box.pack()
|
|
|
|
def ok(self, event=None):
|
|
if not self.validate():
|
|
self.initial_focus.focus_set()
|
|
return
|
|
self.withdraw()
|
|
self.update_idletasks()
|
|
self.apply()
|
|
self.cancel()
|
|
|
|
def cancel(self, event=None):
|
|
self.parent.focus_set()
|
|
self.destroy()
|
|
|
|
def validate(self):
|
|
return True
|
|
|
|
def apply(self):
|
|
pass
|
|
|
|
class Config(Dialog):
|
|
def body(self, master):
|
|
Label(master, text="Nb minutes", padx=20).grid(row=0)
|
|
self.entry = Entry(master)
|
|
self.entry.grid(row=0, column=1)
|
|
return self.entry
|
|
|
|
def apply(self):
|
|
value = self.entry.get()
|
|
if value == "": result = None
|
|
else: result = value
|
|
self.set_result(result)
|
|
|
|
class Application(Frame):
|
|
root = None
|
|
chrono = None
|
|
stop = None
|
|
|
|
def __init__(self, timeout=None, autostart=False, **kw):
|
|
self.chrono = Chrono(timeout)
|
|
self.stop = False
|
|
|
|
root = Tk()
|
|
root.title("Chronomètre")
|
|
root.columnconfigure(0, weight=1)
|
|
root.rowconfigure(0, weight=1)
|
|
root.bind("c", lambda event: self.do_config())
|
|
root.bind("s", lambda event: self.do_start())
|
|
root.bind("q", lambda event: self.quit())
|
|
self.root = root
|
|
|
|
kw.update(master=root)
|
|
Frame.__init__(self, **kw)
|
|
|
|
self.TIME = Label(self, width=10, height=2, text=self.chrono.initial, padx=30, pady=10, font=('Helvetica', 18, "normal"))
|
|
self.START = Button(self, text="Démarrer", command=self.do_start)
|
|
self.CONFIG = Button(self, text="Config", command=self.do_config)
|
|
self.QUIT = Button(self, text="Quitter", command=self.quit)
|
|
|
|
self.grid(column=0, row=0, sticky='nsew')
|
|
self.TIME.grid(column=0, row=0, columnspan=3, sticky='nsew')
|
|
self.START.grid(column=0, row=1, sticky='ew')
|
|
self.CONFIG.grid(column=1, row=1, sticky='ew')
|
|
self.QUIT.grid(column=2, row=1, sticky='ew')
|
|
|
|
self.columnconfigure(0, weight=2)
|
|
self.columnconfigure(1, weight=1)
|
|
self.columnconfigure(2, weight=2)
|
|
self.rowconfigure(0, weight=1)
|
|
|
|
if autostart: self.do_start()
|
|
|
|
def update_time(self):
|
|
chrono = self.chrono
|
|
self.TIME.configure(text=chrono)
|
|
if chrono.is_started():
|
|
if chrono.is_end():
|
|
playSound(DEFAULT_SOUND)
|
|
else:
|
|
self.root.after(300, self.update_time)
|
|
|
|
def do_start(self):
|
|
self.chrono.start()
|
|
self.update_time()
|
|
|
|
def do_config(self):
|
|
chrono = self.chrono
|
|
chrono.stop()
|
|
config = Config(self.root)
|
|
if config.have_result:
|
|
try:
|
|
chrono.set_timeout(config.result)
|
|
self.TIME.configure(text=chrono.initial)
|
|
except:
|
|
traceback.print_exc()
|
|
tkMessageBox.showerror("Valeur invalide", sys.exc_info()[1])
|
|
|
|
Application(timeout, autostart).mainloop()
|
|
|
|
if __name__ == '__main__':
|
|
from argparse import ArgumentParser, HelpFormatter
|
|
if sys.argv[1:2] == ['--compat']:
|
|
# Avec l'argument --compat, désactiver la classe FancyHelpFormatter qui
|
|
# se base sur une API non documentée
|
|
sys.argv = sys.argv[0:1] + sys.argv[2:]
|
|
FancyHelpFormatter = HelpFormatter
|
|
else:
|
|
class FancyHelpFormatter(HelpFormatter):
|
|
"""Comme HelpFormatter, mais ne touche pas aux lignes qui commencent par les
|
|
caractères '>>>'. Cela permet de mixer du texte formaté et du texte non
|
|
formaté.
|
|
"""
|
|
def _fill_text(self, text, width, indent):
|
|
return ''.join([indent + line for line in text.splitlines(True)])
|
|
def _split_lines(self, text, width):
|
|
lines = ['']
|
|
for line in text.splitlines():
|
|
if line.startswith('>>>'):
|
|
lines.append(line)
|
|
lines.append('')
|
|
else:
|
|
lines[-1] += '\n' + line
|
|
lines = filter(None, lines)
|
|
texts = []
|
|
for line in lines:
|
|
if line.startswith('>>>'):
|
|
texts.append(line[3:])
|
|
else:
|
|
texts.extend(super(FancyHelpFormatter, self)._split_lines(line, width))
|
|
return texts
|
|
AP = ArgumentParser(
|
|
usage=u"%(prog)s [options] [TIMEOUT]",
|
|
description=u"Afficher un chronomètre",
|
|
epilog=u"Si TIMEOUT est spécifié, par défaut le décompte démarre automatiquement.",
|
|
formatter_class=FancyHelpFormatter,
|
|
)
|
|
AP.set_defaults(autostart=None, timeout=None)
|
|
AP.add_argument('timeout', metavar='TIMEOUT', nargs='?',
|
|
help=u"""\
|
|
>>> (valeur vide)
|
|
chronomètre qui démarre à 0:00 et ne s'arrête pas
|
|
>>> H:M:S (heures:minutes:secondes)
|
|
>>> ou M:S (minutes:secondes)
|
|
>>> ou M (minutes)
|
|
minuteur qui démarre à H:M:S et fait un décompte jusqu'à 0:00. A la fin
|
|
du décompte, une sonnerie retentit.
|
|
>>> @H[:M[:S]]
|
|
minuteur qui fonctionne comme précédemment, sauf qu'on spécifie l'heure
|
|
d'arrivée, et que la durée est calculée automatiquement""")
|
|
AP.add_argument('-n', '--no-autostart', dest='autostart', action='store_false',
|
|
help=u"Ne pas démarrer automatiquement le décompte même si TIMEOUT est spécifié.")
|
|
AP.add_argument('-s', '--autostart', dest='autostart', action='store_true',
|
|
help=u"Forcer le démarrage automatique du décompte, même si TIMEOUT n'est pas spécifié.")
|
|
o = AP.parse_args()
|
|
|
|
autostart = o.autostart
|
|
if autostart is None: autostart = o.timeout is not None
|
|
o.autostart = autostart
|
|
|
|
timeout = o.timeout
|
|
if timeout is None: timeout = DEFAULT_TIMEOUT
|
|
o.timeout = timeout
|
|
|
|
run_chronometre(o.timeout, o.autostart)
|