def __init__(self, parent):
Canvas.__init__(self, width=WIDTH, height=HEIGHT,
background="black", highlightthickness=0)
self.parent = parent
self.initGame()
self.pack()
def __init__(self, *args, **kwargs):
Canvas.__init__(self, *args, **kwargs)
self.graphs = []
self.x = Axis()
self.y = Axis()
self.y.direction = -1
self.bind("<Configure>", lambda ev: self.after_idle(self.__onConfigure__))
def __init__(self, master=None, cnf=None, **kw):
if not cnf:
cnf = {}
Canvas.__init__(self, master, cnf, **kw)
self._polygons = list()
self._layer = None
self._image = None
def __init__(self, master, controller, *, height, width, background): self.height = height self.width = width self.controller = controller self.viewports = [] Canvas.__init__(self, master, height=height, width=width, background=background) self.SetupMenu(master) self.SetNamedView(FLAGS.gui_initial_view or self.default_initial_view)
def __init__(self, parent):
"""Simple Canvas class."""
Canvas.__init__(self, parent)
self.parent = parent
self.config(background="white", width=960, height=640)
self.num = 1
self.pack()
self.element_list = []
self.bindings()
def __init__(self, **kwargs):
"""
Constructor
root - reference to the widget containing this widget
"""
Canvas.__init__(self, **kwargs)
self["bg"] = DEAD_COLOUR
GolCell.__init__(self)
def __init__(self, master=None, cnf={}, **kw):
Canvas.__init__(self, master, cnf, **kw)
Observable.__init__(self)
self.__boxId = None
self.__start_x = None
self.__start_y = None
self.bind('<Button-1>', self.onButton1Press)
self.bind('<B1-Motion>', self.onMouseMove)
self.bind('<ButtonRelease-1>', self.onButton1Release)
def __init__(self, master=None, data=None, cell_size=10, color='green'):
self.cell = data if data else [[False]]
self._grid_width = len(self.cell)
self._grid_height = len(self.cell[0])
self._width = self._grid_width * cell_size
self._height = self._grid_height * cell_size
Canvas.__init__(self, master, width=self._width, height=self._height)
self.cell_size = cell_size
self.color = color
self.bind('<Button-1>', self.on_click)
self.bind('<B1-Motion>', partial(self.on_click, motion=True))
self.draw()
def __init__(self, master, controller, *, height, width, background):
self.is_history_displayed = False
self.height = height
self.width = width
self.controller = controller
self.viewports = []
Canvas.__init__(
self, master, height=height, width=width, background=background)
self.SetupMenu(master)
self.SetNamedView(farg_flags.FargFlags.gui_initial_view or
self.default_initial_view)
if farg_flags.FargFlags.history:
self.TurnOnHistoryGUI(master)
def __init__(self, parent, name, size):
Canvas.__init__(self, parent)
self.parent = parent
self.name = name
self.background = "white"
self.size = size
self.width = size[0]
self.height = size[1]
self.info = defaultdict(dict)
self.num = defaultdict(int)
self.sticky_size = (250, 220)
self.stickies = []
self.lines = {}
self.bind("<ButtonPress-1>", self.smark)
self.bind("<B1-Motion>", self.sdrag)
self.bind("<Button-3>", self.insert_node)
def __init__(self, parent, name):
Canvas.__init__(self, parent)
self.parent = parent
self.name = name
self.config(bg="white")
self.info = defaultdict(dict)
self.marked = None
self.sticky_size = (250, 220)
self.stickies = {}
self.lines = {}
self.scale_by = 0
self.bind("<ButtonPress-2>", self.smark)
self.bind("<B2-Motion>", self.sdrag)
self.bind("<Button-3>", self.insert_node)
self.bind("<Button-4>", self.zoom_up)
self.bind("<Button-5>", self.zoom_down)
def __init__(self, master, image):
Canvas.__init__(self, master, width=image.size[0], height=image.size[1])
# fill the canvas
self.tile = {}
self.tilesize = tilesize = 32
xsize, ysize = image.size
for x in range(0, xsize, tilesize):
for y in range(0, ysize, tilesize):
box = x, y, min(xsize, x+tilesize), min(ysize, y+tilesize)
tile = ImageTk.PhotoImage(image.crop(box))
self.create_image(x, y, image=tile, anchor=NW)
self.tile[(x, y)] = box, tile
self.image = image
self.bind("<B1-Motion>", self.paint)
def __init__(self, master):
Canvas.__init__(self, master, bg="white", height=CANVAS_HEIGHT)
self.create_rectangle(MAIN_REC_X,
MAIN_REC_Y,
MAIN_REC_X + MAIN_REC_WIDTH,
MAIN_REC_Y + MAIN_REC_HEIGHT,
fill="gray")
self.create_text(MAIN_REC_X + (MAIN_REC_WIDTH / 2),
MAIN_REC_Y + (TEXT_HEIGHT / 2),
text="SystemCoreClock",
fill="#000000",
font=("Consolas", 10))
self.selected_globals = GlobalVarSampling()
self.pack(fill="none")
def __init__(self, parent: tk.Frame = None, interval=20, linenum=10, save=True, drag=True, adaptation=True, lengthx=20000):
Canvas.__init__(self, parent, bg='#345', closeenough=2)
parent.update_idletasks()
self.pack(fill=tk.BOTH, expand=True)
self.update_idletasks()
self.hScroll = Scrollbar(parent, orient='horizontal',
command=self.hScrolled)
self.hScroll.pack(side=tk.BOTTOM, fill=tk.X)
self.configure(yscrollcommand=None,
xscrollcommand=self._canvashScrolled)
self.bind("<Button-1>", self.__mouseDown)
self.bind("<MouseWheel>", self.__mouseScale)
self.bind("<B1-Motion>", self.__mouseDownMove)
self.bind("<B1-ButtonRelease>", self.__mouseUp)
self.bind("<Enter>", self.__mouseEnter)
self.bind("<Leave>", self.__mouseLeave)
self.bind("<Motion>", self.__mouseHoverMove)
self["xscrollincrement"] = 1
self["yscrollincrement"] = 1
self.__dataList = []
self._rulerdata = [0]*linenum
self.x = 0
self.scrollx = 3.0
self.offsety = 0
self._interval = interval # main loop interval to handle input data
self._lengthx = lengthx # scrollregion x
self._rulerOn = False
self._dragOn = drag # enable mouse move items
self._gridOn = True # draw grid lines
self._loopOn = True
self._tipOn = False
self._adaptation = adaptation
self._ruler = None
self._rulerX = -1
self._save = save # 保存数据
self._dataWriter = None # 数据保存writer
self._datafile = '' # 保存文件名称
self._scrollOn = False
self._lineNum = linenum
self._firststart = True
self._scrollDelay = 0
# this data is used to keep track of an item being dragged
# in this app, only vertical position
self._drag_data = {"sx": 0, "sy": 0, "x": 0, "y": 0, "item": None}
self._lines = []
self.after(200, self.__initCanvas)
def __init__(self, size, values):
Canvas.__init__(self)
self.config(width = size, height = size)
self.size = size
sudoku.font = Font(size = int(32 * self.size / 600))
self.values = values
self.curyx = (4, 4)
sudoku.INDEXES = [(x, y) for x in range(9) for y in range(9)]
self.pack()
self.init_graphics()
self.event_add('<<digit>>', *['<KeyPress-{}>'.format(i) for i in range(1, 10)])
self.bind_all('<<digit>>', self.write_digit)
self.bind_all('s', self.solve)
self.bind_all('c', self.clear)
self.bind('<Motion>', self.on_mouse_motion)
self.bind('<Button-1>', self.on_mouse_click1)
self.bind('<Button-3>', self.on_mouse_click3)
def __init__(self, master, image):
Canvas.__init__(self, master, width=image.size[0], height=image.size[1])
# fill the canvas
self.tile = {}
self.tilesize = tilesize = 32
xsize, ysize = image.size
for x in range(0, xsize, tilesize):
for y in range(0, ysize, tilesize):
box = x, y, min(xsize, x+tilesize), min(ysize, y+tilesize)
tile = ImageTk.PhotoImage(image.crop(box))
self.create_image(x, y, image=tile, anchor=NW)
self.tile[(x, y)] = box, tile
self.image = image
self.bind("<B1-Motion>", self.paint)
def __init__(self,
parent,
igrac1,
igrac2,
naziv_fajla,
stampaj_vrednosti_svih_poteza,
crtaj_svaki_korak=True):
"""Konstruktor klase IgraCanvas, inicijalizuje potrebne atribute.
:param parent: Roditeljski widget u kojem se crta IgraCanvas
:type parent: Widget
:param igrac1: Tip prvog igraca
:type igrac1: str
:param igrac2: Tip drugog igraca
:type igrac2: str
:param naziv_fajla: Putanja do falja iz kojeg se citaju potezi ili u kojem se upisuju potezi
:type naziv_fajla: str
:param stampaj_vrednosti_svih_poteza: Da li treba stampati vrednosti svih mogucih poteza za AI
:type stampaj_vrednosti_svih_poteza: bool
:param crtaj_svaki_korak: Kad igraju AI vs AI da li treba prikazivati svaki potez ili samo rezultat njihovog meca, defaults to True
:type crtaj_svaki_korak: bool, optional
"""
Canvas.__init__(self, parent)
self.config(width=500, height=550)
self.bind("<Button-1>", self.mouse_click)
self.crtaj_svaki_korak = crtaj_svaki_korak
# postavljanje tip igraca koji su prosledjeni kao parametri
self.plavi_AI = self.odaberi_AI(igrac1, stampaj_vrednosti_svih_poteza)
self.crveni_AI = self.odaberi_AI(igrac2, stampaj_vrednosti_svih_poteza)
# inicijalizacije matrice
self.tabla = Tabla()
self.na_potezu = None # da napisem dobar komentar za ovo
self.game_state = GameState.POSTAVLJANJE_FIGURA # u pocetku svi igraci postavljaju svoje figure na tablu
self.broj_figura = 0 # treba mi za prvu fazu gde se postavljaju figure
self.selektovana_figura = (-2, -2)
# otvaranje fajla, citanje i izvrsavanje poteza ako ih ima u njemu
self.procitaj_fajl_i_popuni_tabelu(naziv_fajla)
# otvaranje fajla za pisanje sad, svaki put kad se izvrsi neki potez on se upisuje u fajl
self.f = open(naziv_fajla, "a")
self.crtaj()
self.zameni_igraca()
def __init__(self,
boss=None,
largeur=400,
hauteur=300,
xmin=-10,
ymin=-10,
xmax=10,
ymax=10,
background='white',
axes=True):
Canvas.__init__(self, boss)
self.configure(width=largeur,
height=hauteur,
bg=background,
border=5,
relief=RIDGE)
self.x1 = 0
self.y2 = 0
self.axes = axes
self.xmin, self.ymin, self.xmax, self.ymax = xmin, ymin, xmax, ymax
self.largeur = largeur # int(self.cget('width'))
self.hauteur = hauteur # int(self.cget('height'))
self.o2, self.p, self.inv_p = self._initialize_matrix(
xmin, ymin, xmax, ymax, largeur, hauteur)
self.pasU = self._reglage_pas()
self.flag = 0 # pas de déplacement d'objets au départ
border_w = self.winfo_reqwidth() - self.largeur # largeur intérieure
border_h = self.winfo_reqheight() - self.hauteur # hauteur intérieure
self.border = (border_w / 2, border_h / 2) # taille du bord
# où l'on stocke les différents objets dessinés pour la
# réactualisation:
self.objets = []
# [ tag, nature, xmin, ymin, xmax, ymax, couleur, epaisseur, remplissage ]
self.redraw()
self.bind('<Configure>', self._config)
self.bind('<Button-1>', self.mouseDown)
boss.bind('<Double-Button-1>', self.dblclic)
self.bind('<Button1-Motion>', self.mouseMove)
self.bind('<Button1-ButtonRelease>', self.mouseUp)
self.bind('<Button-4>', self.wheel) # roulette pour linux
self.bind('<Button-5>', self.wheel) # roulette pour linux
boss.bind('<MouseWheel>', self.wheel) # pour windows
self.master.protocol("WM_DELETE_WINDOW", self.fermeture)
def __init__(self,
tk_instance,
*geometry,
fp="background.png",
animation_speed=50):
#Verifica se o parâmetro tk_instance é uma instância de Tk
if not isinstance(tk_instance, Tk):
raise TypeError(
"The tk_instance argument must be an instance of Tk.")
#Recebe o caminho de imagem e a velocidade da animação
self.image_path = fp
self.animation_speed = animation_speed
#Recebe a largura e altura do widget
self.__width = geometry[0]
self.__height = geometry[1]
#Inicializa o construtor da classe Canvas
Canvas.__init__(self,
master=tk_instance,
width=self.__width,
height=self.__height)
#Carrega a imagem que será usada no plano de fundo
self.__bg_image = self.getPhotoImage(image_path=self.image_path,
width=self.__width,
height=self.__height,
closeAfter=True)[0]
#Cria uma imagem que será fixa, ou seja, que não fará parte da animação e serve em situações de bugs na animação
self.__background_default = self.create_image(self.__width // 2,
self.__height // 2,
image=self.__bg_image)
#Cria as imagens que serão utilizadas na animação do background
self.__background.append(
self.create_image(self.__width // 2,
self.__height // 2,
image=self.__bg_image))
self.__background.append(
self.create_image(self.__width + (self.__width // 2),
self.__height // 2,
image=self.__bg_image))
def __init__(self,
master,
stationId,
dateFrom=datetime.today(),
dateTo=datetime.today(),
statisticType='day'):
'''
Parameters
----------
master : frame
Frame where the canvas set
dateFrom : datetime
Statistic start date
dateTo : datetime
Statistic end date
statisticType : string
Set display type (day,month,year)
'''
# Statistic size
self.width = 1000
self.height = 800
self.lineColors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00']
Canvas.__init__(self, master, width=self.width, height=self.height)
# Db
self.db = Db()
# Statistic border
Border = namedtuple('Border', 'top bottom left right')
self.border = Border(5, 50, 50, 5)
# Statistic coordinations
Statistic = namedtuple('Statistic',
'top left right bottom height width')
self.statistic = Statistic(
self.border.top, self.border.left, self.width - self.border.right,
self.height - self.border.bottom,
self.height - self.border.top - self.border.bottom,
self.width - self.border.left - self.border.right)
self.pack(expand=1, side='bottom')
self.set(stationId, dateFrom, dateTo, statisticType)
def __init__(self, parent, radius, color_on, o_color_on, color_off, o_color_off, off_or_on):
Canvas.__init__(self, parent, borderwidth=0, highlightthickness=0, bg='sky blue')
padding = 0
self.color_on = color_on
self.color_off = color_off
self.o_color_on = o_color_on
self.o_color_off = o_color_on
self.current_color = color_on
self.outline_color = o_color_on
self.light = self.create_oval((3, 3, radius, radius), width=radius/5, fill=self.current_color)
self.set_state(off_or_on)
(x0, y0, x1, y1) = self.bbox("all")
radius = (x1-x0) + padding
self.configure(width=radius, height=radius)
def __init__(self, root):
Canvas.__init__(self, width = 400 ,height = 400, bg=bg)
self.root = root
self.board = Board(self)
for i in range(4):
for j in range(4):
rect = self.create_rectangle(
j*100 + 8, i*100 + 8,
j*100+98, i*100+98,
fill=tile_bg,
outline="")
self.tag_lower(rect)
root.bind("<Up>", lambda event: self.step((-1, 0)))
root.bind("<Down>", lambda event: self.step((1, 0)))
root.bind("<Left>", lambda event: self.step((0, -1)))
root.bind("<Right>", lambda event: self.step((0, 1)))
def __init__(self, parent: Widget, width: int, height: int):
"""Initialize chart canvas.
Args:
parent: tkinter widget canvas should belong to
width: pixel width of candle area
height: pixel height of candle area
Attributes (not all set upon initialization).
"""
Canvas.__init__(
self,
master=parent,
background=Color.BACKGROUND,
borderwidth=0,
bd=0,
highlightthickness=0,
width=width,
height=height,
)
def __init__(self, parent, title, value, textColor=None):
Canvas.__init__(self,
parent,
bd=-2,
width=0,
height=0,
highlightthickness=0)
self.config = ConfigValues()
if textColor:
self.textColor = textColor
else:
self.textColor = self.config.values['colors']['green']
self.text = None
self.setBackgroundColor(self.config.values['colors']['darkBlue'])
self.setText(title, value)
def __init__(self, parent, doc, **kw):
kw['width'] = 512
kw['height'] = 480
kw['relief']='raised'
kw['highlightthickness'] = 0
Canvas.__init__(self, parent, **kw)
self.doc = doc
self.tile = []
im = PILImage.new('RGB', (32, 32))
for y in range(15):
row = []
for x in range(16):
tile = ImageTk.PhotoImage(im)
if True or ((x ^ y) & 1) == 0:
self.create_image(x * 32, y * 32, image=tile, anchor=NW)
row.append(tile)
self.tile.append(row)
self.updating = False
self.updScreen()
def __init__(self, master, node_map, **options):
# Initialize canvas
Canvas.__init__(self, master, **options) # Initialize parent class
self.grid(row=0, column=0)
self.last_update = current_time_millis() # FPS
# Control variables
self.x_offset, self.y_offset = 0, 0
self.scale = 1
self.node_map = node_map
# Mouse events
self.mouse_x_offset, self.mouse_y_offset = 0, 0
self.bind("<Button-1>", self.mouse1_down)
self.bind("<B1-Motion>", self.mouse1_drag)
self.bind("<MouseWheel>", self.mouse_scroll) # Windows
self.bind("<Button-4>", self.mouse_scroll) # Linux
self.bind("<Button-5>", self.mouse_scroll) # Linux
def __init__(self, parent: Tk, width_in_pixels: int, height_in_pixels: int, block_size: int,
board_width: int, board_height: int, grid_row: int, grid_column: int):
self.parent = parent
self.width_in_pixels = width_in_pixels
self.height_in_pixels = height_in_pixels
Canvas.__init__(self, parent, width=self.width_in_pixels, height=self.height_in_pixels, bg=self.board_colour)
self.num_circles_horizontal = board_width
self.num_circles_vertical = board_height
self.circle_diameter = (8 / 10) * block_size
self.padding = (1 / 10) * block_size
self.drop_distance = block_size
self.grid(row=grid_row, column=grid_column, columnspan=self.num_circles_horizontal)
self.draw_bg_circles()
self.animation_in_progress = False # Used to tell parent that it should wait until animation over
def __init__(self, master=None, **kw):
self.log = logging.getLogger(__name__)
self.min = 0
self.max = 100
if "min" in kw:
self.min = kw['min']
del kw['min']
if "max" in kw:
self.max = kw['max']
del kw['max']
if "width" not in kw:
kw['width'] = 100
if "height" not in kw:
kw['height'] = 10
if "background" not in kw:
kw['background'] = "black"
self.rect = None
Canvas.__init__(*(self, master), **kw)
def __init__(self, tk_instance, *geometry, fp="background.png", animation_speed=50):
if not isinstance(tk_instance, Tk): raise TypeError("The tk_instance argument must be an instance of Tk.")
self.image_path = fp
self.animation_speed = animation_speed
self.__width = geometry[0]
self.__height = geometry[1]
Canvas.__init__(self, master=tk_instance, width=self.__width, height=self.__height)
self.__bg_image = \
self.getPhotoImage(image_path=self.image_path, width=self.__width, height=self.__height, closeAfter=True)[0]
self.__background_default = self.create_image(self.__width // 2, self.__height // 2, image=self.__bg_image)
self.__background.append(self.create_image(self.__width // 2, self.__height // 2, image=self.__bg_image))
self.__background.append(
self.create_image(self.__width + (self.__width // 2), self.__height // 2, image=self.__bg_image))
def __init__(self, parent, **kwargs):
"""
Custom scrollbar, using canvas. It can be configured with fg, bg and command
:param parent:
:param kwargs:
"""
self.command = kwargs.pop("command", None)
kw = kwargs.copy()
bd = 0
hlt = 0
if "fg" in kw.keys():
del kw["fg"]
if "bd" in kw.keys():
bd = kw.pop("bd")
if "border" in kw.keys():
bd = kw.pop("border")
if "highlightthickness" in kw.keys():
hlt = kw.pop("highlightthickness")
Canvas.__init__(self,
parent,
**kw,
highlightthickness=hlt,
border=bd,
bd=bd)
if "fg" not in kwargs.keys():
kwargs["fg"] = "darkgray"
# coordinates are irrelevant; they will be recomputed
# in the 'set' method\
self.old_y = 0
self._id = self.create_rectangle(0,
0,
1,
1,
fill=kwargs["fg"],
outline=kwargs["fg"],
tags=("thumb", ))
self.bind("<ButtonPress-1>", self.on_press)
self.bind("<ButtonRelease-1>", self.on_release)
def __init__(self, master, layout, margin=20, caption=None, **kw):
Canvas.__init__(self,
master,
width=int(layout.size.x + 2 * margin),
height=int(layout.size.y + 2 * margin),
**kw)
self.__margin = margin
self._vertex_label_mode = "auto"
# map value -> Vertex object
self._vertices = dict()
self._layout = layout
self._picked_vertex_state = PickedState()
self._create_vertex_shape = (
lambda vertex: shapes.create_default_shape(self, vertex))
self.update()
self._caption = self.create_caption(caption) if caption else None
# self._translate = (0, 0)
self._mouse_plugin = MousePlugin().apply(self)
# makes vertex shape change appearing if it was picked
# also sets layout lock for picked vertices
def createListener():
state = self._picked_vertex_state
layout = self.layout
def listener(vertex):
picked = state.is_picked(vertex)
vertex.shape.set_selection(picked)
layout.set_lock(layout.graph.index(vertex.value), picked)
return listener
self._picked_vertex_state.add_listener(createListener())
# handle resize
self.bind("<Configure>", lambda event: self._on_configure())
def __init__(self,
parent,
main_window,
col=None,
bg="#009900",
diameter=50,
mode="game",
command=None):
Canvas.__init__(self, parent, width=diameter, height=diameter)
self.configure(highlightthickness=1,
highlightbackground="black",
borderwidth=1,
bg=bg)
self.Main_Window = main_window
# Do we create the disc initially or not?
if col == None:
self.Visible = False
else:
self.Visible = True
if self.Visible:
self.Disc = self.create_oval((0, 0, diameter, diameter),
fill=col,
tags="Disc")
else:
self.Disc = None
self.Mode = mode
# Display Attributes
self.diameter = diameter
# Disc Attribute
self.Current_Color = col
# Binds
self.command = command
self.bind("<Button-1>", self._Onclick)
self.bind("<Configure>", self._Onresize)
def __init__(self,
master=None,
chosen_color="red",
rows=2000,
columns=2000):
Canvas.__init__(self, master)
self.bind("<Button-1>", self.click)
self.bind("<B1-Motion>", self.hold_down_cell)
self.bind("<Button-3>", self.right_click)
self.bind("<B3-Motion>", self.right_move)
self.cell_width = 15
self.cell_height = 15
self.cell_draws = [[None for c in range(columns)] for r in range(rows)]
self.DEAD_COLOR = "white"
self.chosen_pattern = "cell"
self.chosen_color = chosen_color
self.patterns = self._load_patterns()
self.matrix = GameMatrix(rows=rows, columns=columns)
self._create_grid()
self.shift_x = 0
self.shift_y = 0
def __init__(self, master, row_number, column_number, cell_size):
Canvas.__init__(self,
master,
width=cell_size * column_number,
height=cell_size * row_number)
self.cellSize = cell_size
self.grid = [[
Cell(self, column, row, cell_size)
for column in range(column_number)
] for row in range(row_number)]
self.switched = [
] # avoid multi switching of state during mouse motion.
self.bind("<Button-1>", self.handle_mouse_click)
self.bind("<B1-Motion>", self.handle_mouse_motion)
self.bind("<ButtonRelease-1>", lambda event: self.switched.clear())
self.draw()
def __init__(self, master, size, color, secondary_color, last_roll):
Canvas.__init__(self,
master=master,
width=size,
height=size,
bd=1,
relief=RIDGE)
self._current_value = last_roll
self._size = size
self._color = color
self._secondary_color = secondary_color
self._dot_list = []
self._dot_locations = [[(5, 5)], [(2, 2), (8, 8)],
[(8, 2), (5, 5), (2, 8)],
[(2, 2), (2, 8), (8, 2), (8, 8)],
[(5, 5), (2, 2), (2, 8), (8, 2), (8, 8)],
[(2, 2), (2, 8), (8, 2), (8, 8), (2, 5),
(8, 5)]]
self._x = self._y = self._c = self._size / 2
self._show()
self._dot_radius = self._size / 10
self._show_dots()
def __init__(self, master):
Canvas.__init__(self, master)
self.master = master
self.nivel = 1
self.cabeza_coordenadas = self.genera_comida_aleatoria_inicio()
self.cuerpo_coordenadas = [
self.cabeza_coordenadas,
(self.cabeza_coordenadas[0] - 20, self.cabeza_coordenadas[1])
]
self.comida_coordenadas = self.genera_comida_aleatoria()
self.color_cabeza = constantes.color_cabeza
self.direcciones_posibles = constantes.DIRECCIONES_FLECHAS
# Si se quiere que empiece con una direccion aleatoria automaticamente cambiar self.direccion = random.choice(self.direcciones_posibles)
self.direccion = ''
self.bind_all('<Key>', self.presiona_tecla)
self.cargar_imagenes_cuerpo_cabeza()
self.cargar_vivorita()
self.cargar_comida()
self.mover_vivorita()
self.after(self.master.master.velocidad.get(), self.bucle_juego)
self.reproductor = Reproductor()
self.reproductor.reproducir_musica(constantes.musica_en_juego, 0.04)
def __init__(self, master=None, **kw):
Canvas.__init__(self, master, kw)
self.doIdleRedraw = 0
self.doIdleSWCursor = 0
self.ignoreNextRedraw = 0
# Add a placeholder software cursor attribute. If it is None,
# that means no software cursor is in effect. If it is not None,
# then it will be used to render the cursor.
self._isSWCursorActive = 0
self._SWCursor = None
self.initialised = 0
# to save last cursor position if switching to another window
self.lastX = None
self.lastY = None
self.width = self.winfo_width() # to avoid repeated calls
self.height = self.winfo_height()
# Basic bindings for the virtual trackball
self.bind('<Expose>', self.tkExpose)
self.bind('<Configure>', self.tkExpose)
def __init__(self, master, widget, **kwargs):
Canvas.__init__(self, master, **kwargs)
self._marks = {'warning': [], 'error': [], 'sep': []}
self.widget = widget
self.colors = {'warning': 'orange', 'error': 'red', 'sep': 'blue'}
self.active_colors = {
'warning': '#FFC355',
'error': '#FF5555',
'sep': '#5555FF'
}
self.update_idletasks()
self._highlight_img = Image.new('RGBA', (1, 1), "#ffffff88")
self._highlight_photoimg = ImageTk.PhotoImage(self._highlight_img,
master=self)
self.highlight = self.create_image(0,
0,
anchor='nw',
image=self._highlight_photoimg)
self.bind('<1>', self.on_click)
self.bind('<Map>', self.update_positions)
def __init__(self,
master=None,
*ap,
foreground="black",
rows,
columns,
cell,
**an):
"""Init screen function"""
self.foreground = StringVar()
self.foreground.set(foreground)
Canvas.__init__(self, master, *ap, **an)
self.rows = rows
self.columns = columns
self.cell_width = cell
self.cell_height = cell
self.matrix = []
for _ in range(self.columns):
column_arr = ["gray" for _ in range(self.rows)]
self.matrix.append(column_arr)
self.rects = {}
def __init__(self, parent, controller):
# create canvas
Canvas.__init__(self,master=parent,scrollregion=(0,0,3000,200))
self.controller = controller
# create subframe
self.lFrame = ListsFrame(parent=self,controller=self.controller)
# create scrollbar
self.hBar=Scrollbar(master=parent,orient=HORIZONTAL)
# place subframe
self.lFrame.pack(fill=BOTH)
# place scrollbar
self.hBar.pack(side=BOTTOM,fill=X)
# configure scrollbar
self.hBar.config(command=self.xview)
# configure canvas
self.config(xscrollcommand=self.hBar.set)
def __init__(self, parent, square: Square) :
# Init
Canvas.__init__(self, parent, width=SQUARE_SIZE, height=SQUARE_SIZE)
self.parent = parent
# Square attribute
self.square = square
self.selected = False
self.highlighted = False
# Graphical piece
self.piece_gui = None
# Position on the board canvas
x_position = 1/8 * self.square.get_file()
y_position = 1 - (1/8 * (self.square.get_rank() + 1))
self.place(relx=x_position, rely=y_position)
# Configure square background
if self.square.get_color() == SquareColor.DARK.value :
self.base_color = SquareGui.DARK_BG
else :
self.base_color = SquareGui.LIGHT_BG
self.configure(bg=self.base_color)
# Button bindings
self.bind("<Button-1>", self.on_left_click)
self.bind("<Button-3>", self.on_right_click)
def __init__(self, master, listaComics=None, session = None, cnf={}, **kw):
Canvas.__init__(self, master, cnf, **kw)
self.size = self.size = (int(320 / 2), int(496 / 2))
self.space = 58
if session is not None:
self.session = session
else:
self.session = Entidades.Init.Session()
self.pahThumnails = self.session.query(Setup).first().directorioBase+ os.path.sep +"images"+os.path.sep +"coverIssuesThumbnails"+os.path.sep
print(self.pahThumnails)
print(self.size[0])
self.listaComics = listaComics
self.thumbnail = []
self.comicsSelected=[]
self.tagAndComic = []
self.halfSize = (int(self.size[0] / 2), int(self.size[1] / 2))
self.bind("<Button-1>", self.comicClicked)
self.bind('<Shift-Button-1>', self.multipleComicsClicked)
self.bind('<Control-Button-1>', self.addComicClicked)
self.paginaDoblada = Iconos().pilImagePaginaDoblada
self.cantidadColumnas = 6
def __init__(self, master):
Canvas.__init__(self, master)
self.initializeComponents()
def __init__(self, frame, window, background):
self.window = window
Canvas.__init__(self, frame, background=background)
def __init__(self): Canvas.__init__(self)
