def plot_spectra(self):
# calculate scale and axis label steps:
scale_x = (688.0 - 2 * self.x_offset) / (self.x_max - self.x_min)
scale_y = (688.0 - 2 * self.y_offset) / (self.y_max - self.y_min)
step_x = scale_x * (self.x_max - self.x_min) / 10
step_y = scale_y * (self.y_max - self.y_min) / 10
# Draw x and y axix:
canvas.set_stroke_color(0, 0, 0)
# x-axis
canvas.draw_line(self.x_offset, self.y_offset, 688, self.y_offset)
# y-axis
canvas.draw_line(self.x_offset, self.y_offset, self.x_offset, 688)
# label and mark the axes..
for i in range(11):
canvas.set_fill_color(0, 0, 0)
# x-axis...
label = self.x_axis_format.format(self.x_min + i *
(self.x_max - self.x_min) / 10)
canvas.draw_text(label,
self.x_offset + step_x * i,
0,
font_name='Helvetica',
font_size=16)
canvas.draw_line(self.x_offset + step_x * i, self.y_offset - 5,
self.x_offset + step_x * i, self.y_offset)
# y-axis...
label = self.y_axis_format.format(self.y_min + i *
(self.y_max - self.y_min) / 10)
canvas.draw_text(label,
0,
self.y_offset + step_y * i,
font_name='Helvetica',
font_size=16)
canvas.draw_line(self.x_offset - 5, self.y_offset + step_y * i,
self.x_offset, self.y_offset + step_y * i)
# draw each dataset...
for j in range(len(self.x_set)):
temp_x = []
temp_y = []
temp_colour = []
temp_x = self.x_set[j]
temp_y = self.y_set[j]
canvas.set_stroke_color(*self.spectrum_colour[j])
canvas.set_line_width(2)
canvas.move_to(self.x_offset + scale_x * (temp_x[0] - self.x_min),
self.y_offset + scale_y * (temp_y[0] - self.y_min))
for i in range(len(temp_x)):
draw_x = self.x_offset + scale_x * (temp_x[i] - self.x_min)
draw_y = self.y_offset + scale_y * (temp_y[i] - self.y_min)
if (self.style[j] == '-'):
canvas.add_line(draw_x, draw_y)
if (self.style[j] == 'o'):
canvas.add_ellipse(draw_x - 3, draw_y - 3, 6, 6)
canvas.draw_path()
def dessine(mot,p,e):
global to_find
for i in range(len(mot)):
if mot[i] in to_find:
canvas.draw_line((i+1)*e+(i)*p,60,(i+1)*(e+p),60)
else:
a = (i+1)*e+(i)*p
b = (i+1)*(e+p)
canvas.draw_text( (a+b)/2 , 50 , mot[i])
def drawNumbers2(): for i in range(12): canvas.save_gstate() canvas.translate(centerX, centerY) canvas.rotate(-2 * pi / 12.0 * i) canvas.set_fill_color(0.3, 0.3, 0.3, 0.6) fontSize = 30 fontName = 'Helvetica-Bold' number = str(12 if i == 0 else i) width, height = canvas.get_text_size(number, fontName, fontSize) canvas.draw_text(number, -width/2, 115, fontName, fontSize) canvas.restore_gstate()
def drawNumbers(): for i in range(12): canvas.save_gstate() canvas.set_fill_color(0.3, 0.3, 0.3, 0.6) fontSize = 30 fontName = 'Helvetica-Bold' number = str(12 if i == 0 else i) width, height = canvas.get_text_size(number, fontName, fontSize) hour = i angle = -2 * pi / 12.0 * (hour - 3) length = clockWidth * 0.43 rads = radians(angle) x = int(cos(angle) * length) + centerX y = int(sin(angle) * length) + centerY canvas.draw_text(number, x - width/2, y - height/2, fontName, fontSize) canvas.restore_gstate()
def render(self):
self.time += 1
canvas.clear()
canvas.draw_image(images[self.fond.name], self.fond.center, self.fond.size, (470, 150), self.fond.size2, 0)
canvas.draw_image(
images[self.ball.info.name],
self.ball.info.center,
self.ball.info.size,
self.ball.pos,
self.ball.info.size2,
self.ball.angle,
)
canvas.draw_line((500, 146), (400, 146), 3, "Red")
canvas.draw_text("Score: " + str(self.ball.get_score()), (370, 46), 30, "Orange")
c = self.get_kb()
if c == "38":
self.ball.shooting = True
self.ball.shoot()
if c == None:
self.ball.shooting = False
self.ball.update()
def render():
global jeu, count, partie, timer
canvas.clear()
canvas.draw_image(echiquier, (175,171),(350,342),(250,250),(500,500),0)
board = str(jeu.board).split()
j = 0
for ligne in board:
i = 0
for c in ligne:
i += 1
if c<> ".":
x = ML+i*(W-2*ML)/8 - 25
y = MT+j*(W-2*MT)/8 + 12
p = pieces[c]
canvas.draw_image(pions,
(
pions_center[0]+p[1]*pions_size[0],
pions_center[1]+p[0]*pions_size[1]),
pions_size,
(x,y),
pions_size2,
0
)
j += 1
if count < len(partie):
canvas.draw_text(partie[count],(20,20),24,'Blue')
jeu.move(partie[count])
jeu.advance()
count += 1
def draw():
global bits, out
canvas.fill_rect(0,0,500,500)
left = 80
top = 30
canvas.draw_line((0,30+top),(500,30+top),4,'Blue')
cl2 = 'Yellow'
canvas.draw_text("ENTREES",(left-30,25+top),24,cl2)
canvas.draw_text("SORTIES",(left+250,25+top),24,cl2)
canvas.draw_circle((left, 50+top), 10, 2, 'Blue', color(str(bits['A'])))
canvas.draw_circle((left, 73+top), 10, 2, 'Blue', color(str(bits['B'])))
canvas.draw_circle((left, 96+top), 10, 2, 'Blue', color(str(bits['C'])))
canvas.draw_circle((left+170, 50+top), 10, 2, 'Blue', color(out))
canvas.draw_text("A: "+str(bits['A']),(left+15,58+top),24,cl2)
canvas.draw_text("B: "+str(bits['B']),(left+15,80+top),24,cl2)
canvas.draw_text("C: "+str(bits['C']),(left+15,102+top),24,cl2)
canvas.draw_text(inp.get_text(),(left+185,58+top),24,cl2)
"""
A FAIRE:
Dessiner avec draw_circle et draw_line les interrupteurs
et les faire basculer et eteindre quand les entrees changent
"""
#dessin des fils
canvas.draw_line((0,290+top),(100,290+top),3,'Blue')
canvas.draw_line((150,290+top),(200,290+top),3,'Blue')
canvas.draw_line((200,230+top),(200,350+top),3,'Blue')
canvas.draw_line((200,230+top),(250,230+top),3,'Blue')
canvas.draw_line((200,350+top),(250,350+top),3,'Blue')
canvas.draw_line((300,230+top),(350,230+top),3,'Red')
canvas.draw_line((300,350+top),(350,350+top),3,'Red')
canvas.draw_line((350,230+top),(350,350+top),3,'Red')
canvas.draw_line((500,290+top),(350,290+top),3,'Red')
canvas.draw_circle((420, 290+top), 30, 2, 'Blue', color(out))
canvas.draw_text("A",(115,270+top),24,cl2)
canvas.draw_text("B",(267,210+top),24,cl2)
canvas.draw_text("C",(267,330+top),24,cl2)
#dessin des interrupteurs
if bits['C'] == 0:
canvas.draw_line((250,350+top),(300,350+top),3,'Orange')
else:
canvas.draw_line((250,350+top),(300,330+top),3,'Orange')
def draw():
#ceci est la fonction qui gere l'ecran
global bits
canvas.fill_rect(0,0,500,500)
left = 80
top = 30
canvas.draw_line((0,30+top),(500,30+top),4,'Blue')
cl2 = 'Yellow'
canvas.draw_text("ENTREES",(left-30,25+top),24,cl2)
canvas.draw_text("SORTIES",(left+250,25+top),24,cl2)
if (bits['A']+bits['B'] >= 1):
equ = 1
else:
equ = 0
canvas.draw_circle((left, 50+top), 10, 2, 'Blue', color(str(bits['A'])))
canvas.draw_circle((left, 80+top), 10, 2, 'Blue', color(str(bits['B'])))
canvas.draw_circle((left+250, 50+top), 10, 2, 'Blue', color(str(equ)))
canvas.draw_text("A: "+str(bits['A']),(left+15,58+top),24,cl2)
canvas.draw_text("B: "+str(bits['B']),(left+15,88+top),24,cl2)
canvas.draw_text("L: "+str(equ),(left+265,58+top),24,cl2)
canvas.draw_line((0,290+top),(100,290+top),3,'Red')
canvas.draw_line((150,350+top),(200,350+top),3,'Blue')
canvas.draw_line((50,350+top),(100,350+top),3,'Red')
canvas.draw_line((50,350+top),(50,290+top),3,'Red')
canvas.draw_line((200,350+top),(200,290+top),3,'Blue')
canvas.draw_line((500,290+top),(150,290+top),3,'Blue')
canvas.draw_circle((420, 290+top), 30, 2, 'Blue', color(str(equ)))
canvas.draw_text("A",(115,270+top),24,cl2)
canvas.draw_text("B",(115,320+top),24,cl2)
canvas.draw_text("L",(410,240+top),24,cl2)
if bits['A'] == 0:
canvas.draw_line((100,290+top),(150,270+top),3,'Orange')
else:
canvas.draw_line((100,290+top),(150,290+top),3,'Orange')
if bits['B'] == 0:
canvas.draw_line((100,350+top),(150,330+top),3,'Orange')
else:
canvas.draw_line((100,350+top),(150,350+top),3,'Orange')
"""
def draw(mycanvas):
#ceci est la fonction qui gere l'ecran
global bits
left = 80
top = 30
canvas.draw_line((0,30+top),(500,30+top),4,'Blue')
cl2 = 'Yellow'
canvas.draw_text("ENTREES",(left-30,25+top),24,cl2)
canvas.draw_text("SORTIES",(left+250,25+top),24,cl2)
canvas.draw_circle((left, 50+top), 10, 2, 'Blue', color(str(bits['A'])))
canvas.draw_circle((left+250, 50+top), 10, 2, 'Blue', color(str(bits['A'])))
canvas.draw_text("A: "+str(bits['A']),(left+15,58+top),24,cl2)
canvas.draw_text("L: "+str(bits['A']),(left+265,58+top),24,cl2)
canvas.draw_line((0,290+top),(100,290+top),3,'Red')
#canvas.draw_line((150,290+top),(300,290+top),3,'Blue')
canvas.draw_line((500,290+top),(150,290+top),3,'Blue')
canvas.draw_circle((420, 290+top), 30, 2, 'Blue', color(str(bits['A'])))
canvas.draw_text("A",(115,270+top),24,cl2)
canvas.draw_text("L",(410,240+top),24,cl2)
if bits['A'] == 0:
canvas.draw_line((100,290+top),(150,270+top),3,'Orange')
else:
canvas.draw_line((100,290+top),(150,290+top),3,'Orange')
"""
def render(self):
#global errors, mot, to_find, msg , end_game
canvas.clear()
if self.msg <> None:
canvas.draw_text(200,250,self.msg)
if self.end_game:
canvas.add_button(26*18,0,18,18,"@")
c = self.get_mouse()
if c <> None:
#une lettre est cliquee mouse_handler
#canvas.draw_text(200,250,c)
self.mouse_handler(c)
w = 18
for i in range(26):
canvas.add_button(i*w,0,18,18,chr(65+i))
n = len(self.mot)
p = (500 * 2) / ( 3*n + 1 )
e = p / 2
for i in range(len(self.mot)):
if self.mot[i] in self.to_find:
canvas.draw_line((i+1)*e+(i)*p,80,(i+1)*(e+p),80)
else:
a = (i+1)*e+(i)*p
b = (i+1)*(e+p)
canvas.draw_text((a+b)/2 - e/2 , 70, self.mot[i])
if (self.errors > 1):
canvas.draw_line(100,400,200,400)
if (self.errors >= 2):
canvas.draw_line(100,400,200,400)
if (self.errors >= 3):
canvas.draw_line(150,400,150,150)
if (self.errors >= 4):
canvas.draw_line(150,150,300,150)
if (self.errors >= 5):
canvas.draw_line(225,150,150,230)
if (self.errors >= 6):
canvas.draw_line(300,150,300,180)
if (self.errors >= 7):
canvas.draw_circle(300,200,20)
if (self.errors >= 8):
canvas.draw_line(300,220,300,300)
if (self.errors >= 9):
canvas.draw_line(300,300,330,360)
if (self.errors >= 10):
canvas.draw_line(300,300,270,360)
if (self.errors >= 11):
canvas.draw_line(300,240,330,300)
if (self.errors >= 12):
canvas.draw_line(300,240,270,300)
def main():
console.alert('Motion Experiment 2',
'yo gang gang, we gonna measure this motion', 'Continue')
motion.start_updates()
sleep(0.2)
print('Capturing motion data...')
w = 1000
h = 1400
while True:
sleep(0.01)
canvas.set_size(w, h)
current = motion.get_gravity()
newMotion = [0, 0, 0]
for i in range(len(current)):
newMotion[i] = (current[i] * (10**3)) // 1
#print(newMotion)
x = newMotion[0] + 1000
y = newMotion[1] + 1000
z = newMotion[2] + 1000
goalX = w / 2
goalY = h / 2
#bottom
if (abs(x - 1000) < 500 and abs(y - 1000) < 600 and abs(z - 0) < 500):
canvas.set_fill_color(1, 0, 0)
canvas.draw_text("bottom",
x - 500,
y - 400,
font_name='Courier New',
font_size=50.0)
#top
if (abs(x - 1000) < 500 and abs(y - 1000) < 600
and abs(z - 2000) < 500):
canvas.set_fill_color(0, 0, 1)
canvas.draw_text("top",
1500 - x,
1700 - y,
font_name='Courier New',
font_size=50.0)
#right
if (abs(x - 0) < 500 and abs(y - 1000) < 600 and abs(z - 1000) < 500):
canvas.set_fill_color(0, 0, 1)
canvas.draw_text("right",
500 - x,
1500 - y,
font_name='Courier New',
font_size=50.0)
#left
if (abs(x - 2000) < 500 and abs(y - 1000) < 600
and abs(z - 1000) < 500):
canvas.set_fill_color(0, 0, 1)
canvas.draw_text("left",
x - 1500,
1500 - y,
font_name='Courier New',
font_size=50.0)
#front
if (abs(x - 1000) < 500 and abs(y - 0) < 600 and abs(z - 1000) < 500):
canvas.set_fill_color(0, 0, 1)
canvas.draw_text("front",
500 - y,
1500 - z,
font_name='Courier New',
font_size=50.0)
#back
if (abs(x - 1000) < 500 and abs(y - 2000) < 600
and abs(z - 1000) < 500):
canvas.set_fill_color(0, 0, 1)
canvas.draw_text("back",
y - 1500,
z - 500,
font_name='Courier New',
font_size=50.0)
# if (z > 1000):
# canvas.set_fill_color(0, 0, 1)
# canvas.draw_text("top", 1500-x, 1700-y, font_name='Courier New', font_size=50.0)
motion.stop_updates()
print('Capture finished, plotting...')
e = p / 2
lettres = []
to_find = []
for c in mot:
if not(c in to_find):
to_find.append(c)
while (len(to_find)>0) and (errors<12):
dessine(mot,p,e)
lettre = input('Donne une lettre: ')
ch = lettre[0].upper()
if ch in ['A','B','C','D','E','F','G','H','I','J',
'K','L','M','N','O','P','Q','R','S','T',
'U','V','W','X','Y','Z','-']:
if not(ch in lettres):
lettres.append(ch)
if ch in mot:
to_find.remove(ch)
else:
errors += 1
process()
dessine(mot,p,e)
if (errors >= 12):
canvas.draw_text( 200 , 250 , "YOU LOOSE :(")
else:
canvas.draw_text( 200 , 250 , "YOU WIN :)")
errors = 0
def draw_text(self, text, x, y, font_name=None, font_size=None):
if font_size is None:
font_size = self.font_size
if font_name is None:
font_name = self.font_name
canvas.draw_text(text, *self.xyWorld(x, y), font_name, font_size)
def draw_label(s, x, y): fs = 30 fnt = 'Helvetica-Bold' w, h = canvas.get_text_size(str(s), fnt, fs) canvas.set_fill_color(0,0,0) canvas.draw_text(str(s), x - w / 2, y - h / 2, fnt, fs)
# https://forum.omz-software.com/topic/3238/the-color-of-the-text-that-is-drawn-with-draw_text import canvas canvas.set_size(600, 600) canvas.set_fill_color(1, 0, 0) #red text = 'OK' x = 0 y = 400 font_family = 'Helvetica-Bold' font_size = 40 canvas.draw_text(text, x, y, font_family, font_size)
def paint(self, width, height):
# start with unit diagonal
self.unit_diagonal(self.view_tm)
# rotate object
self.rotx(self.xinc, self.rotx_tm)
self.am4x4(self.view_tm, self.rotx_tm, self.view_tm)
self.roty(self.yinc, self.roty_tm)
self.am4x4(self.view_tm, self.roty_tm, self.view_tm)
self.rotz(self.zinc, self.rotz_tm)
self.am4x4(self.view_tm, self.rotz_tm, self.view_tm)
# scale
self.scaleit(self.scale, self.scale, self.scale, self.scale_tm)
self.am4x4(self.view_tm, self.scale_tm, self.view_tm)
# move coordinates to origin
self.trans(-self.xe, -self.ye, -self.ze, self.trans_tm)
self.am4x4(self.view_tm, self.trans_tm, self.view_tm)
# rotate -90 deg. about x axis
self.rotx(1.5708, self.rotx_tm)
self.am4x4(self.view_tm, self.rotx_tm, self.view_tm)
# rotate -theta about y axis
theta = math.atan2(-(self.xe - self.xt), -(self.ye - self.yt))
self.roty(-theta, self.roty_tm)
self.am4x4(self.view_tm, self.roty_tm, self.view_tm)
# rotate -phi around x axis
phi = math.atan2((self.ze - self.zt),
math.sqrt((self.xe - self.xt) * (self.xe - self.xt) +
(self.ye - self.yt) * (self.ye - self.yt)))
self.rotx(-phi, self.rotx_tm)
self.am4x4(self.view_tm, self.rotx_tm, self.view_tm)
# change rh to lh coordinates
self.scaleit(1, -1, -1, self.scale_tm)
self.am4x4(self.view_tm, self.scale_tm, self.view_tm)
# add perspective
if self.persp:
self.perspect(self.s, self.d, self.persp_tm)
self.am4x4(self.view_tm, self.persp_tm, self.view_tm)
# transform the view
self.am20x4(self.view_tm, self.view)
# draw the view in width/height
orgx = width / 2
orgy = height / 2
if self.persp:
for i in range(self.vertnum):
self.view[i][0] = (orgx * self.view[i][0] /
self.view[i][2]) + orgx
self.view[i][1] = (orgy * self.view[i][1] /
self.view[i][2]) + orgy
canvas.begin_updates()
canvas.set_size(width, height)
canvas.set_stroke_color(0, 1, 0)
for i in range(self.facenum):
for j in range(self.edgenum[i] - 1):
canvas.draw_line(self.view[self.face[i][j]][0],
self.view[self.face[i][j]][1],
self.view[self.face[i][j + 1]][0],
self.view[self.face[i][j + 1]][1])
canvas.draw_line(self.view[self.face[i][j + 1]][0],
self.view[self.face[i][j + 1]][1],
self.view[self.face[i][0]][0],
self.view[self.face[i][0]][1])
canvas.set_fill_color(0, 1, 0)
self.frames += 1
canvas.draw_text(
'Object: ' + self.name + ' Frames: ' + str(self.frames) +
' Angle: ' + str(self.yinc), 10, 10)
canvas.end_updates()
def render(self):
global a_missile, lives, score
if lives == 0:
canvas.draw_text("YOU LOOSE :(",(200,230),30,"Red")
return
self.time += 1
wtime = (self.time / 4) % WIDTH
canvas.clear()
canvas.draw_image(self.fond.get_image(),self.fond.center,self.fond.size,(250,250),self.fond.size2,0)
canvas.draw_image(self.debris.get_image(), self.debris.get_center(), self.debris.get_size(), (wtime - WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT),0)
canvas.draw_image(self.debris.get_image(), self.debris.get_center(), self.debris.get_size(), (wtime + WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT),0)
canvas.draw_image(self.ship.info.image,self.ship.info.center,self.ship.info.size,self.ship.pos,self.ship.info.size2,self.ship.angle)
#canvas.draw_circle(self.ship.pos[0],self.ship.pos[1],self.ship.radius)
canvas.draw_image(self.a_missile.info.image,self.a_missile.info.center,self.a_missile.info.size,self.a_missile.pos,self.a_missile.info.size2,self.a_missile.angle)
if self.a_rock.exploded:
if (wtime) % 24 == 0:
self.a_rock.exploded = False
x = random.randrange(0,2)
y = random.randrange(0,HEIGHT)
x = x * WIDTH
self.a_rock.set_pos(x,y)
if x == 0:
vx = 1
else:
vx = -1
vy = 1
self.a_rock.set_vit(vx,vy)
#self.a_rock.exploded = False
canvas.draw_image(self.a_rock_exploded.info.image,
(self.a_rock_exploded.info.center[0]
+((wtime) % 24)*self.a_rock_exploded.info.size[0],
self.a_rock_exploded.info.center[1]),
self.a_rock_exploded.info.size,
self.a_rock.pos,
self.a_rock_exploded.info.size,
0)
else:
canvas.draw_image(self.a_rock.info.image,self.a_rock.info.center,self.a_rock.info.size,self.a_rock.pos,self.a_rock.info.size2,self.a_rock.angle)
canvas.draw_text("lives: "+str(lives)+" score: "+str(score),(320,30),24,'Orange')
#canvas.draw_circle(self.a_rock.pos[0],self.a_rock.pos[1],self.a_rock.radius)
c = self.get_kb()
if c == '32':
self.ship.shoot(self.a_missile)
if c == '37':
self.ship.dec_angle()
if c == '39':
self.ship.inc_angle()
if c == '38' and (self.time % 10 == 0):
self.ship.set_thrust(True)
if c == None:
self.ship.stop_angle()
self.ship.set_thrust(False)
self.ship.update()
self.a_missile.update()
self.a_rock.update()
self.check_collision()
def draw():
global bits, out
canvas.fill_rect(0, 0, 500, 500)
left = 80
top = 30
canvas.draw_line((0, 30 + top), (500, 30 + top), 4, "Blue")
cl2 = "Yellow"
canvas.draw_text("ENTREES", (left - 30, 25 + top), 24, cl2)
canvas.draw_text("SORTIES", (left + 250, 25 + top), 24, cl2)
canvas.draw_circle((left, 50 + top), 10, 2, "Blue", color(str(bits["A"])))
canvas.draw_circle((left, 73 + top), 10, 2, "Blue", color(str(bits["B"])))
canvas.draw_circle((left, 96 + top), 10, 2, "Blue", color(str(bits["C"])))
canvas.draw_circle((left + 170, 50 + top), 10, 2, "Blue", color(out))
canvas.draw_text("A: " + str(bits["A"]), (left + 15, 58 + top), 24, cl2)
canvas.draw_text("B: " + str(bits["B"]), (left + 15, 80 + top), 24, cl2)
canvas.draw_text("C: " + str(bits["C"]), (left + 15, 102 + top), 24, cl2)
canvas.draw_text(inp.get_text(), (left + 185, 58 + top), 24, cl2)
"""
finally:
canvas.restore_gstate()
screenHeight = 512
circleHeight = 128
colorBlue = (0, 0, 1)
colorGreen = (0, 1, 0)
colorRed = (1, 0, 0)
def coloredCircle(inColor, inX, inY):
canvas.set_fill_color(*inColor)
canvas.fill_ellipse(inX, inY, circleHeight, circleHeight)
canvas.clear()
canvas.set_size(screenHeight * 1.42, screenHeight)
with privateGstate(): # Save and then restore the canvas.gstate
canvas.rotate(89) # Text on an angle.
canvas.draw_text('Green on top -->', 154, 0, 'Helvetica', 36)
canvas.draw_text('<-- Red and Blue on bottom', 282, 52, 'Helvetica', 36)
x = 20 + circleHeight
coloredCircle(colorRed, 10, 10) # Red circle appears at bottom.
with flippedDisplay(): # Change origin to topLeft instead of bottomLeft.
coloredCircle(colorGreen, x, 10) # Green circle appears at top.
coloredCircle(colorBlue, x, 10) # Blue circle appears at bottom.
def draw(mycanvas):
# ceci est la fonction qui gere l'ecran
global bits
left = 80
top = 30
canvas.draw_line((0, 30 + top), (500, 30 + top), 4, "Blue")
cl2 = "Yellow"
canvas.draw_text("ENTREES", (left - 30, 25 + top), 24, cl2)
canvas.draw_text("SORTIES", (left + 250, 25 + top), 24, cl2)
canvas.draw_circle((left, 50 + top), 10, 2, "Blue", color(str(bits["A"])))
canvas.draw_circle((left, 73 + top), 10, 2, "Blue", color(str(bits["B"])))
canvas.draw_circle((left, 96 + top), 10, 2, "Blue", color(str(bits["C"])))
equ = process(inp.get_text())
canvas.draw_circle((left + 250, 50 + top), 10, 2, "Blue", color(equ))
canvas.draw_text("A: " + str(bits["A"]), (left + 15, 58 + top), 24, cl2)
canvas.draw_text("B: " + str(bits["B"]), (left + 15, 80 + top), 24, cl2)
canvas.draw_text("C: " + str(bits["C"]), (left + 15, 102 + top), 24, cl2)
canvas.draw_text(inp.get_text(), (left + 265, 58 + top), 24, cl2)
"""
