q-tools/bin/clockcurses

#!/usr/bin/env python3
import curses
import datetime
import math
import os
import signal
import sys
import time
from optparse import OptionParser

ascii_digits = {
    "0": "0000 00 00 0000",
    "1": "  1" * 5,
    "2": "222  22222  222",
    "3": "333  3 33  3333",
    "4": "4  4 4444  4  4",
    "5": "5555  555  5555",
    "6": "66 6  6666 6666",
    "7": "777  7  7  7  7",
    "8": "8888 88888 8888",
    "9": "9999 9999  9 99",
    ":": "    .     .    ",
}

fancy_digits = {
    "0": "╒═╕│ ││ ││ │╘═╛",
    "1": " ╕  │  │  │  ╧ ",
    "2": "╒═╕  │╒═╛│  ╘═╛",
    "3": "╒═╕  │ ═╡  │╘═╛",
    "4": "╤  │ │╘═╡  │  ╧",
    "5": "╒═╕│  ╘═╕  │╘═╛",
    "6": "╒╕ │  ╞═╕│ │╘═╛",
    "7": "╒═╕  │  ╪  │  ╛",
    "8": "╒═╕│ │╞═╡│ │╘═╛",
    "9": "╒═╕│ │╘═╡  │ ╘╛",
    ":": "    °     °    ",
}


def termsize():
    rows, columns = os.popen("stty size", "r").read().split()
    return (int(rows), int(columns))


def centerpoint(ry, rx):
    r = int(round(min(ry / 1.5, rx / 1.5)) - 1)
    return (int(round(ry / 2)), int(round(rx / 2)), r)


def saddstr(win, y, x, s, a=None):
    if not a:
        a=curses.color_pair(0)
    try:
        win.addstr(y, x, s, a)
    except:
        pass


def drawcircle(win, cy, cx, r):
    precision = 360
    for a in range(precision):
        alpha = 2.0 * math.pi * a / precision
        dy = int(round(cy - float(r) * math.cos(alpha)))
        dx = int(round(cx + 2.0 * float(r) * math.sin(alpha)))
        saddstr(win, dy, dx, ".")
    return


def drawline(win, cy, cx, a, s, r, char, attr=None):
    prec = 2
    for l in range(int(r * prec)):
        if l > s:
            ly = int(round(cy - float(l) * math.cos(a) / prec))
            lx = int(round(cx + 2.0 * float(l) * math.sin(a) / prec))
            saddstr(win, ly, lx, char, attr)

    return


def drawdigit(win, y, x, d, ascii=False):
    s = "               "
    if ascii:
        s = ascii_digits.get(d, s)
    else:
        s = fancy_digits.get(d, s)
    drawsplitstr(win, y, x, s)
    return


def drawsplitstr(win, y, x, st):
    ls = list(st)
    for r in range(5):
        rs = 3 * r
        saddstr(win, y + r, x, ls[rs] + ls[rs + 1] + ls[rs + 2])
    return


def drawdigital(win, y, x, t, ascii=False):
    if options.seconds:
        if t.tm_sec & 1:
            hrs = list("%02d:%02d:%02d" % (t.tm_hour, t.tm_min, t.tm_sec))
        else:
            hrs = list("%02d %02d %02d" % (t.tm_hour, t.tm_min, t.tm_sec))
    else:
        if t.tm_sec & 1:
            hrs = list("%02d:%02d" % (t.tm_hour, t.tm_min))
        else:
            hrs = list("%02d %02d" % (t.tm_hour, t.tm_min))
    for c in range(len(hrs)):
        drawdigit(win, y, x + 4 * c, hrs[c], ascii=ascii)


def readinput(win):
    try:
        input = win.getch()
        if input in [ord(x) for x in ["x", "X", "q", "Q"]]:
            return "x"
    except:
        return ""
    return ""


class timer_struct:
    """Class for storing timer."""

    def __init__(self, h, m, s):
        self.tm_hour = int(h)
        self.tm_min = int(m)
        self.tm_sec = int(s)


def main():
    stdscr = curses.initscr()
    curses.curs_set(0)
    curses.start_color()
    curses.use_default_colors()
    for i in range(0, curses.COLORS):
        curses.init_pair(i + 1, i, -1)
    start_t = time.time()
    try:
        # rows,columns = termsize()
        while 1:
            rows, columns = stdscr.getmaxyx()
            cy, cx, r = centerpoint(rows, columns)
            stdscr.clear()
            t = time.localtime()
            if options.timer:
                t_new = time.time() - start_t
                t_m, t_s = divmod(t_new, 60)
                t_h, t_m = divmod(t_m, 60)
            else:
                t_s = float(t.tm_sec)
                t_m = float(t.tm_min)
                t_h = float(t.tm_hour)
            alphas = math.pi * t_s / 30.0
            alpham = math.pi * t_m / 30.0 + alphas / 60.0
            alphah = math.pi * t_h / 6.0 + alpham / 12.0
            if options.seconds:
                drawline(stdscr, cy, cx, alphas, 1, r / 2, "s", curses.color_pair(2))
            drawline(stdscr, cy, cx, alpham, 1, int(round(r * 0.8) / 2), "m", curses.color_pair(3))
            drawline(stdscr, cy, cx, alphah, 1, int(round(r * 0.5) / 2), "HH", curses.color_pair(7))
            stdscr.addstr(cy, cx, "o")
            drawcircle(stdscr, cy, cx, r / 2)
            for h in range(12):
                drawline(stdscr, cy, cx, math.pi * h / 6.0, r, 1 + r / 2, "O")
            if options.timer:
                drawdigital(stdscr, 1, 1, timer_struct(t_h, t_m, t_s), options.ascii)
                drawdigital(stdscr, 7, 1, t, options.ascii)
            else:
                drawdigital(stdscr, 1, 1, t, options.ascii)
            stdscr.refresh()
            # time.sleep(options.refresh)
            signal.signal(signal.SIGALRM, readinput)
            signal.alarm(int(options.refresh))
            userinput = readinput(stdscr)
            if userinput == "x":
                curses.nocbreak()
                stdscr.keypad(0)
                curses.endwin()
                sys.exit(0)

    except KeyboardInterrupt:
        curses.nocbreak()
        stdscr.keypad(0)
        # curses.echo()

    curses.endwin()


usage = """Usage: %prog [options]

Display a clockface
"""
parser = OptionParser(usage=usage)
parser.add_option("-s", action="store_true", dest="seconds", default=False, help="Show seconds [%default]")
parser.add_option("-r", type="int", dest="refresh", default=3, help="Refresh rate in seconds [%default]")
parser.add_option(
    "-t", action="store_true", dest="timer", default=False, help="Timer instead of current time [%default]"
)
parser.add_option("-a", action="store_true", dest="ascii", default=False, help="Plain ascii characters only [%default]")
global options
(options, args) = parser.parse_args()

main()