1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
# -*- coding: utf-8 -*-
################################################"
from time import sleep
from threading import Thread
class core(Thread):
def __init__(self):
Thread.__init__(self)
self.alive = True
self.db = []
def pause(self,event=None):
self.alive = False
def unpause(self,event=None):
self.alive = True
for key in self.db:
key.pressed = False
self.run()
def add(self,key):
self.db.append(key)
def kill(self,key):
if key in self.db:
self.db.remove(key)
def run(self):
while self.alive:
l = len(self.db)
for key in self.db:
key.run_()
sleep(0.001)
sleep(0.002)
class Key:
motor = core()
def __init__(self,boss,key,func,slp=0.02):
"""Constructeur de classe Key pour des bindings multiples"""
self.boss = boss
self.func = func
self.slp = slp
self.alive = True
self.pressed = False
#self.boss.bind("<FocusIn>",self.unpause) #Pour les versions multi-Thread
#self.boss.bind("<FocusOut>",self.pause) #Pour les versions multi-Thread
self.k_p = "<KeyPress "+key+">" #sauvegarde le nom de l'evenement pour Press
self.k_r = "<KeyRelease "+key+">" #sauvegarde le nom de l'evenement pour Release
self.f_p = boss.bind(self.k_p,self.press) #fait un binding(attend un appui de touche)
self.motor.add(self) #La jour la cle au moteur des Keys
if len(self.motor.db)==1: #Si c'est la premiere instance alors on demarre le moteur
self.boss.after(250,self.motor.run)
self.boss.bind("<FocusIn>",self.motor.unpause)
self.boss.bind("<FocusOut>",self.motor.pause)
def set(self,slp=0.005):
"""Definit le temps de repos de la Key (Non implemente)"""
self.slp = slp
def press(self,event=None):
"""Est appele lorsque la touche est presse"""
self.boss.unbind(self.k_p,self.f_p)
self.f_r = self.boss.bind(self.k_r,self.release)
self.pressed = True
self.func()
self.run_()
def release(self,event=None):
"""Est appele lorsque la touche est relache"""
self.boss.unbind(self.k_r)
self.f_p = self.boss.bind(self.k_p,self.press)
self.pressed = False
def run_(self,arg=None):
"""Effectue les tache necessaire ..."""
#Dans les versions ulterieures chaque instance de Key sera
#un Thread et a la place de if on aura un while
if self.alive:
try:
self.boss.update()
if self.pressed:
self.func()
except:
self.alive = False
self.motor.kill(self)
#Le sleep(self.rps) sera donc independant de processus
#en cours.
def pause(self,event=None):
"""met la touche en pause"""
self.alive = False
self.motor.kill(self)
def unpause(self,event=None):
"""reactive la touche"""
self.alive = True
self.motor.add(self)
#self.run()
###################################################
from Tkinter import *
class Auto() :
def __init__(self,can=None) :
self.can = can
self.spitze = (100,100,110,110,90,110)
self.vorderteil = (102,110,102,114,106,114,106,118,102,118,102,
122,98,122,98,118,94,118,94,114,98,114,98,110)
self.radt_vl = (94,114,94,112,90,112,90,120,94,120,94,118)
self.radt_vr = (106,114,106,112,110,112,110,120,106,120,106,118)
self.kern = (106,122,110,126,110,134,106,138,94,138,90,134,90,126,94,122)
self.sitz = (102,128,102,132,98,132,98,128)
self.hinterteil = (102,138,102,142,106,142,106,146,102,146,102,
150,98,150,98,146,94,146,94,142,98,142,98,138)
self.radt_hl = (94,142,94,140,90,140,90,148,94,148,94,146)
self.radt_hr = (106,142,106,140,110,140,110,148,106,148,106,146)
self.flugel = (108,150,110,154,90,154,92,150)
self.db = [] #Speicht die Bild für die Motion.
def draw_auto(self):
draw = self.can.create_polygon
num = draw(*self.spitze,fill="red")
self.db.append(num)
num = draw(*self.vorderteil,fill="red")
self.db.append(num)
num = draw(*self.radt_vl,fill="black")
self.db.append(num)
num = draw(*self.radt_vr,fill="black")
self.db.append(num)
num = draw(*self.kern,fill="red")
self.db.append(num)
num = draw(*self.sitz,fill="black")
self.db.append(num)
num = draw(*self.hinterteil,fill="red")
self.db.append(num)
num = draw(*self.radt_hl,fill="black")
self.db.append(num)
num = draw(*self.radt_hr,fill="black")
self.db.append(num)
num = draw(*self.flugel,fill="red")
self.db.append(num)
def move(self,x,y):
for itm in self.db:
self.can.move(itm,x,y)
def left(self,event=None):
self.move(-0.5,0)
def right(self,event=None):
self.move(0.5,0)
def up(self,event=None):
self.move(0,-1)
def down(self,event=None):
self.move(0,1)
#formel_1= Auto()
if __name__ == "__main__":
fenster= Tk()
canvas= Canvas(fenster, height=200, width=200, bg='gold')
rennbahn= canvas.create_polygon(65,0, 135,0, 135,200, 65,200, fill='ivory')
canvas.pack()
F1 = Auto(canvas)
F1.draw_auto()
"""
fenster.bind("<Up>",F1.up)
fenster.bind("<Down>",F1.down)
fenster.bind("<Left>",F1.left)
fenster.bind("<Right>",F1.right)
"""
Key(fenster,"Up",F1.up)
Key(fenster,"Down",F1.down)
Key(fenster,"Left",F1.left)
Key(fenster,"Right",F1.right)
mainloop() |
