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 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
|
#! /usr/bin/python
# -*- coding:utf-8 -*-
THREADED = True
import Tkinter
import math
import time
from gui_threads import *
class States:
"""folds state into variable just to track typos you get using raw string"""
def __init__(self, name):
self._name = name
def __str__(self):
return self._name
st_init = States('init')
st_pause = States('pause')
st_run = States('run')
st_quit = States('quit')
ObjectProperties = {
# x y dx dy color
1 : [ 50, 100, 5, 30, "red"],
2 : [150, 100, 5, 30, "green"],
3 : [250, 100, 5, 30, "blue"],
4 : [350, 100, 5, 30, "black"],
}
class Rectangle(object):
def __init__(self, canvas, x, y, dx, dy, color):
self.xy = [(x, y), (x + dx, y), (x + dx, y + dy), (x, y + dy) ]
self.drawn_item = canvas.create_polygon(self.xy, fill=color)
self.center = complex( x + dx / 2, y + dy / 2)
self.arc = 0
self._step = (math.pi * 2) / 50
self.canvas = canvas
def rotate(self, **kwds):
""" rotate polygons by self._step
normally called in threads context"""
if THREADED:
gui_call = kwds.pop('gui_call')
"""compute angle and rotate each point of the polygon around its center
"""
self.arc += self._step
if self.arc >= math.pi * 2:
self.arc = 0
angle = complex(math.cos(self.arc), math.sin(self.arc))
newxy = []
for x, y in self.xy:
v = angle * (complex(x, y) - self.center) + self.center
newxy.append(v.real)
newxy.append(v.imag)
"""send command for execution in gui_mainloop context"""
if THREADED:
gui_call(Command(self.canvas.coords, self.drawn_item, *newxy))
else:
self.canvas.coords(self.drawn_item, *newxy)
"""prepare for next iteration"""
class GuiObject(GuiClient):
#not THREADED:class GuiObject():
button_names = ['start', 'pause', 'restart', 'quit']
NORMAL = Tkinter.NORMAL
DISABLED = Tkinter.DISABLED
buttons_state = dict(
init = [ NORMAL, DISABLED, DISABLED, DISABLED ],
start = [ DISABLED, NORMAL, DISABLED, NORMAL ],
pause = [ DISABLED, DISABLED, NORMAL, NORMAL ],
restart = [ DISABLED, NORMAL, DISABLED, NORMAL ],
quit = [ DISABLED, DISABLED, DISABLED, DISABLED ],
)
class GuiButton:
def __init__(self, frame, name, command, row, column):
self._button = Tkinter.Button(frame,
text="%s %d" % (name, row),
command=command)
self._button.grid(row=row, column=column)
def set_state(self, state):
self._button.config(state=state)
def set_buttons_state(self, b_event):
b_states = self.buttons_state[b_event]
for k, button_name in enumerate(self.button_names):
self.buttons[button_name].set_state(b_states[k])
def __init__(self, gui_server, name_id, frame, canvas, props):
#not THREADED: def __init__(self, name_id, frame, canvas, props):
if THREADED:
GuiClient.__init__(self, gui_server) # déclare client du server
self._frame = frame
self._name_id = name_id
self._canvas = canvas
self.buttons = dict()
row = name_id #TODO: name_id should not be same as row
for column, name in enumerate(self.button_names):
self.buttons[name] = GuiObject.GuiButton(frame, name,
getattr(self, 'command_%s' % name),
row, column)
self.rectangle = Rectangle(canvas, *props)
self.set_buttons_state('init')
self.state = st_init
def command_start(self):
assert self.state in [ st_init ]
if THREADED:
self.thread_start()
self.set_buttons_state('start')
self.state = st_run
def command_quit(self):
if THREADED:
self.thread_quit()
self.set_buttons_state('quit')
self.state = st_quit
def command_pause(self):
assert self.state in [ st_run ]
if self.state == st_run:
if THREADED:
self.thread_pause()
self.set_buttons_state('pause')
self.state = st_pause
def command_restart(self):
assert self.state in [ st_pause ]
if self.state == st_pause:
if THREADED:
self.thread_restart()
self.set_buttons_state('restart')
self.state = st_run
def visit_method(self, **kwds):
"""method called by thread.run
kwds should contains gui_call
"""
if THREADED:
gui_call = kwds.pop('gui_call')
self.rectangle.rotate(gui_call=gui_call)
else:
self.rectangle.rotate()
time.sleep(0.02)
gui_objects = dict()
quit_event = False
def on_delete_window():
global quit_event
if THREADED:
quit_event = True
for o in gui_objects.itervalues():
if o.state != st_quit:
o.command_quit()
sys.exit()
POLL_TIME = 200 # assume Ms
def server_poller(**kwds):
poll_timer = kwds.pop('poll_timer')
if THREADED:
poller_callback = kwds.pop('poller_callback')
gui_root = kwds.pop('gui_root')
def poller_routine():
global quit_event
if THREADED:
quit_event = poller_callback()
else:
for o in gui_objects.itervalues():
if o.state == st_run:
o.visit_method()
if not quit_event:
gui_root.after(poll_timer, poller_routine)
poller_routine()
if __name__ == "__main__":
root = Tkinter.Tk()
root.title('Objets tournants avec threads - v04')
root.geometry('700x200')
root.protocol("WM_DELETE_WINDOW", on_delete_window)
canvas = Tkinter.Canvas(root, bg="white")
canvas.pack(side=Tkinter.LEFT, expand=Tkinter.YES, fill=Tkinter.BOTH)
frame = Tkinter.Frame(root)
if THREADED:
gui_server = GuiServer(root,
poll_timer=POLL_TIME,
server_poller=server_poller) # start server
for id, props in ObjectProperties.iteritems(): # start clients
print "props= %s" % props
if THREADED:
gui_objects[id] = GuiObject(gui_server, id, frame, canvas, props)
else:
gui_objects[id] = GuiObject(id, frame, canvas, props)
frame.pack(side=Tkinter.RIGHT)
if not THREADED:
server_poller(poll_timer=POLL_TIME, gui_root=root)
root.mainloop() |
Partager