def repaint(self, *args):
self.canvas.clear()
w = 5
with self.canvas:
Color(1, 1, 1, 1)
Line(points=(self.pos[0], self.pos[1], self.pos[0],
self.pos[1] + self.height),
width=w,
cap='none')
Line(points=(self.pos[0] + self.width, self.pos[1],
self.pos[0] + self.width,
self.pos[1] + self.height),
width=w,
cap='none')
y = self.pos[1] + self.height / 2
x = self.pos[0] + w * 2
for i in range(floor(self.width / (4 * w))):
Line(points=(x + i * 4 * w, y, x + (i * 4 + 2) * w, y),
width=w,
cap='none')
# cursor
Color(1, 0, 0, 1)
x = self.pos[0] + self.value * self.width
y0 = self.pos[1] + 0.05 * self.height
y1 = self.pos[1] + 0.95 * self.height
Line(points=(x, y0, x, y1), width=w // 2, cap='none')
def update(self, dt):
self.temps += FREQ
self.canvas.clear()
# Dessin du cadre
with self.canvas:
Color(1, 1, 1)
Line(rectangle=(0, 0, self.L, self.H), width=2)
self.remove_widget(self.label_titre)
self.add_widget(self.label_titre)
self.chart_unit()
# Trace la courbe
pas = int(300/10*FREQ)
max_graph = int(10 / FREQ)
for i in range(0, max_graph-1):
x1 = self.graphX[i]
y1 = self.graphY[i]
x2 = self.graphX[i + 1]
y2 = self.graphY[i + 1]
with self.canvas:
Color(0, 1, 1)
Line(points=(x1, y1, x2, y2))
# mise à jour des points avec intégration de la nouvelle valeur
# à la fin
for i in range(0, max_graph-1):
self.graphY[i] = self.graphY[i + 1]
# Mise à jour de de la valeur du capteur
self.graphY[max_graph-1] = self.capteur.data
def set_state(self, *args):
if self.state == 'down':
with self.canvas.before:
Color(50 / 255.0, 164 / 255.0, 206 / 255.0,
1) # Button down colour
Rectangle(pos=self.pos, size=self.size)
Color(111 / 255.0, 111 / 255.0, 111 / 255.0,
1) # Button hover outline colour
Line(rectangle=(self.x + 1, self.y + 1, self.width - 1,
self.height - 1),
width=1)
else:
if self.hovered:
with self.canvas.before:
Color(88 / 255.0, 88 / 255.0, 88 / 255.0,
1) # Button hover colour
Rectangle(pos=self.pos, size=self.size)
Color(111 / 255.0, 111 / 255.0, 111 / 255.0,
1) # Button hover outline colour
Line(rectangle=(self.x + 1, self.y + 1, self.width - 1,
self.height - 1),
width=1)
else:
with self.canvas.before: # Button up colour
Color(53 / 255.0, 53 / 255.0, 53 / 255.0, 1)
Rectangle(pos=self.pos, size=self.size)
def simulateDots(self):
self.gCodePreview.canvas.clear()
scale_x = self.gCodePreview.size[0]/(self.wall.wall_width_mm * 1.0)
scale_y = self.gCodePreview.size[1]/(self.wall.wall_height_mm * 1.0)
scale = min(scale_x,scale_y)
with self.gCodePreview.canvas:
Scale(scale,scale,1)
# wall
Color(1,1,1,.1)
Rectangle(pos=(0, 0), size=(self.wall.wall_width_mm,
self.wall.wall_height_mm))
# dots
Color(0,1,0,1)
max_dot_rad = self.spray.max_dot_dia_mm / 2
max_dot_area = math.pi * (max_dot_rad ** 2)
for n in range (len(self.ripArray)):
x_center = self.ripArray[n][0]
y_center = self.ripArray[n][1]
dia = math.sqrt((self.ripArray[n][2] * max_dot_area)/math.pi) * 2
Ellipse(pos=(x_center-dia/2,y_center-dia/2), size = (dia,dia))
# bounds
Color(0,0,1,1)
Line(points=[self.ripBounds[0], self.ripBounds[1],
self.ripBounds[0], self.ripBounds[3],
self.ripBounds[2], self.ripBounds[3],
self.ripBounds[2], self.ripBounds[1]], width=2, close=True)
def __init__(self, **kwargs):
self.dpi = kwargs.pop('dpi')
super(MemoryTable, self).__init__(**kwargs)
self.viewclass = 'Label'
self.recycle_grid_layout = self.children[0]
if self.dpi < 192:
self.pos_hint = {'x': dp(0.75), 'center_y': dp(0.75)}
self.size_hint_x = dp(0.3)
self.size_hint_y = dp(0.5)
self.recycle_grid_layout.default_size_hint = (dp(0.5), None)
self.recycle_grid_layout.size_hint_x = dp(0.83)
with self.children[0].canvas.before:
Color(.50, .50, .50, 1)
for i in range(2049):
Line(width=2,
rectangle=(dp(0), dp(0), dp(255),
dp(61470 - (30 * i))))
Line(width=2, rectangle=(dp(0), dp(0), dp(127.5), dp(61470)))
else:
self.pos_hint = {'x': dp(0.37), 'center_y': dp(0.368)}
self.size_hint_x = dp(0.135)
self.size_hint_y = dp(0.265)
self.recycle_grid_layout.default_size_hint = (dp(0.5), None)
self.recycle_grid_layout.size_hint_x = dp(0.47)
with self.children[0].canvas.before:
Color(.50, .50, .50, 1)
for i in range(2049):
Line(width=2,
rectangle=(dp(0), dp(0), dp(270),
dp(61470 - (30 * i))))
Line(width=2, rectangle=(dp(0), dp(0), dp(135), dp(61470)))
def __init__(self, **kwargs):
self.dpi = kwargs.pop('dpi')
super(RegisterTable, self).__init__(**kwargs)
self.viewclass = 'Label'
self.recycle_grid_layout = self.children[0]
if self.dpi < 192:
self.pos_hint = {'x': dp(0), 'center_y': dp(0.75)}
self.size_hint_x = dp(0.2)
self.size_hint_y = dp(0.5)
with self.children[0].canvas.before:
Color(.50, .50, .50, 1)
for i in range(13):
Line(width=2,
rectangle=(dp(0), dp(0), dp(205), dp(390 - (30 * i))))
Line(width=2, rectangle=(dp(0), dp(0), dp(102.5), dp(390)))
else:
self.pos_hint = {'x': dp(0), 'center_y': dp(0.368)}
self.size_hint_x = dp(0.12)
self.size_hint_y = dp(0.265)
self.recycle_grid_layout.size_hint_x = dp(0.47)
with self.children[0].canvas.before:
Color(.50, .50, .50, 1)
for i in range(13):
Line(width=2,
rectangle=(dp(0), dp(0), dp(245), dp(390 - (30 * i))))
Line(width=2, rectangle=(dp(0), dp(0), dp(115), dp(390)))
def draw_field(self):
with self.canvas.before:
Color(0.992, 0.925, 0.863, 1)
Rectangle(pos=self.engine.screen_utils.start,
size=self.engine.screen_utils.size)
self.grid = InstructionGroup()
points = self.engine.screen_utils.create_grid()
self.grid.add(Color(rgba=(0.29, 0, 0.153, 1)))
for a, b in points:
self.grid.add(Line(points=[a[0], a[1], b[0], b[1]]))
border_width = 5
dl = self.engine.screen_utils.start
width, height = self.engine.screen_utils.size
self.grid.add(
Line(points=[
dl[0] - border_width, dl[1] - border_width,
dl[0] - border_width, dl[1] + height + border_width,
dl[0] + width + border_width, dl[1] + height + border_width,
dl[0] + width + border_width, dl[1] - border_width
],
width=border_width,
close=True))
self.canvas.before.add(self.grid)
def redraw(self):
self.canvas.clear()
self.clear_widgets()
with self.canvas:
for row, col in self.walk_tiles():
tile_num = self.puzzle.get_number(row, col)
tile_position = self.tile_pos(row, col)
if tile_num == 0:
Color(255 / 255, 0 / 255, 255 / 255, 1)
else:
Color(153 / 255, 102 / 255, 255 / 255, 1)
Rectangle(pos=tile_position,
size=(self.tile_size, self.tile_size))
BorderImage(pos=tile_position,
size=(self.tile_size, self.tile_size),
source='../assets/15_puzzle_canvas.png')
BorderImage(pos=tile_position,
size=(self.tile_size, self.tile_size),
source='../assets/15_puzzle_tile_border.png')
self.add_widget(
Label(pos=tile_position,
size=(100, 100),
text=str(tile_num),
font_size=25,
font_name='OpenSans'))
def update_canvas(self, *args):
self.canvas.after.clear() # TODO mirar si es necesario si no pintamos
self.canvas.before.clear()
for p in self.horario.pasadas_widget():
with self.canvas.before:
y = self.y + self.height \
- p['start'] * self.height - p['len'] * self.height
h = p['len'] * self.height
pos = (self.x, y)
size = (self.width, h)
if p['task'] == 'Ejecutivo':
# color = get_color_from_hex('#FF880088')
color = get_color_from_hex('#888888')
elif p['task'] == 'Ayudante':
# color = get_color_from_hex('#CC000088')
color = get_color_from_hex('#444444')
if p['task'] != 'Libre':
Color(*color)
Rectangle(pos=pos, size=size)
with self.canvas.after:
Color(1, 1, 1)
# Line(rectangle=pos+size)
with self.canvas.before:
h = 10
pos = (self.x,
self.y + self.height - self.timepos * self.height - h / 2)
size = (self.width, h)
self.tpc = Color(1, .1, .1, self.alpha)
# Color(self.alpha, self.alpha, self.alpha, 1)
self.tp = Rectangle(pos=pos, size=size)
def btn_click_nine(self):
print("nine")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(350, 150, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(50, 150, 100, 100))
def btn_click_seven(self):
print("seven")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(50, 150, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(50, 300, 100, 100))
def btn_click_second(self):
print("second")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(200, 450, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(200, 150, 100, 100))
def draw_stone(self, x, y, player, alpha=1, innercol=None, evalcol=None, evalscale=1.0, scale=1.0):
stone_size = self.stone_size * scale
Color(1, 1, 1, alpha)
Rectangle(
pos=(self.gridpos_x[x] - stone_size, self.gridpos_y[y] - stone_size),
size=(2 * stone_size, 2 * stone_size),
texture=cached_texture(Theme.STONE_TEXTURE[player]),
)
if evalcol:
eval_radius = math.sqrt(evalscale) # scale area by evalscale
evalsize = self.stone_size * (
Theme.EVAL_DOT_MIN_SIZE + eval_radius * (Theme.EVAL_DOT_MAX_SIZE - Theme.EVAL_DOT_MIN_SIZE)
)
Color(*evalcol)
Rectangle(
pos=(self.gridpos_x[x] - evalsize, self.gridpos_y[y] - evalsize),
size=(2 * evalsize, 2 * evalsize),
texture=cached_texture(Theme.EVAL_DOT_TEXTURE),
)
if innercol:
Color(*innercol)
inner_size = stone_size * 0.8
Rectangle(
pos=(self.gridpos_x[x] - inner_size, self.gridpos_y[y] - inner_size),
size=(2 * inner_size, 2 * inner_size),
texture=cached_texture(Theme.LAST_MOVE_TEXTURE),
)
def draw_stone(self,
x,
y,
col,
outline_col=None,
innercol=None,
evalcol=None,
evalscale=1.0,
scale=1.0):
stone_size = self.stone_size * scale
draw_circle((self.gridpos_x[x], self.gridpos_y[y]), stone_size, col)
if outline_col:
Color(*outline_col)
Line(circle=(self.gridpos_x[x], self.gridpos_y[y], stone_size),
width=min(2, 0.035 * stone_size))
if evalcol:
eval_radius = math.sqrt(evalscale) # scale area by evalscale
evalsize = self.stone_size * (
EVAL_DOT_MIN_SIZE + eval_radius *
(EVAL_DOT_MAX_SIZE - EVAL_DOT_MIN_SIZE))
draw_circle((self.gridpos_x[x], self.gridpos_y[y]), evalsize,
evalcol)
if innercol:
Color(*innercol)
Line(circle=(self.gridpos_x[x], self.gridpos_y[y],
stone_size * 0.475 / 0.85),
width=0.1 * stone_size)
def draw_stone(self,
x,
y,
col,
outline_col=None,
innercol=None,
evalcol=None,
evalscale=1.0,
scale=1.0):
stone_size = self.stone_size * scale
draw_circle((self.gridpos_x[x], self.gridpos_y[y]), stone_size, col)
if outline_col:
Color(*outline_col)
Line(circle=(self.gridpos_x[x], self.gridpos_y[y], stone_size),
width=min(2, 0.035 * stone_size))
if evalcol:
eval_radius = math.sqrt(evalscale) # scale area by evalscale
evalsize = self.stone_size * (
self.ui_config["eval_dot_min_size"] + eval_radius *
(self.ui_config["eval_dot_max_size"] -
self.ui_config["eval_dot_min_size"]))
draw_circle((self.gridpos_x[x], self.gridpos_y[y]), evalsize,
evalcol)
if innercol:
Color(*innercol)
Line(circle=(self.gridpos_x[x], self.gridpos_y[y],
stone_size * 0.475 / 0.85),
width=0.1 * stone_size)
def btn_click_eight(self):
print("eigth")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(200, 150, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(200, 300, 100, 100))
def __init__(self, **kwargs):
super().__init__(**kwargs)
with self.canvas.before:
# sfondo
Color(0, 0, 0)
self.background = Rectangle()
# colore del modello
Color(.9, .9, 1)
# renderer
self.renderer = Renderer(shader_file="glContext\\simple.glsl")
# scene
self.scene = Scene()
# objects
self.objects = Objects_list()
self.object_father = self.objects.get()
# adding objects to scene
self.scene.add(self.object_father)
# camera
self.camera = PerspectiveCamera(
fov=75, # distance from the screen
aspect=0, # "screen" ratio
near=1, # nearest rendered point
far=100 # farthest rendered point
)
# rendering
self.renderer.render(self.scene, self.camera)
self.renderer.bind(size=self._adjust_aspect)
self.add_widget(self.renderer)
def btn_click_five(self):
print("five")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(200, 300, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(200, 450, 100, 100))
def draw_stone(self, x, y, player, alpha=1, innercol=None, evalcol=None, evalscale=1.0, scale=1.0):
stone_size = self.stone_size * scale
Color(1, 1, 1, alpha)
Rectangle(
pos=(self.gridpos_x[x] - stone_size, self.gridpos_y[y] - stone_size),
size=(2 * stone_size, 2 * stone_size),
source=f"img/{player}_stone.png",
)
if evalcol:
eval_radius = math.sqrt(evalscale) # scale area by evalscale
evalsize = self.stone_size * (EVAL_DOT_MIN_SIZE + eval_radius * (EVAL_DOT_MAX_SIZE - EVAL_DOT_MIN_SIZE))
Color(*evalcol)
Rectangle(
pos=(self.gridpos_x[x] - evalsize, self.gridpos_y[y] - evalsize),
size=(2 * evalsize, 2 * evalsize),
source=f"img/dot.png",
)
if innercol:
Color(*innercol)
inner_size = stone_size * 0.8
Rectangle(
pos=(self.gridpos_x[x] - inner_size, self.gridpos_y[y] - inner_size),
size=(2 * inner_size, 2 * inner_size),
source=f"img/inner.png",
)
def load_design(self, path, filename):
hex_canvas = self.ids.hex_grid
# with open(os.path.join(path, filename[0])) as in_file:
with open(filename[0]) as in_file:
in_des = eval(in_file.read())
for helix_pair in in_des:
node_from_id, node_to_id = helix_pair
node_from = hex_canvas.grid[node_from_id[0]][node_from_id[1]]
node_to = hex_canvas.grid[node_to_id[0]][node_to_id[1]]
with node_from.canvas:
Color(1, 1, 1, 1)
Ellipse(pos=(node_from.center[0] - 6, node_from.center[1] - 6),
size=(12, 12))
with node_to.canvas:
Color(1, 1, 1, 1)
Ellipse(pos=(node_to.center[0] - 6, node_to.center[1] - 6),
size=(12, 12))
vvh = VVHelix(from_node=node_from,
to_node=node_to,
vvhelix_id=hex_canvas.vvhelix_id)
hex_canvas.scaffold_path.append(vvh)
hex_canvas.vvhelix_id += 2
hex_canvas.add_widget(vvh)
from pprint import pprint
pprint(hex_canvas.scaffold_path)
self.dismiss_popup()
def show_solution(self, present):
if present is None:
self.add_widget(
Label(text="No solution", color=(0, 1, 0, 1), size=self.size))
return
with self.canvas:
Color(0, 0, 0, 1)
Rectangle(pos=(0, 0), size=self.size)
height = len(present)
width = len(present[0])
self.grid_layout.cols = height
self.grid_layout.rows = width
for x in range(width):
for y in range(height):
symbol = present[y][x]
if symbol != '#':
Color(0, 1, 0, 1)
text = "" if symbol == "&&" else symbol
label = CoreLabel(text=text, font_size=20)
label.refresh()
coord_x = x * self.CELL_SIZE + self.OFFSET
top_offset = (y + 1) * self.CELL_SIZE
coord_y = self.height - top_offset + self.OFFSET
Rectangle(pos=(coord_x, coord_y),
texture=label.texture,
size=label.texture.size)
self.draw_empty_rectangle(x, self.height - top_offset)
def paint_square(self, sq_rank, sq_file):
with self.canvas:
if (sq_file % 2) != (sq_rank % 2):
Color(244 / 255.0, 220 / 255.0, 184 / 255.0, mode='rgb')
else:
Color(182 / 255.0, 142 / 255.0, 96 / 255.0, mode='rgb')
Rectangle(pos=(sq_file * 60, sq_rank * 60), size=(60, 60))
def initialize_board(self):
for sq_rank in range(1, 9):
for sq_file in range(1, 9):
pos = (sq_file * 60, sq_rank * 60)
self.board.append(None)
with self.canvas:
if sq_file % 2 != sq_rank % 2:
Color(244 / 255.0,
220 / 255.0,
184 / 255.0,
mode='rgb')
else:
Color(182 / 255.0, 142 / 255.0, 96 / 255.0, mode='rgb')
Rectangle(pos=pos, size=(60, 60))
init_arr = [('p', 'd', 7, 1), ('p', 'd', 7, 2), ('p', 'd', 7, 3),
('p', 'd', 7, 4), ('p', 'd', 7, 5), ('p', 'd', 7, 6),
('p', 'd', 7, 7), ('p', 'd', 7, 8), ('r', 'd', 8, 1),
('r', 'd', 8, 8), ('n', 'd', 8, 2), ('n', 'd', 8, 7),
('b', 'd', 8, 3), ('b', 'd', 8, 6), ('k', 'd', 8, 5),
('q', 'd', 8, 4), ('p', 'l', 2, 1), ('p', 'l', 2, 2),
('p', 'l', 2, 3), ('p', 'l', 2, 4), ('p', 'l', 2, 5),
('p', 'l', 2, 6), ('p', 'l', 2, 7), ('p', 'l', 2, 8),
('r', 'l', 1, 1), ('r', 'l', 1, 8), ('n', 'l', 1, 2),
('n', 'l', 1, 7), ('b', 'l', 1, 3), ('b', 'l', 1, 6),
('k', 'l', 1, 5), ('q', 'l', 1, 4)]
for init_piece in init_arr:
p = Piece(*init_piece)
self.pieces.append(p)
self.add_widget(p)
self.put_piece(p)
self.hash = hash_zobrist(self.board)
def btn_click_third(self):
print("third")
with self.canvas:
Color(1, 0, 0, 3)
Line(rectangle=(350, 450, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(50, 450, 100, 100))
def update(self, dt):
with self.canvas:
for entity, a in self.entity_manager.pairs_for_type(Accumulateur):
# Couleur du texte rgba
if a.full():
Color(0.7, 0, 0) # rouge c'est plein
elif a.empty():
Color(0, 1, 1) # cyan c'est vide
elif a.get() < a.dispo(
): # tout n'est pas dispo (a cause de transit)
Color(1, 1, 0) # jaune c'est partiellement dispo
else:
Color(0, 1, 0) # vert tout est dispo
if not float(a.get()).is_integer():
s = str(round(a.get(), 3))
if a.getmax() != Accumulateur.infini:
s += "/" + str(round(a.getmax(), 3))
else:
s = str(a.get())
if a.getmax() != Accumulateur.infini:
s += "/" + str(a.getmax())
my_label = CoreLabel(text=s, font_size=14)
# the label is usually not drawn until needed, so force it to draw.
my_label.refresh()
# Now access the texture of the label and use it wherever
x_texture = my_label.texture
li = self.entity_manager.component_for_entity(
entity, simulation.graphe.Ligne)
Rectangle(size=x_texture.size, pos=li.ptxt, texture=x_texture)
def btn_click_four(self):
print("four")
with self.canvas:
Color(1, 0, 0)
Line(rectangle=(50, 300, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(350, 300, 100, 100))
def fill_canvas(self):
from kivy.graphics.context_instructions import Color
from kivy.graphics.vertex_instructions import Line
self.normal_level_label = Label(text="100% ",
bold=True,
halign='right',
valign='bottom',
size=(self.LABEL_SIZE,
self.LABEL_SIZE),
text_size=(self.LABEL_SIZE,
self.LABEL_SIZE))
self.half_level_label = Label(text="50% ",
bold=True,
halign='right',
valign='bottom',
size=(self.LABEL_SIZE, self.LABEL_SIZE),
text_size=(self.LABEL_SIZE,
self.LABEL_SIZE))
self.add_widget(self.normal_level_label)
self.add_widget(self.half_level_label)
with self.canvas.before:
self.fill_color = Color()
with self.canvas.after:
Color(1, 1, 1, 1)
self.normal_level_line = Line(width=dp(2))
self.half_level_line = Line(width=dp(2))
def draw(self):
"""
Draws this shape using the Kivy canvas
"""
if self.canvas is None:
return
# Set xt and xb to the horizontal coordinates of left pt
# of top and bottom lines
xb = self.getX() + self.getD()
xt = self.getX()
if (self.getD() < 0):
xb = self.getX()
xt = self.getX() - self.getD()
# Set yt to the vertical coordinate of the bottom left point
yt = self.getY() + int(
round(
math.sqrt(self.getL2() * self.getL2() -
self.getD() * self.getD())))
yb = self.getY()
# Prepare the canvas for drawing
self.canvas.clear()
# Check to see if this is a rectangle
if hasattr(self, 'getFill'):
gl_color = self.getFill().glColor()
color = Color(gl_color[0], gl_color[1], gl_color[2], gl_color[3])
self.canvas.add(color)
rect = vert.Rectangle(pos=map(dp, self.pos),
size=(dp(self.getL1()), dp(self.getL2())))
self.canvas.add(rect)
# Draw the four lines
gl_color = self._color.glColor()
color = Color(gl_color[0], gl_color[1], gl_color[2], gl_color[3])
self.canvas.add(color)
line = kivy.graphics.vertex_instructions.Line(
points=[dp(xt), dp(yt),
dp(xt + self.getL1()),
dp(yt)])
self.canvas.add(line)
line = kivy.graphics.vertex_instructions.Line(points=[
dp(xt + self.getL1()),
dp(yt),
dp(xb + self.getL1()),
dp(yb)
])
self.canvas.add(line)
line = kivy.graphics.vertex_instructions.Line(
points=[dp(xb + self.getL1(
)), dp(yb), dp(xb), dp(yb)])
self.canvas.add(line)
line = kivy.graphics.vertex_instructions.Line(
points=[dp(xb), dp(yb), dp(xt), dp(yt)])
self.canvas.add(line)
def draw(self):
# Avoid garbage collection to draw them...
self._rec_color = Color(*self.color)
self._rec = Rectangle(pos=self.pos, size=(BOX_SIZE, BOX_SIZE))
self._label_color = Color(0, 0, 0)
self._label = Label(text=self.label, font_size=20, pos=self.pos)
self.drawn = True
self._clean_old_pos()
def btn_click_first(self):
print("first")
with self.canvas:
Color(1, 0, 0, 3)
Line(rectangle=(50, 450, 100, 100))
Color(1, 1, 0, 3)
Line(rectangle=(350, 450, 100, 100))
def put_pixel(x, y, color, canvas, token, alpha=None, thickness=2):
r, g, b = color.r, color.g, color.b
c = Color(r, g, b)
if alpha:
c.a = alpha
group = InstructionGroup(group=token)
group.add(c)
group.add(Rectangle(pos=(x, y), size=(thickness, thickness)))
canvas.add(group)
