def inner(mainloop):
'''
伴随函数
mainloop : 接收主循环线程
'''
# 创建目录，生成文件名模板
try:
mkdir(folder_name)
except:
pass
file_fm = join_path(folder_name, file_format)
# 获取截图范围
screen = Screen()
canvas, root = screen.getcanvas(), screen._root
# 截图
print('screenshot begin.')
index = 0
while mainloop.is_alive():
x = root.winfo_rootx() + canvas.winfo_x() + margin
y = root.winfo_rooty() + canvas.winfo_y() + margin
x1 = x + canvas.winfo_width() - margin
y1 = y + canvas.winfo_height() - margin
ImageGrab.grab().crop((x, y, x1, y1)).save(file_fm % index)
sleep(timespan)
index += 1
ImageGrab.grab().crop((x, y, x1, y1)).save(file_fm % 9999)
print('screenshot end.')
def set_up_window():
window = turtle.Screen()
window.bgcolor("lightgreen")
window.title("SHAPE PRESENTATION")
# Show window in foreground.
foreground = Screen()
rootwindow = foreground.getcanvas().winfo_toplevel()
rootwindow.call('wm', 'attributes', '.', '-topmost', '1')
rootwindow.call('wm', 'attributes', '.', '-topmost', '0')
def one_turtle_shot(file, margin=10):
'''
获取一张turtle界面截图
file : jpg格式文件名
margin : 窗口边界
'''
# 获取截图范围
screen = Screen()
canvas, root = screen.getcanvas(), screen._root
# 截图
x = root.winfo_rootx() + canvas.winfo_x() + margin
y = root.winfo_rooty() + canvas.winfo_y() + margin
x1 = x + canvas.winfo_width() - margin
y1 = y + canvas.winfo_height() - margin
ImageGrab.grab().crop((x, y, x1, y1)).save(file)
def main():
# Set the window size
WIDTH, HEIGHT = 128, 128
# Init the screen to be able to change default size
screen = Screen()
screen.setup(WIDTH, HEIGHT)
# set the pointer position
screen.setworldcoordinates(-64, -64, 64, 64)
turtle = Turtle()
# Hide the pointer to be able to draw quick
turtle.hideturtle()
face(64, turtle)
twoEyes('white', 'black', 8, 4, turtle)
nose(8, turtle)
mouse(12, turtle)
# screen.exitonclick()
cv = screen.getcanvas()
cv.postscript(file="test.ps", colormode='color')
for p in plist:
p.forward(l)
q = p.clone()
p.left(a)
q.right(a)
lst.append(p)
lst.append(q)
for x in tree(lst, l * f, a, f):
yield None
def maketree():
p = Turtle()
p.pencolor("green")
p.setundobuffer(None)
p.hideturtle()
p.speed(0)
p.tracer(30, 0)
p.left(90)
p.penup()
p.forward(-210)
p.pendown()
t = tree([p], 200, 65, 0.6375)
for x in t:
pass
s = Screen()
maketree()
print s.getcanvas().postscript()
canvas.xview_scroll(1, "units")
turtle.setx(turtle.xcor() + MAGNIFICATION)
def move_up():
canvas.yview_scroll(-1, "units")
turtle.sety(turtle.ycor() + MAGNIFICATION)
def move_down():
canvas.yview_scroll(1, "units")
turtle.sety(turtle.ycor() - MAGNIFICATION)
screen = Screen()
width, height = screen.screensize()
screen.screensize(width * MAGNIFICATION, height * MAGNIFICATION)
canvas = screen.getcanvas()
canvas.config(xscrollincrement=str(MAGNIFICATION))
canvas.config(yscrollincrement=str(MAGNIFICATION))
turtle.width(MAGNIFICATION)
turtle.resizemode('auto')
screen.onkey(move_left, "Left")
screen.onkey(move_right, "Right")
screen.onkey(move_up, "Up")
screen.onkey(move_down, "Down")
screen.listen()
screen.mainloop()
def setBackground(self):
try:
self.t = Turtle()
self.t.shape("circle")
self.t.speed(15)
self.t.turtlesize(0.01)
self.w = get_monitors()[0].width
self.h = get_monitors()[0].height
Screen().setup(self.w, self.h, startx=0, starty=0)
except Exception as e:
print(e)
try:
del self.t
except:
pass
Screen().bye()
Screen().exitonclick()
self.t.screen.colormode(1.0)
COLOR = (uniform(0, 1), uniform(0, 1), uniform(0, 1)
) #(1,0,0)#(0.39, 0.57, 0.9258)
TARGET = (uniform(0, 1), uniform(0, 1), uniform(0, 1)
) #(1,1,0) #(0.5625, 0.9297, 0.5625)
screen = Screen()
screen.tracer(False)
#print(screen.window_width(), screen.window_height())
#screen.screensize(1980,1024)
#screen.setup(width=1.0, height=1.0)
canvas = screen.getcanvas()
root = canvas.winfo_toplevel()
root.overrideredirect(1)
WIDTH, HEIGHT = get_monitors()[0].width, get_monitors(
)[0].height #screen.window_width(), screen.window_height()
deltas = [(hue - COLOR[index]) / HEIGHT
for index, hue in enumerate(TARGET)]
self.t.color(COLOR)
self.t.penup()
self.t.goto(-WIDTH / 2, HEIGHT / 2)
self.t.pendown()
direction = 1
for distance, y in enumerate(range(HEIGHT // 2, -HEIGHT // 2, -1)):
self.t.forward(WIDTH * direction)
self.t.color([
COLOR[i] + delta * distance for i, delta in enumerate(deltas)
])
self.t.sety(y)
direction *= -1
screen.tracer(True)
self.t.screen.colormode(255)
for p in plist:
p.forward(l)
q = p.clone()
p.left(a)
q.right(a)
lst.append(p)
lst.append(q)
for x in tree(lst, l * f, a, f):
yield None
def maketree():
p = Turtle()
p.pencolor("#697C82")
p.setundobuffer(None)
p.hideturtle()
p.speed(0)
p.tracer(30, 0)
p.left(90)
p.penup()
p.forward(-210)
p.pendown()
t = tree([p], 200, 65, 0.6375)
for x in t:
pass
s = Screen()
maketree()
print s.getcanvas().postscript()
from turtle import Screen, Turtle
from tkinter import *
from math import sqrt
import hangmanmodel
from pynput import keyboard
from pynput.keyboard import Key
import turtle
import random
from alphabet import alphabet
canvas = Screen()
inp = simpledialog.askstring("Input",
"What is your word?",
parent=canvas.getcanvas())
hangmanmodel.start(inp)
canvas.setup(1000, 750, None, None)
myPen = turtle.Turtle()
myPen.hideturtle()
myPen.speed(0)
window = turtle.Screen()
window.bgcolor("#ffffff")
myPen.pensize(2)
def displayMessage(message, fontSize, color, x, y):
myPen.color(color)
message = message.upper()
for character in message:
if character in alphabet:
class TurtlePaint():
def __init__(self, settings):
self.t1 = Turtle() # main turtle
self.t2 = Turtle() # draws color bar
self.t3 = Turtle() # selects current color
self.t4 = Turtle() # draws tool bar border
self.t5 = Turtle() # makes shape stamps
self.t6 = Turtle() # selects current shape
self.t7 = Turtle() # refers to instructions
self.t8 = Turtle() # selects current fillcolor
self.s = Screen()
self.instructions = {
"b": "begin filling",
"c": "clear all",
"e": "end filling",
"f": "change fillcolor",
"h": "turn left",
"j": "go backward",
"k": "go forward",
"l": "turn right",
"p": "pen up / pen down",
"s": "save picture",
"t": "change turtle shape",
"u": "undo last drawing",
"space": "change pencolor",
"arrow_up": "increase pensize",
"arrow_down": "decrease pensize"
}
self.v = VolumeBar(settings.get("start_volume_bar"),
settings.get("max_pensize"), self.s)
self.toggler = StringToggler(settings.get("start_pendown"),
settings.get("start_penup"), "pen down",
"pen up", self.s)
self.colors = [
"green", "red", "yellow", "pink", "blue", "lightblue", "orange",
"purple", "black", "white"
]
self.fillcolors = [
"green", "red", "yellow", "pink", "blue", "lightblue", "orange",
"purple", "black", "white"
]
self.shapes = [
"turtle", "triangle", "circle", "square", "arrow", "classic"
]
self.settings = settings
self.setup()
def setup(self):
self.t1.speed(0)
self.t1.resizemode("auto") # turtlesize increases with pensize
self.t2.hideturtle()
self.t3.hideturtle()
self.t4.hideturtle()
self.t5.hideturtle()
self.t6.hideturtle()
self.t7.hideturtle()
self.t8.hideturtle()
self.s.screensize(
settings.get("screen_dims")[0],
settings.get("screen_dims")[1]) # space for turtle
self.s.setup(
settings.get("screen_dims")[0] * 1.1,
settings.get("screen_dims")[1] * 1.1) # actual screen size
self.s.cv._rootwindow.resizable(False, False)
self.s.title(self.settings.get("title"))
self.draw_color()
self.v.draw_volume_bar()
self.draw_toolbar()
self.draw_shapes()
self.refer_to_instructions()
self.v.fill_volume_bar(self.t1.pensize() /
self.settings.get("max_pensize"))
self.register_callbacks()
def register_callbacks(self):
self.t1.onclick(self.t1.goto, 1)
self.s.onkey(self.pen_change, "p")
self.s.onkey(self.change_color, "space")
self.s.onkey(self.increase_pensize, "Up")
self.s.onkey(self.decrease_pensize, "Down")
self.s.onscreenclick(self.go_to, 1)
self.t1.ondrag(self.go_to, 1)
self.s.onkey(self.screen_exit_handler, "Escape")
self.s.onkey(self.screen_save_handler, "s")
self.s.onkeypress(self.undo_drawings, "u")
self.s.onkey(self.clear_all, "c")
self.s.onkey(self.change_shape, "t")
self.s.onkeypress(self.move_down, "j")
self.s.onkey(self.show_instructions, "?")
self.s.onkeypress(self.move_up, "k")
self.s.onkeypress(self.turn_left, "h")
self.s.onkeypress(self.turn_right, "l")
self.s.onkey(self.t1.begin_fill, "b")
self.s.onkey(self.t1.end_fill, "e")
self.s.onkey(self.change_fillcolor, "f")
self.s.listen()
def screen_exit_handler(self):
print("[debug] got ESC, quitting")
exit(0)
def screen_save_handler(self):
print("[debug] trying to save canvas to a pdf file")
name = self.s.textinput("Save a Screenshot to PDF",
"Please enter a filename (without .pdf): ")
self.s.getcanvas().postscript(file="tmp.ps", colormode="color")
if platform.system() == "Windows":
cmd = r'c:\Program Files\Git\usr\bin\bash.exe'
p = subprocess.Popen(
[cmd, "ps2pdf", "tmp.ps", "{}.pdf".format(name)], shell=True)
else: # we're actually on a good OS here
p = subprocess.Popen(["ps2pdf tmp.ps {}.pdf".format(name)],
shell=True)
ret = p.wait()
if ret == 0:
os.remove("tmp.ps")
self.s.listen() # required to re-focus onto turtle
def show_instructions(self):
win = Tk()
row = 0
column = 0
for instruction in self.instructions:
Label(win, text=instruction).grid(row=row,
column=column,
sticky="W",
ipadx=10)
column += 1
Label(win,
text=self.instructions.get(instruction)).grid(row=row,
column=column,
sticky="W",
ipadx=10)
row += 1
column = 0
def pen_change(self):
if self.t1.isdown():
self.t1.penup()
self.toggler.toggle()
else:
self.t1.pendown()
self.toggler.toggle()
def draw_selector(self, turtle, pensize):
turtle.clear()
turtle.pensize(pensize)
for _ in range(4):
turtle.fd(30)
turtle.left(90)
def draw_color(self):
self.s.tracer(False)
x = -410
pos = (x, 310)
self.t2.penup()
self.t3.penup()
self.t8.penup()
self.t2.goto(pos)
self.t3.goto(-50, 310)
self.t8.goto(-35, 295)
self.t2.right(90)
self.t3.right(90)
self.t2.pendown()
self.t3.pendown()
self.t8.pendown()
self.t2.pensize(1)
for color in self.colors:
# determine colors
if color == "white":
self.t2.pencolor("black")
self.t2.fillcolor("white")
else:
self.t2.color(color)
# draw square
self.t2.begin_fill()
for _ in range(4):
self.t2.fd(30)
self.t2.left(90)
# pen up, go to next square, pen down
self.t2.end_fill()
self.t2.penup()
x += 40
self.t2.goto(x, 310)
self.t2.pendown()
self.s.tracer(True)
def change_color(self):
if self.t3.pos()[0] >= -50:
x = -410
else:
x = self.t3.pos()[0] + 40
color = self.colors.pop(0)
self.t1.pencolor(color)
self.colors.append(color)
self.s.tracer(False)
if color == "black":
self.t3.pencolor("dim gray")
else:
self.t3.pencolor("black")
self.t3.penup()
self.t3.goto(x, 310)
self.t3.pendown()
self.draw_selector(self.t3, 4)
self.s.tracer(True)
def change_fillcolor(self):
self.s.tracer(False)
if self.t8.pos()[0] >= -36:
x = -395
else:
x = self.t8.pos()[0] + 40
fillcolor = self.fillcolors.pop(0)
self.t1.fillcolor(fillcolor)
self.fillcolors.append(fillcolor)
if fillcolor == "black":
self.t8.pencolor("dim gray")
else:
self.t8.pencolor("black")
self.t8.penup()
self.t8.goto(x, 295)
self.t8.pendown()
self.t8.clear()
self.t8.dot(10)
self.s.tracer(True)
def increase_pensize(self):
pensize = self.t1.pensize() + self.settings.get("pensize_stepsize")
if pensize <= self.settings.get("max_pensize"):
self.t1.pensize(pensize)
self.v.fill_volume_bar(self.t1.pensize() /
self.settings.get("max_pensize"))
def decrease_pensize(self):
pensize = self.t1.pensize() - self.settings.get("pensize_stepsize")
if pensize >= 1:
self.t1.pensize(pensize)
self.v.fill_volume_bar(self.t1.pensize() /
self.settings.get("max_pensize"))
def draw_toolbar(self):
self.s.tracer(False)
self.t4.penup()
self.t4.goto(-420, 260)
self.t4.pensize(3)
self.t4.pendown()
self.t4.fd(840)
self.t4.penup()
self.t4.goto(-420, -300)
self.t4.pendown()
self.t4.fd(840)
self.s.tracer(True)
def draw_shapes(self):
self.s.tracer(False)
self.t5.penup()
self.t5.resizemode("user")
self.t5.shapesize(0.9, 0.9)
x = 200
self.t5.fillcolor("white")
for shape in self.shapes:
self.t5.shape("turtle")
self.t5.goto(x, 295)
self.t5.shape(shape)
self.t5.stamp()
x += 40
self.t6.penup()
self.t6.goto(389, 280)
self.s.tracer(True)
def change_shape(self):
self.s.tracer(False)
shape = self.shapes.pop(0)
self.t1.shape(shape)
self.shapes.append(shape)
if self.t6.pos()[0] >= 380:
x = 189
elif shape == "circle":
x = self.t6.pos()[0] + 38
elif shape == "arrow":
x = self.t6.pos()[0] + 43
elif shape == "classic":
x = self.t6.pos()[0] + 32
elif shape == "triangle":
x = self.t6.pos()[0] + 39
else:
x = self.t6.pos()[0] + 40
self.t6.penup()
self.t6.goto(x, 280)
self.t6.pendown()
self.t6.pencolor("green")
self.draw_selector(self.t6, 2)
self.s.tracer(True)
def refer_to_instructions(self):
self.s.tracer(False)
self.t7.penup()
self.t7.goto(-410, -320)
self.t7.pendown()
self.t7.write("press '?' for instructions")
self.s.tracer(True)
def move_up(self):
self.t1.fd(10)
def move_down(self):
self.t1.backward(10)
def turn_left(self):
heading = self.t1.heading()
if heading == 355:
self.t1.setheading(0)
else:
heading += 5
self.t1.setheading(heading)
def turn_right(self):
heading = self.t1.heading()
if heading == 0:
self.t1.setheading(355)
else:
heading -= 5
self.t1.setheading(heading)
def go_to(self, x, y):
if y < 258 and y > -300:
self.t1.goto(x, y)
def undo_drawings(self):
self.t1.undo()
def clear_all(self):
self.t1.clear()
def mainloop(self):
mainloop()
from turtle import Screen
from snake import Snake
from score_board import ScoreBoard
from food import Food
import time
delay = 0.1
wn = Screen()
wn.title("Snake Game")
wn.bgcolor("black")
wn.setup(width=600, height=600)
#Accesses the X on the GUI
canvas = wn.getcanvas()
root = canvas.winfo_toplevel()
#Snake
snake = Snake()
#Food
food = Food()
#Score Board
scoreboard = ScoreBoard()
#Turn off the screen updates
wn.tracer(0)
#Keyboard bindings
wn.listen()
from turtle import Turtle, Screen
bg_colour = input("Enter the desired background colour: ")
wn = Screen()
rootwindow = wn.getcanvas().winfo_toplevel()
rootwindow.call('wm', 'attributes', '.', '-topmost', '1')
rootwindow.call('wm', 'attributes', '.', '-topmost', '0')
wn.bgcolor(bg_colour) # Set the window background color
wn.title("Hello, Tess!") # Set the window title
tess = Turtle()
tess.color("blue") # Tell tess to change her color
tess.pensize(3) # Tell tess to set her pen width
tess.forward(50)
tess.left(120)
tess.forward(50)
wn.mainloop()
class NCSimVisualizer:
def __init__(self, cfg_os):
# Create Screen Object
self.screen = Screen()
# Add app icon
LOGO_PATH = "assets/favicon.ico"
# do not forget "@" symbol and .xbm format for Ubuntu
LOGO_LINUX_PATH = "@assets/favicon_linux.xbm"
# Use the same Tk root with turtle:
# noinspection PyProtectedMember
# assert isinstance(self.screen._root, tk.Tk) # True
# noinspection PyProtectedMember
self.root = self.screen.getcanvas().winfo_toplevel()
self.root.title("Network Coding Simulator")
if cfg_os.lower() == "linux":
self.root.iconbitmap(LOGO_LINUX_PATH)
else:
self.root.iconbitmap(LOGO_PATH)
# tkinter use same root
self.controls = tk.Frame(self.root)
# Create Screen Layout Cursor
self.layout_cursor = Turtle()
self.layout_cursor.ht()
self.layout_cursor.penup()
self.layout_cursor.pensize(3)
self.layout_cursor.color("slate grey")
# Create Screen Message Cursor
self.msg_cursor = Turtle()
self.msg_cursor.ht()
self.msg_cursor.penup()
self.msg_cursor.color("midnight blue")
# Create Screen coverage Cursor
self.coverage_cursor = Turtle()
self.coverage_cursor.ht()
self.coverage_cursor.penup()
self.coverage_cursor.pensize(2)
self.coverage_cursor.color("saddle brown")
# Create Screen Send Packet Cursor
self.snd_pckt = Turtle()
self.snd_pckt.ht()
self.snd_pckt.penup()
self.snd_pckt.pensize(2)
self.snd_pckt.color("saddle brown")
# Call Screen Init Method
self.screen_init()
def screen_init(self):
# Set Screen Dimensions and Coloring
self.screen.setup(TOTAL_WIDTH, TOTAL_HEIGHT)
self.screen.bgcolor(SCREEN_BGCOLOR)
self.layout_cursor.color("slate grey")
self.layout_cursor.setposition(-((TOTAL_WIDTH / 2) - SCREEN_MARGIN),
-((TOTAL_HEIGHT / 2) - SCREEN_MARGIN))
self.layout_cursor.speed(8)
self.layout_cursor.pendown()
self.layout_cursor.fd(SCREEN_WIDTH)
self.layout_cursor.rt(-90)
self.layout_cursor.fd(SCREEN_HEIGHT)
self.layout_cursor.rt(-90)
self.layout_cursor.fd(SCREEN_WIDTH)
self.layout_cursor.rt(-90)
self.layout_cursor.fd(SCREEN_HEIGHT)
self.layout_cursor.setheading(90)
self.layout_cursor.fd(MESSAGE_MARGIN)
self.layout_cursor.setheading(0)
self.layout_cursor.fd(SCREEN_WIDTH)
self.layout_cursor.penup()
self.layout_cursor.speed("fastest")
self.layout_cursor.color("midnight blue")
x_cor = 0
y_cor = int((TOTAL_HEIGHT / 2) - (3 / 4 * HEAD_MARGIN))
self.layout_cursor.setposition(x_cor, y_cor)
self.layout_cursor.write(f"{SCREEN_HEADER}",
align="Center",
font=("Calibri", HEADER_FONT_SIZE, "bold"))
x_cor = 20 - (int(SCREEN_WIDTH / 2))
y_cor = (int(TOTAL_HEIGHT / 2)) - (HEAD_MARGIN + 40)
self.layout_cursor.setposition(x_cor, y_cor)
self.layout_cursor.write(f"Topology: {TOPOLOGY_TYPE.title()}",
align="Left",
font=("Calibri", TEXT_FONT_SIZE, "bold"))
x_cor = (int(SCREEN_WIDTH / 2)) - 20
y_cor = (int(TOTAL_HEIGHT / 2)) - (HEAD_MARGIN + 40)
self.layout_cursor.setposition(x_cor, y_cor)
self.layout_cursor.write(f"Nodes: {NUM_OF_NODES}",
align="Right",
font=("Calibri", TEXT_FONT_SIZE, "bold"))
self.visual_output_msg("This where the text message appears")
# Stop Auto-update Screen changes
self.screen.tracer(0)
def visual_output_msg(self, message):
x_cor = 20 - (int(SCREEN_WIDTH / 2))
y_cor = (SCREEN_MARGIN + 15) - (int(TOTAL_HEIGHT / 2))
self.msg_cursor.setposition(x_cor, y_cor)
self.msg_cursor.clear()
self.msg_cursor.write(f"{message}",
align="Left",
font=("Calibri", TEXT_FONT_SIZE, "bold"))
def visual_send_packet(self, tx_node, rx_nodes):
# draw arrow for all neighbors
for rx_node in rx_nodes:
self.snd_pckt.setposition(tx_node.pos())
self.snd_pckt.pendown()
self.snd_pckt.setheading(self.snd_pckt.towards(rx_node.pos()))
self.snd_pckt.setposition(rx_node.pos())
self.snd_pckt.bk(11)
# Drawing arrow head
self.snd_pckt.left(45)
self.snd_pckt.backward(10)
self.snd_pckt.forward(10)
self.snd_pckt.right(90)
self.snd_pckt.backward(10)
self.snd_pckt.penup()
def clear_send_packets(self):
self.snd_pckt.pd()
self.snd_pckt.clear()
self.snd_pckt.pu()
def show_coverage(self, node):
self.coverage_cursor.goto(node.xcor(), node.ycor() - node.coverage)
self.coverage_cursor.pendown()
self.coverage_cursor.circle(node.coverage)
self.coverage_cursor.penup()
self.coverage_cursor.goto(node.pos())
def hide_coverage(self):
self.coverage_cursor.pendown()
self.coverage_cursor.clear()
self.coverage_cursor.penup()
def screen_refresh(self):
self.screen.update()
def mainloop(self):
while True:
try:
self.root.update()
self.root.update_idletasks()
except Exception as exp:
print(exp)
print("bye")
break
score = Scoreboard()
# Game speed parameters
default_game_speed = 0.02
game_acceleration = 1.05
# Initialize settings
game_speed = default_game_speed
paddle_hit = False
game_is_on = True
s.update()
time.sleep(1)
# Keyboard input
s.listen()
s.getcanvas().bind("<Up>", r_paddle.move_up_true)
s.getcanvas().bind("<KeyRelease-Up>", r_paddle.move_up_false)
s.getcanvas().bind("<Down>", r_paddle.move_down_true)
s.getcanvas().bind("<KeyRelease-Down>", r_paddle.move_down_false)
s.getcanvas().bind("<z>", l_paddle.move_up_true)
s.getcanvas().bind("<KeyRelease-z>", l_paddle.move_up_false)
s.getcanvas().bind("<s>", l_paddle.move_down_true)
s.getcanvas().bind("<KeyRelease-s>", l_paddle.move_down_false)
while game_is_on:
time.sleep(game_speed)
r_paddle.move_up(r_paddle.ycor())
l_paddle.move_up(l_paddle.ycor())
r_paddle.move_down(r_paddle.ycor())
l_paddle.move_down(l_paddle.ycor())
ball.forward(5)
