def generator():
def iterator():
for n, sala in SALAS.items():
Cena(sala).vai()
yield
timer.set_interval(iterator, 200)
def __setattr__(self, name, value):
object.__setattr__(self, name, value)
if name == 'x': self.b.style.left = f'{50+(value*100)}%'
elif name == 'y': self.b.style.top = f'{50+(value*100)}%'
elif name == 'scale_x': self.b.style.width = f'{value*100}%'
elif name == 'scale_y': self.b.style.height = f'{value*100}%'
elif name == 'origin':
self.b.style.transform = f'translate({(-value[0]-.5)*100}%, {(value[1]-.5)*100}%)'
# elif name == 'origin_y': self.b.style.transform = f'translate({(-value-.5)*100}%, -50%)'
# elif name == 'origin': self.b.style.transformOrigin = f'{value[0]*100}% {value[0]*100}%'
# elif name == 'origin': self.b.style.transformOrigin = f'left center'
# elif name == 'enabled': self.b.disabled = not value
elif name == 'visible':
self.b.style.visibility = ('hidden', 'inherit')[int(value)]
elif name == 'model':
if value == None: self.b.style.backgroundColor = color.clear
elif value == 'quad': self.b.style.borderRadius = '0%'
# if name == 'text': self.b.style.innerHTML = value
elif name == 'update':
if callable(value): timer.set_interval(value, 60)
else: timer.clear_interval(update)
elif name == 'parent': value.b.appendChild(self.b)
elif name == 'color': self.b.style.backgroundColor = value
elif name == 'texture':
self.b.style.backgroundImage = f"url('{value}.jpg'), url('{value}.png')"
def clicker(ev):
global state, count, timer, interval, green, gaps
if state == 'intro':
state = 'test'
green = False
doc['zone'].value = 'test'
count = 3
interval = timer.set_interval(doOrange, 2000)
elif state in ('test', 'main'):
if green:
green = False
gap = time.time() - last
gaps.append(gap)
doc["zone"].value += '\n{}'.format(gap)
count -= 1
if count == 0:
if state == 'test':
green = False
gaps = []
doc['zone'].value = state = 'main'
count = 5
interval = timer.set_interval(doOrange, 2000)
else:
state = 'done'
doc['result'].value = '{},{},{},{}'.format(
'nm', 'gn', 'yr', ','.join(encode(gaps)))
doc['zone'].value = 'please email results to '
else: #do another test
interval = timer.set_interval(doOrange, 2000)
else: # pused to early so restart timer
timer.clear_timeout(interval)
interval = timer.set_interval(doGreen, 2000 + random() * 5000)
else: # state 'done'
pass
def clicker(ev):
global state,count,timer,interval,green,gaps
if state== 'intro':
state = 'test'
green =False
doc['zone'].value = 'test'
count = 3
interval=timer.set_interval(doOrange,2000)
elif state in ('test','main'):
if green:
green = False
gap=time.time()-last
gaps.append(gap)
doc["zone"].value += '\n{}'.format(gap)
count -= 1
if count ==0:
if state== 'test':
green =False
gaps=[]
doc['zone'].value = state = 'main'
count = 5
interval=timer.set_interval(doOrange,2000)
else:
state = 'done'
doc['result'].value = '{},{},{},{}'.format('nm','gn','yr'
,','.join(encode(gaps)))
doc['zone'].value = 'please email results to '
else: #do another test
interval=timer.set_interval(doOrange,2000)
else: # pused to early so restart timer
timer.clear_timeout(interval)
interval=timer.set_interval(doGreen,2000 + random()*5000)
else: # state 'done'
pass
def enable_goldmeter():
try:
gold_meter = GoldMeter()
gold_meter.register_goldmeter_handler("game_log", gold_meter.gold_meter_game_log_handler)
gold_meter.register_goldmeter_handler("game_response", gold_meter.gold_meter_game_response_handler)
set_interval(function(gold_meter.update_goldmeter), 100)
except:
pass
def connect(self):
if USE_WEBSOCKETS:
# Set up websockets
self.try_ws_connect()
else:
# Poll every second if websockets aren't supported
console.log('No websockets. Polling via AJAX.')
self.send('update')
timer.set_interval(lambda: self.send('update'), 1000)
def set_timer(eventid, ms):
def fire():
nonlocal eventid
pygame.event.post(pygame.event.Event(eventid))
if eventid not in set_timer.timers:
set_timer.timers[eventid] = timer.set_interval(fire, ms)
else:
timer.clear_interval(set_timer.timers[eventid])
if ms != 0:
set_timer.timers[eventid] = timer.set_interval(fire, ms)
def start_timer(ev):
global _timer, counter
if _timer is None:
counter = time.time()
_timer = timer.set_interval(show, 10)
doc['start'].text = 'Hold'
elif _timer == 'hold': # restart
# restart timer
counter = time.time() - float(doc['_timer'].text)
_timer = timer.set_interval(show, 10)
doc['start'].text = 'Hold'
else: # hold
timer.clear_interval(_timer)
_timer = 'hold'
doc['start'].text = 'Restart'
def dec(inst):
if wait_for:
def wait_for_condition():
result = wait_for()
if result is True:
timer.clear_interval(test_timer)
try:
return function(inst)
except:
exc = traceback.format_exc()
print(exc, file=sys.stderr)
window.__BRYTHON_UNITTEST_RESULTS__ = {
'exception': exc
}
else:
print("'wait_for' condition is not fulfilled, wait for one second")
test_timer = timer.set_interval(wait_for_condition, 1000)
else:
try:
return function(inst)
except:
exc = traceback.format_exc()
print(exc, file=sys.stderr)
window.__BRYTHON_UNITTEST_RESULTS__ = {
'exception': exc
}
def doOrange():
global interval
timer.clear_timeout(interval)
showHide('red', 0)
showHide('orange', 1)
showHide('green', 0)
interval = timer.set_interval(doGreen, 2000 + random() * 5000)
def response(self):
gap = time.time() - self.last
self.gaps.append(gap)
doc["zone"].value += '\n{}'.format(gap)
self.count -= 1
if self.count == 0:
if self.state == 'test':
self.gaps = []
doc['zone'].value = 'now 5 main runs'
self.state = 'main'
self.count = 5
else:
self.state = 'done'
self.subjects[-1].setgaps(self.gaps)
showHide('resultButtons', 1)
doc['result'].value = (
"'Click!' to record another person or if all finished, press an email button to send results"
)
if len(self.subjects) > 1:
self.compare()
else:
doc['zone'].value += '\nNow next person to get a comparison!'
if self.count > 0: #do another test
showHide('green', 0)
showHide('red', 1)
self.interval = timer.set_interval(self.doOrange, 2000)
def intro(self):
self.state = 'test'
green = False
doc['zone'].value = '3 test runs\n Click as soon as light goes green'
doc['result'].value = "Orange is the warning, then 2 to 5 seconds to green\n 'Click!' as soon as green appears"
self.count = 3
self.interval = timer.set_interval(self.doOrange, 2000)
def doOrange(self):
timer.clear_timeout(self.interval)
showHide('red', 0)
showHide('orange', 1)
showHide('green', 0)
self.interval = timer.set_interval(self.doGreen,
2000 + random() * 5000)
def doOrange():
global interval
timer.clear_timeout(interval)
showHide('red',0)
showHide('orange',1)
showHide('green',0)
interval=timer.set_interval(doGreen,2000 + random()*5000)
def run_forever(self):
if not self._running:
for handle in self._scheduled:
handle.resume()
self._clean_schedule()
self._cleanup_timer = timer.set_interval(self._clean_schedule, 1000)
self._running = True
def __init__(self):
self.pulo = -10
self.issun_top = 380
_kamui = "https://i.imgur.com/R3pCA3a.jpg"
_okami = "https://i.imgur.com/1jSbzEj.png"
_issun = "https://i.imgur.com/lAYKq3F.png"
self.kamui = Cena(_kamui)
self.okami = Elemento(_okami,
cena=self.kamui,
tit="Essa é a Deusa Amaterasu")
self.issun = Elemento(_issun,
cena=self.kamui,
style=dict(left=135,
top=400,
width=20,
height="20px"),
tit="Issun - O artista intinerante")
self.kamui.vai()
def pula_issun(_=0, issun_=self.issun.elt.style):
issun_.top = self.issun_top + self.pulo
self.pulo = -self.pulo
self.pula_issun = timer.set_interval(pula_issun, 300)
def para_issun(_=0):
Texto(self.kamui,
tit="Issun - O artista intinerante",
txt="Essa é a história da deusa Amaterasu").vai()
timer.clear_interval(self.pula_issun)
self.issun.vai = para_issun
def intro(self): self.state = 'test' green =False doc['zone'].value = '3 test runs\n Click as soon as light goes green' doc['result'].value = "Orange is the warning, then 2 to 5 seconds to green\n 'Click!' as soon as green appears" self.count = 3 self.interval=timer.set_interval(self.doOrange,2000)
def run(self, *args, **kwargs):
""""""
delay = w.get_value('delay')
pulse = w.get_value('pulse')
if hasattr(self, 'timer_cue'):
timer.clear_interval(self.timer_cue)
self.timer_cue = timer.set_interval(lambda: self.trial(pulse), delay)
def check_download_btn(self, ev):
if ev.target.tagName == "I":
ev.target.parent.className = "ui loading button"
else:
ev.target.className = "ui loading button"
document["download-mp4"].unbind()
self.prepare_btn_for_download()
self.wait_btn_timer = timer.set_interval(self.prepare_btn_for_download,
5000)
def start_timer(e):
global _timer, counter
if _timer is None:
set_timer()
if timer_length == 0:
alert("Time must be greater than 0")
else:
counter = time.time() + timer_length
_timer = set_interval(show, 1000)
start_button.text = 'Hold'
elif _timer == 'hold': # restart
# restart timer
counter = time.time() + float((int(countdown.text[:2]) * 60) +
int(countdown.text[3:]))
_timer = set_interval(show, 1000)
start_button.text = 'Hold'
else: # hold
clear_interval(_timer)
_timer = 'hold'
start_button.text = 'Restart'
def newgame(ev):
global cboard, redsturn, selectedtile, ai, glt, whowon
alert("Starting new game with " + doc["aiselect"].value + " as AI!")
whowon = NOWIN
cboard = getgsb()
printboard(cboard)
redsturn = True
ai = doc["aiselect"].value
# game loop
glt = timer.set_interval(gameloop, 20)
def show():
global _timer, _alarm
if countdown.text is '00:00':
clear_interval(_timer)
_timer = None
calculate_countdown(timer_length)
start_button.text = 'Start'
stop_button.innerHTML = 'Stop ' + "🔊"
if stop_button.text is not 'Stop':
_alarm = set_interval(audio.play, 1000)
else:
calculate_countdown(counter - time.time())
display_mins_secs()
def __init__(self, _id):
self._id = _id
self.element = doc[_id]
self.history = []
self.is_static = False
try:
self.is_static = self.element.static == 'true'
if self.is_static:
self.element.class_name = self.element.class_name + " is_static"
except:
pass
self.current = 0
self.last_output = None
self.queue = ""
self._status = "main" # or "block" if typing inside a block
# execution namespace
self.editor_ns = {
# 'credits': credits,
# 'copyright': copyright,
# 'license': license,
'__name__': '__main__',
'_': None,
'last_output': None
}
self.attach_events()
timer.set_interval(self.process_queue, 200)
if self.run_initial():
pass
else:
self.intro_and_prompt()
def init():
global canvas, overlay, map, mpos
#ele = doc["map"]
#if not ele.getContext:
# alert('An error occured creating a Canvas 2D context. '
# 'This may be because you are using an old browser')
# return
#map=ele.getContext("2d")
_css = doc.createElement('link')
_css.type = "text/css"
_css.rel = "stylesheet"
_css.href = "gallery/brython/css/3Dwalker.css"
doc['pydiv'] <= _css
_app = html.DIV(id="app")
_app <= html.CANVAS(id="underMap", width="80px", height="80px")
_app <= html.CANVAS(id="map", width="80px", height="80px")
doc['pydiv'] <= html.DIV(id="content")
doc['content'] <= _app
_app <= html.DIV(id='holder')
doc['holder'] <= html.DIV(id='sky')
doc['holder'] <= html.DIV(id='floor')
doc['holder'] <= html.CANVAS(id='canvas', width="400px", height="300px")
doc['holder'] <= html.DIV(id='overlay')
canvas = doc["canvas"].getContext("2d")
overlay = doc["overlay"]
map = doc["map"].getContext('2d')
doc["sky"].style.backgroundPosition = "%spx 0" % floor(-playerDir /
(2 * pi) * 2400)
drawCanvas()
initUnderMap()
timer.set_interval(update, 35)
def change_params_callback(self, ev):
self.clear_canvas()
exec_string = "2 - x"
def dxdt(x):
return 2 - x
self.net = FixedLattice(dxdt, float(self.inputs['dt'].value),
int(self.inputs['n_nodes'].value))
self.canvas.width = 900
self.canvas.height = 900
global _timer
timer.clear_interval(_timer)
_timer = timer.set_interval(self.update,
10 * float(self.inputs['dt'].value))
def draw_border_set_clock_and_show_hours(self, width, height, ray, canvas,
ctx, clock_id):
if hasattr(canvas, 'getContext'):
ctx = canvas.getContext("2d")
ctx.beginPath()
ctx.arc(width / 2, height / 2, ray, 0, 2 * pi)
ctx.fillStyle = self.background_color
ctx.fill()
ctx.beginPath()
ctx.lineWidth = 6
ctx.arc(width / 2, height / 2, ray + 3, 0, 2 * pi)
ctx.strokeStyle = self.border_color
ctx.stroke()
for i in range(60):
ctx.lineWidth = 1
if i % 5 == 0:
ctx.lineWidth = 3
angle = i * 2 * pi / 60 - pi / 3
x1 = width / 2 + ray * cos(angle)
y1 = height / 2 + ray * sin(angle)
x2 = width / 2 + ray * cos(angle) * 0.9
y2 = height / 2 + ray * sin(angle) * 0.9
ctx.beginPath()
ctx.strokeStyle = self.digits_color_1
ctx.moveTo(x1, y1)
ctx.lineTo(x2, y2)
ctx.stroke()
timer.set_interval(
lambda: self.set_clock(width, height, ray, canvas, ctx,
clock_id), 100)
self.show_hours(width, height, ray, canvas, ctx)
else:
document[
'navig_zone'].html = "On Internet Explorer 9 or more, use a Standard rendering engine"
def rodada(self):
artefato = ARTEFATOS[self.rodada_corrente]
self.mesa = self.fases[self.rodada_corrente] # )
self.mesa.vai()
self.acampamento.entra(self.mesa)
self.labirinto.entra(self.mesa)
self.labirinto.elt.html = ''
self.jogadores_ativos = self.jogadores[:]
[jogador.entra() for jogador in self.jogadores]
self.baralho.extend(self.salas)
self.baralho.embaralha(artefato)
self.perigo = self.salas = []
self.interval = timer.set_interval(self.turno, 500)
self.rodada_corrente += 1
return
def init():
global canvas,overlay,map,mpos
#ele = doc["map"]
#if not ele.getContext:
# alert('An error occured creating a Canvas 2D context. '
# 'This may be because you are using an old browser')
# return
#map=ele.getContext("2d")
_css=doc.createElement('link')
_css.type="text/css"
_css.rel="stylesheet"
_css.href="gallery/brython/css/3Dwalker.css"
doc['pydiv'] <= _css
_app = html.DIV(id="app")
_app <= html.CANVAS(id="underMap", width="80px", height="80px")
_app <= html.CANVAS(id="map", width="80px", height="80px")
doc['pydiv'] <= html.DIV(id="content")
doc['content'] <= _app
_app <= html.DIV(id='holder')
doc['holder']<=html.DIV(id='sky')
doc['holder']<=html.DIV(id='floor')
doc['holder']<=html.CANVAS(id='canvas', width="400px", height="300px")
doc['holder']<=html.DIV(id='overlay')
canvas=doc["canvas"].getContext("2d")
overlay=doc["overlay"]
map=doc["map"].getContext('2d')
doc["sky"].style.backgroundPosition="%spx 0" %floor(-playerDir/(2*pi)*2400)
drawCanvas()
initUnderMap()
timer.set_interval(update, 35)
def init():
global tick_timer
element = document["grid"]
element.width = w * block_size
element.height = h * block_size
element = document["next"]
element.width = block_size * 6
element.height = block_size * 4
if not document["grid"].getContext:
alert('An error occured creating a Canvas 2D context. '
'This may be because you are using an old browser')
play_grid.draw_grid()
update_lines_complete(0)
next_block.paint("next")
tick_timer = timer.set_interval(tick, 500)
document["stop"].bind('click', stop_timer)
document.onkeydown = key_code
def rodar(self, vetor, eixo):
self.angle = 0
def rodando(wait=lambda: None):
if self.angle in range(10):
self.cena.forward = y.rotate({'angle': self.angle*pi/20, 'axis': vec(a, b, c)._vec})
self.angle += 1
else:
timer.clear_interval(_timer)
f = self.cena.forward
self.cena.forward = vec(int(f.x*2), int(f.y*2), int(f.z*2))._vec
print(self.cena.forward)
azim = (vetor.x, vetor.y, vetor.z)
a, b, c = ROTATE[azim][eixo]
y = self.cena.forward
_timer = timer.set_interval(rodando, 100)
def joga(self):
vetor = self.cena.forward
xyz = (vetor.x, vetor.y, vetor.z)
self.sentido = sentido = ROTATE[xyz][0]
moventes = [casa.peca for casa in self.casas.values() if casa.peca]
def movendo():
moventes = [peca for peca in moventes if self.find(peca.pos, sentido).recebe(peca)]
if not moventes:
pass
timer.clear_interval(_timer)
vazios = [casa for casa in self.casas.values() if casa.peca is None]
shuffle(vazios)
vazios.pop().joga()
return moventes
_timer = timer.set_interval(movendo, 50)
def startGame(string):
global tableau
global canvas
global idTimer
document["zone"].text = ""
tableau = initPlateau()
if len(string) != 0:
tableau = convertStringToTab(string)
canvas = CANVAS(width = tailleTableau*64 + tailleTableau*5, height = tailleTableau*64 + tailleTableau*5)
canvas.bind("click", cellClickEvent)
document["zone"] <= canvas
idTimer = timer.set_interval(gameLoop, 16)
def test_browser_svg():
from browser import document, svg
line = svg.line(x1="40",
y1="50",
x2="40",
y2="150",
stroke="brown",
stroke_width="2")
panel = document['panel3']
panel <= line
from browser import document, svg
star = svg.polygon(fill="red",
stroke="blue",
stroke_width="10",
points=""" 75,38 90,80 135,80 98,107
111,150 75,125 38,150 51,107
15,80 60,80""")
panel = document['panel4']
panel <= star
from browser import document, svg, timer
rect = svg.rect(x=10, y=10, width=100, height=100)
def move_rect():
# the attributes of the SVG element are strings, they must be explicitely
# converted into integers
rect.attrs["y"] = int(rect.attrs["y"]) + 1
# ends animation when the rectangle reaches its target
if int(rect.attrs["y"]) > 50:
timer.clear_interval(loop)
panel = document['panel5']
panel <= rect
# initialise the animation loop
loop = timer.set_interval(move_rect, 30)
def animateCSS(element, numFrames, timePerFrame, animation, whendone=None):
""" Adapted from Flanagan's javascript version
"""
# park these variables inside element - naughty
element.frame = 0 # // Store current frame number
element.time = 0.0 # // Store total elapsed time
"""
// Arrange to call displayNextFrame() every timePerFrame milliseconds.
// This will display each of the frames of the animation.
"""
element.intervalId = None
def displayNextFrame():
if element.frame >= numFrames: # // First, see if we're done
timer.clear_interval(
element.intervalId) # // If so, stop calling ourselves
"""
del element.frame
del element.time
del element.intervalId
"""
if whendone:
whendone(element) # // Invoke whendone function
return
for cssprop in animation:
"""
// For each property, call its animation function, passing the
// frame number and the elapsed time. Use the return value of the
// function as the new value of the corresponding style property
// of the specified element. Use try/catch to ignore any
// exceptions caused by bad return values.
"""
element.style[cssprop] = animation[cssprop](element.frame,
element.time)
element.frame += 1 # // Increment the frame number
element.time += timePerFrame # // Increment the elapsed time
element.intervalId = timer.set_interval(displayNextFrame, timePerFrame)
"""
def rodar(self, vetor, eixo):
self.angle = 0
def rodando(wait=lambda: None):
if self.angle in range(10):
self.cena.forward = y.rotate({
'angle': self.angle * pi / 20,
'axis': vec(a, b, c)._vec
})
self.angle += 1
else:
timer.clear_interval(_timer)
f = self.cena.forward
self.cena.forward = vec(int(f.x * 2), int(f.y * 2),
int(f.z * 2))._vec
print(self.cena.forward)
azim = (vetor.x, vetor.y, vetor.z)
a, b, c = ROTATE[azim][eixo]
y = self.cena.forward
_timer = timer.set_interval(rodando, 100)
def joga(self):
vetor = self.cena.forward
xyz = (vetor.x, vetor.y, vetor.z)
self.sentido = sentido = ROTATE[xyz][0]
moventes = [casa.peca for casa in self.casas.values() if casa.peca]
def movendo():
moventes = [
peca for peca in moventes
if self.find(peca.pos, sentido).recebe(peca)
]
if not moventes:
pass
timer.clear_interval(_timer)
vazios = [
casa for casa in self.casas.values() if casa.peca is None
]
shuffle(vazios)
vazios.pop().joga()
return moventes
_timer = timer.set_interval(movendo, 50)
def response(self):
gap=time.time()-self.last
self.gaps.append(gap)
doc["zone"].value += '\n{}'.format(gap)
self.count -= 1
if self.count ==0:
if self.state== 'test':
self.gaps=[]
doc['zone'].value = 'now 5 main runs'
self.state = 'main'
self.count = 5
else:
self.state = 'done'
self.subjects[-1].setgaps(self.gaps)
showHide('resultButtons',1)
doc['result'].value = ("'Click!' to record another person or if all finished, press an email button to send results")
if len(self.subjects) > 1:
self.compare()
else:
doc['zone'].value += '\nNow next person to get a comparison!'
if self.count > 0: #do another test
showHide('green',0)
showHide('red',1)
self.interval=timer.set_interval(self.doOrange,2000)
'y': now.seconds,
'dial': {
'radius': '100%',
'baseWidth': 1,
'rearLength': '20%'
}
}],
'animation': False,
'dataLabels': {
'enabled': False
}
}]
})
def move():
hour = chart.get('hour')
minute = chart.get('minute')
second = chart.get('second')
now = Now()
# run animation unless we're wrapping around from 59 to 0
animation = False
if now.seconds == 0:
animation = {'easing': 'easeOutElastic'}
hour.update(now.hours, True, animation)
minute.update(now.minutes, True, animation)
second.update(now.seconds, True, animation)
timer.set_interval(move, 1000)
#accord position create link
line1 = Link(p1,p2)
line2 = Link(p2,p3)
line3 = Link(p3,p4)
line4 = Link(p1,p4)
line5 = Link(p2,p4)
link2_len = p2.distance(p3)
link3_len = p3.distance(p4)
#link2_len = line1.getR()
#link3_len = line3.getR()
#alert(str(link2_len)+','+str(link3_len))
triangle1 = Triangle(p1,p2,p4)
triangle2 = Triangle(p2,p3,p4)
# 視窗載入時執行內容
# 繪圖畫布設定
canvas = doc["plotarea"]
context = canvas.getContext("2d")
# 座標轉換, 移動 canvas.height 並且 y 座標變號, 也就是將原點座標移到畫面左下角
#context.translate(0,canvas.height)
#context.scale(1,1)
#以間隔 10 micro seconds 重複呼叫 draw()
#time.set_interval(draw,20)
timer.set_interval(draw,10)
def doOrange(self):
timer.clear_timeout(self.interval)
showHide('red',0)
showHide('orange',1)
showHide('green',0)
self.interval=timer.set_interval(self.doGreen,2000 + random()*5000)
def process(self):
self._interval=timer.set_interval(self.__interval, 10)
def falsePress(self): timer.clear_timeout(self.interval) self.interval=timer.set_interval(self.doGreen,2000 + random()*5000)
def __init__(self):
self._debug = False
self._pending =[]
self._running=True
self._scheduled = []
self._cleanup_timer = timer.set_interval(self._clean_schedule, 1000)
def loop(self, function, FPS=32):
timer.set_interval(function, 1000 / FPS)
handRadius = RADIUS - HAND_TRUNCATION
context.moveTo(canvas.width / scale, canvas.height / scale)
context.lineTo(
canvas.width / scale + math.cos(angle) * handRadius, canvas.height / scale + math.sin(angle) * handRadius
)
context.stroke()
def drawHands():
now = datetime.datetime.now()
day = now.day
hour = now.hour % 12 + now.minute / 60
minute = now.minute
second = now.second + now.microsecond / 1000000
drawHand(hour * 5 + (minute / 60) * 5, True)
drawHand(minute, False)
drawHand(second, False)
def drawClock():
context.clearRect(0, 0, canvas.width, canvas.height)
drawCircle()
drawCenter()
drawHands()
drawNumerals()
# Initialization
loop = timer.set_interval(drawClock, 1000)
def __init__(self,time):
self.repeat = 0
self.time = time
self.interval = timer.set_interval(self.flash,1000)
