self.marked_val = elapsed

                    elapsed = self.marked_val + (time.time() - self.marked_time)

                    songnum, total = self.true_song_total

                t = -1

                if songnum == 1:

                    t = elapsed

                elif songnum == 0:

                    t = elapsed - total

                elif songnum == 2:

                    t = self.total_time.get() + elapsed

                self.current_time.set(t)

                self.last_poll_time = time.time()

            self.check_autopause()

        finally:

            reactor.callLater(.05, self.pollStatus)

    def set_total_time(self, song):

        # currently only good for .wav

        p = showconfig.songOnDisk(song)

        self.total_time.set(wavelength.wavelength(p))

    def play(self, song=None):

        if song is None:

            self.mpd.play()

            return

        self.mpd.clear()

        self.mpd.add(showconfig.songInMpd(MUS['preSong']))

        self.mpd.add(showconfig.songInMpd(song))

        self.mpd.add(showconfig.songInMpd(MUS['postSong']))

        self.fillCache(song)

        self.filename_var.set(graph.value(song, L9['showPath']))

        self.song_uri = song

        self.set_total_time(song)

        self.seek_to(-4)

    def fillCache(self, song):

        """read the song's entire wav file into memory just before

        playing, so that mpd should never hit the disk during

        playback. On score in 2007, we had some mpd stutters that were

        always timed with a disk read."""

    def check_autopause(self):

        pause_time = self.total_time.get() + self.song_pad_time

        t = self.current_time.get()

        if (self.state.get() == "play" and

            self.last_autopause_time < pause_time < t):

            self.mpd.pause()

        self.last_autopause_time = t

    def stop(self):

        self.mpd.seek(seconds=0, song=0)

        self.mpd.stop()

    def seek_to(self, time):

        if time < 0:

            # seeking to anything within my 4-sec silence ogg goes

            # right to zero. maybe ogg seeking is too coarse?

            self.mpd.seek(seconds=time - (-4), song=0)

        elif time > self.total_time.get():

            self.mpd.seek(seconds=time - self.total_time.get(), song=2)

        else:

            self.mpd.seek(seconds=time, song=1)

        self.last_autopause_time = time

    def skip_intro(self):

        self.seek_to(0)

    def in_post(self):

        return (self.current_time.get() > self.total_time.get() +

                self.song_pad_time)

    def play_pause_toggle(self):

        def finish(status):

            if status.state == 'play':

                self.mpd.pause()

            else:

                self.mpd.play()

        self.mpd.status().addCallback(finish)

    def pause(self):

        self.mpd.pause()

    def skip_to_post(self):

        self.seek_to(self.total_time.get() + self.song_pad_time)

        self.play()

class GoButton: