def start(self):
     if self.__running:
         unschedule(self.update)
         self.__running = False
     else:
         schedule_interval(self.update, self.speed)
         self.__running = True

 def visible(self, visible):
     self._visible = visible
     clock.unschedule(self._blink)
     if visible and self._active and self.PERIOD:
         clock.schedule_interval(self._blink, self.PERIOD)
         self._blink_visible = False  # flipped immediately by next blink
     self._blink(0)

 def pause(self):
     if not self.playing: return
     clock.unschedule(self.update)
     self.player.pause()
     self.control.play.setVisible(True)
     self.control.pause.setVisible(False)
     self.playing = False

    def game_exit_callback(self, *args):
        if self._overlay:
            unschedule(self._overlay.update)
            self._overlay = None

        self.win.pop_handlers()
        self.win.close()

    def leave(self):
        # get the end time
        self.end_time = now()
        
        # update the parent state time to actual elapsed time if necessary
        if self.duration < 0:
            if isinstance(self, ParentState):
                # advance the duration the children moved the this parent
                duration = self.state_time-self.start_time
            else:
                # advance the duration of this state
                duration = self.end_time-self.start_time
            self.advance_parent_state_time(duration)

        # remove the callback from the schedule
        clock.unschedule(self.callback)

        # notify the parent that we're done
        self.active = False
        self.done = True
        if self.parent:
            self.parent.check = True

        # call custom leave code
        self._leave()

        # write log to the state log
        #print self.get_log()
        if self.save_log:
            dump([self.get_log()],self.get_log_stream())
        pass

 def stopRepeat(self):
     if self.delay_timer is not None:
         self.delay_timer.cancel()
         self.delay_timer = None
     if self.repeating:
         clock.unschedule(self.repeat)
     self.repeating = False

def village_scene(dt):
    clock.unschedule(spawn_troll)
    s.Narration("This time")
    s.Narration("They will say")
    s.Title("You are the Villain")
    clock.schedule_interval(village_callback, 5)
    for i in range(counter + 4):
        s.Villager(on_death = decrement_counter)

        def on_rerun_menu():
            unschedule(func=self.update)

            #reset current handler
            self.win.pop_handlers()
            #and setup update handler
            self.win.push_handlers(self.menu)
            self.menu.start_bgrn_animation()

 def _update_schedule(self):
     clock.unschedule(self.dispatch_events)
     if self._playing and self._sources:
         interval = 1000.0
         if self._sources[0].video_format:
             interval = min(interval, 1 / 24.0)
         if self._audio:
             interval = min(interval, self._audio.UPDATE_PERIOD)
         clock.schedule_interval_soft(self.dispatch_events, interval)

    def in_transition(self):
        for index, transition in enumerate(self.queue):
            if transition["phase"] == 0:
                del self.queue[index]

        if len(self.queue) <= 0:
            clock.unschedule(self.tick)

        return len(self.queue) > 0

def scene2(dt):
    print "scene2"
    s.Narration('Why me?')
    s.Narration('Alone')
    s.Narration('Why me?')
    s.Narration('Alone')
    s.Narration('This is not fair')
    clock.unschedule(spawn_troll)
    clock.schedule_interval(spawn_troll, 3)
    clock.schedule_once(scene3, 20)

    def delete(self):
        """Force immediate removal of the sprite from video memory.

        This is often necessary when using batches, as the Python garbage
        collector will not necessarily call the finalizer as soon as the
        sprite is garbage.
        """
        if self._animation:
            clock.unschedule(self._animate)
        self._vertex_list.delete()
        self._vertex_list = None

    def test_unschedule(self):
        clock.set_default(clock.Clock())
        clock.schedule(self.callback)

        result = clock.tick()
        self.assertTrue(result == self.callback_dt)
        self.callback_dt = None
        time.sleep(1)
        clock.unschedule(self.callback)

        result = clock.tick()
        self.assertTrue(self.callback_dt == None)

    def test_schedule_multiple(self):
        clock.set_default(clock.Clock())
        clock.schedule(self.callback)
        clock.schedule(self.callback)
        self.callback_count = 0

        clock.tick()
        self.assertTrue(self.callback_count == 2)
        clock.unschedule(self.callback)

        clock.tick()
        self.assertTrue(self.callback_count == 2)

    def update(self, dt):
        self._total_time += dt
        alpha = self._total_time / float(self._duration) 

        self._label.begin_update()
        self._label.x = alpha * (self._x1 - self._x0) + self._x0
        self._label.y = alpha * (self._y1 - self._y0) + self._y0
        self._label.font_size = alpha * (self._end_font_size - self._init_font_size) + self._init_font_size
        self._label.end_update()

        if self._total_time > self._duration:
            self.window.remove_handlers(self)
            clock.unschedule(self.update)

    def _set_image(self, img):
        if self._animation is not None:
            clock.unschedule(self._animate)
            self._animation = None

        if isinstance(img, image.Animation):
            self._animation = img
            self._frame_index = 0
            self._set_texture(img.frames[0].image.get_texture())
            self._next_dt = img.frames[0].duration
            clock.schedule_once(self._animate, self._next_dt)
        else:
            self._set_texture(img.get_texture())
        self._update_position()

    def delete(self):
        """Force immediate removal of the sprite from video memory.

        This is often necessary when using batches, as the Python garbage
        collector will not necessarily call the finalizer as soon as the
        sprite is garbage.
        """
        if self._animation:
            clock.unschedule(self._animate)
        self._vertex_list.delete()
        self._vertex_list = None
        self._texture = None

        # Easy way to break circular reference, speeds up GC
        self._group = None

    def callborg(dt):
        global ANS, NBSEC
        if ANS:
            c = ANS.pop()
            console.write(c)
            console._caret.position = len(console._document.text)

        elif ANS==[]:
            console.write (' ',attributes={'color': (255, 255, 255, 255)})
            console.write ('\n')
            console.prompt()
            #console._document.delete_text(0, len(console._document.text)-1)
            #console._prompt_end = 0
            ANS = None
            clock.unschedule(callborg)
        else: ANS=None

    def run_snake(self, *args):
        if self._overlay:
            unschedule(self._overlay.update)
            self._overlay = None

        #reset current handlers
        self.win.pop_handlers()

        self.gameInfo.pause = False
        self.gameField.reset()

        #setup new handlers
        self.win.push_handlers(self.gameField)

        #and setup update handler
        self._update_interval = Game.INITIAL_UPDATE_INTERVAL
        schedule_interval(func=self.update,interval=self._update_interval)

def play(level):
    view = FlatView.from_window(w, layers=[level, effectlayer, rocketlayer])

    # set rocket start
    for col in level.cells:
        for cell in col:
            if 'player-start' in cell.properties:
                rocket.midtop = cell.midtop

    clock.schedule(rocket.update)
    rocket.properties.update(dict(dx=0, dy=0, done=0))

    # run game
    while not (w.has_exit or rocket.properties['done']):
        dt = clock.tick()
        w.dispatch_events()
        view.fx, view.fy = rocket.center
        view.clear((.2, .2, .2, .2))
        view.draw()
        fps.draw()
        w.flip()

    # put up a message
    done = rocket.properties['done']
    if not done:
        return
    if done == 1:
        text = 'YAY YOU LANDED!'
    if done == 2:
        text = 'BOO YOU CRASHED!'
    text += '  (press [escape] to continue)'
    sprite = TextSprite(font, text, color=(1., 1., 1., 1.))
    sprite.x, sprite.y = w.width / 2 - sprite.width / \
        2, w.height / 2 - sprite.height / 2
    w.has_exit = False
    while not w.has_exit:
        dt = clock.tick()
        w.dispatch_events()
        view.clear((.2, .2, .2, .2))
        view.draw()
        sprite.draw()
        w.flip()

    clock.unschedule(rocket.update)
    if boom in effectlayer.sprites:
        effectlayer.sprites.remove(boom)