Пример #1
0
class App(object):

    def __init__(self):
        self.render_asap = False;
        self.app_should_exit = False
        self.root = Tk()
        self.scene = None
        self.lastUpdateMoment = 0
        self.renderingTechniq = RENDER_ON_MAINLOOP
        
    def setAppExit(self):
        self.app_should_exit = TRUE

    def initialize(self):
        speller = GazeSpeller()
        tracker = self._ckeckAvailableTracker()
        canvas = self._initializeCanvas()
        
        if isinstance(tracker,MouseTracker):
            canvas.bind('<Motion>',tracker.onMotion) # use this to let the tracker get updates from the mouse event without actual get knowledge of the GUIs
            # it's named "inversion of control"

        self.scene = Scene(canvas, tracker, speller)
        self.scene.initialize(1)
    
    def startRendering(self):
        if self.renderingTechniq == RENDER_ON_MAINLOOP:
            self.runOnTkInterMainLoop()
        if self.renderingTechniq == RENDER_ON_TIMER_TICK:
            self.runOnExpectedFixedFramerate()
        
        sys.exit(0)
    
    def _ckeckAvailableTracker(self):
        #TODO check if tracker available if not use mouse
        return MouseTracker(self.root)

    def _initializeCanvas(self):
        self.root.attributes("-fullscreen", True)
        self.root.protocol("WM_DELETE_WINDOW", self.setAppExit)
        canvas = Canvas(self.root)
        canvas.pack(fill=BOTH, expand=YES)
        return canvas
    
    def _processRenderLoop(self, deltaTime, CallTkUpdates = False):
        self.scene.update(deltaTime)
        self.scene.render()
        if CallTkUpdates:
            self.root.update_idletasks() # render / drawing
            self.root.update() # perform processing of key events etc
    
    def _estimateFrameTime(self):
        currentMoment = time()
        deltaTime = currentMoment - self.lastUpdateMoment
        self.lastUpdateMoment = currentMoment
        return deltaTime

    # example rendering A
    def runOnExpectedFixedFramerate(self):
        self.lastUpdateMoment = time()
        while not self.app_should_exit:
            deltaTime = self._estimateFrameTime()
            self._processRenderLoop(deltaTime, CallTkUpdates = True)
            if not self.render_asap:
                sleep(self.scene.getExpectedUpdateTime())

    #example rendering B
    def runOnTkInterMainLoop(self):
        self._callUpdatingOnAfterCall();
        self.root.mainloop()
        
    def _callUpdatingOnAfterCall(self):
        deltaTime = self._estimateFrameTime()
        self._processRenderLoop(deltaTime)
        # uses a scheduler from tkinter GUI Mainloop - test
        # self.scene.getExpectedUpdateTime()
        self.root.after(1, self._callUpdatingOnAfterCall)