Merge pull request #305 from dweymouth/feature/jukebox

Redesign of PlaybackManager
2023-12-23 10:52:55 -08:00
parent 61f5f24c4f 85bfa73da4
commit 10feaad1f3
21 changed files with 1300 additions and 987 deletions
@@ -2,6 +2,7 @@ package backend

 import (
 	"context"
+	"errors"
 	"log"
 	"math/rand"
 	"time"
@@ -12,30 +13,29 @@ import (
 	"github.com/dweymouth/supersonic/sharedutil"
 )

-const (
-	ReplayGainNone  = string(player.ReplayGainNone)
-	ReplayGainAlbum = string(player.ReplayGainAlbum)
-	ReplayGainTrack = string(player.ReplayGainTrack)
+var (
+	ReplayGainNone  = player.ReplayGainNone.String()
+	ReplayGainAlbum = player.ReplayGainAlbum.String()
+	ReplayGainTrack = player.ReplayGainTrack.String()
 	ReplayGainAuto  = "Auto"
 )

+// The playback loop mode (LoopNone, LoopAll, LoopOne).
 type LoopMode int

 const (
-	LoopModeNone LoopMode = LoopMode(player.LoopNone)
-	LoopModeAll  LoopMode = LoopMode(player.LoopAll)
-	LoopModeOne  LoopMode = LoopMode(player.LoopOne)
+	LoopNone LoopMode = iota
+	LoopAll
+	LoopOne
 )

-// A high-level Subsonic-aware playback backend.
-// Manages loading tracks into the Player queue,
-// sending callbacks on play time updates and track changes.
+// A high-level MediaProvider-aware playback engine, serves as an
+// intermediary between the frontend and various Player backends.
 type PlaybackManager struct {
 	ctx           context.Context
 	cancelPollPos context.CancelFunc
-	pollingTick   *time.Ticker
 	sm            *ServerManager
-	player        *player.Player
+	player        player.BasePlayer

 	playTimeStopwatch   util.Stopwatch
 	curTrackTime        float64
@@ -43,7 +43,8 @@ type PlaybackManager struct {
 	callbacksDisabled   bool

 	playQueue     []*mediaprovider.Track
-	nowPlayingIdx int64
+	nowPlayingIdx int
+	loopMode      LoopMode

 	// to pass to onSongChange listeners; clear once listeners have been called
 	lastScrobbled *mediaprovider.Track
@@ -51,59 +52,50 @@ type PlaybackManager struct {
 	transcodeCfg  *TranscodingConfig
 	replayGainCfg ReplayGainConfig

+	// registered callbacks
 	onSongChange     []func(nowPlaying, justScrobbledIfAny *mediaprovider.Track)
 	onPlayTimeUpdate []func(float64, float64)
 	onLoopModeChange []func(LoopMode)
 	onVolumeChange   []func(int)
+	onSeek           []func()
+	onPaused         []func()
+	onStopped        []func()
+	onPlaying        []func()
+	onPlayerChange   []func()
 }

 func NewPlaybackManager(
 	ctx context.Context,
 	s *ServerManager,
-	p *player.Player,
+	p player.BasePlayer,
 	scrobbleCfg *ScrobbleConfig,
 	transcodeCfg *TranscodingConfig,
 ) *PlaybackManager {
 	// clamp to 99% to avoid any possible rounding issues
 	scrobbleCfg.ThresholdPercent = clamp(scrobbleCfg.ThresholdPercent, 0, 99)
 	pm := &PlaybackManager{
-		ctx:          ctx,
-		sm:           s,
-		player:       p,
-		scrobbleCfg:  scrobbleCfg,
-		transcodeCfg: transcodeCfg,
+		ctx:           ctx,
+		sm:            s,
+		player:        p,
+		scrobbleCfg:   scrobbleCfg,
+		transcodeCfg:  transcodeCfg,
+		nowPlayingIdx: -1,
 	}
-	p.OnTrackChange(func(tracknum int64) {
-		if tracknum >= int64(len(pm.playQueue)) {
-			return
-		}
-		pm.checkScrobble() // scrobble the previous song if needed
-		if pm.player.GetStatus().State == player.Playing {
-			pm.playTimeStopwatch.Start()
-		}
-		pm.nowPlayingIdx = tracknum
-		pm.curTrackTime = float64(pm.playQueue[pm.nowPlayingIdx].Duration)
-		pm.sendNowPlayingScrobble() // Must come before invokeOnChangeCallbacks b/c track may immediately be scrobbled
-		pm.invokeOnSongChangeCallbacks()
-		pm.doUpdateTimePos()
-	})
+	p.OnTrackChange(pm.handleOnTrackChange)
 	p.OnSeek(func() {
 		pm.doUpdateTimePos()
+		pm.invokeNoArgCallbacks(pm.onSeek)
 	})
-	p.OnStopped(func() {
-		pm.playTimeStopwatch.Stop()
-		pm.checkScrobble()
-		pm.stopPollTimePos()
-		pm.doUpdateTimePos()
-		pm.invokeOnSongChangeCallbacks()
-	})
+	p.OnStopped(pm.handleOnStopped)
 	p.OnPaused(func() {
 		pm.playTimeStopwatch.Stop()
 		pm.stopPollTimePos()
+		pm.invokeNoArgCallbacks(pm.onPaused)
 	})
 	p.OnPlaying(func() {
 		pm.playTimeStopwatch.Start()
 		pm.startPollTimePos()
+		pm.invokeNoArgCallbacks(pm.onPlaying)
 	})

 	s.OnLogout(func() {
@@ -113,6 +105,14 @@ func NewPlaybackManager(
 	return pm
 }

+func (p *PlaybackManager) CurrentPlayer() player.BasePlayer {
+	return p.player
+}
+
+func (p *PlaybackManager) OnPlayerChange(cb func()) {
+	p.onPlayerChange = append(p.onPlayerChange, cb)
+}
+
 func (p *PlaybackManager) IsSeeking() bool {
 	return p.player.IsSeeking()
 }
@@ -155,6 +155,26 @@ func (p *PlaybackManager) OnVolumeChange(cb func(int)) {
 	p.onVolumeChange = append(p.onVolumeChange, cb)
 }

+// Registers a callback that is notified whenever the player has been seeked.
+func (p *PlaybackManager) OnSeek(cb func()) {
+	p.onSeek = append(p.onSeek, cb)
+}
+
+// Registers a callback that is notified whenever the player has been paused.
+func (p *PlaybackManager) OnPaused(cb func()) {
+	p.onPaused = append(p.onPaused, cb)
+}
+
+// Registers a callback that is notified whenever the player is stopped.
+func (p *PlaybackManager) OnStopped(cb func()) {
+	p.onStopped = append(p.onStopped, cb)
+}
+
+// Registers a callback that is notified whenever the player begins playing.
+func (p *PlaybackManager) OnPlaying(cb func()) {
+	p.onPlaying = append(p.onPlaying, cb)
+}
+
 // Loads the specified album into the play queue.
 func (p *PlaybackManager) LoadAlbum(albumID string, appendToQueue bool, shuffle bool) error {
 	album, err := p.sm.Server.GetAlbum(albumID)
@@ -173,28 +193,29 @@ func (p *PlaybackManager) LoadPlaylist(playlistID string, appendToQueue bool, sh
 	return p.LoadTracks(playlist.Tracks, appendToQueue, shuffle)
 }

+// Load tracks into the play queue.
+// If replacing the current queue (!appendToQueue), playback will be stopped.
 func (p *PlaybackManager) LoadTracks(tracks []*mediaprovider.Track, appendToQueue, shuffle bool) error {
 	if !appendToQueue {
 		p.player.Stop()
-		p.nowPlayingIdx = 0
+		p.nowPlayingIdx = -1
 		p.playQueue = nil
 	}
 	nums := util.Range(len(tracks))
 	if shuffle {
 		rand.Shuffle(len(nums), func(i, j int) { nums[i], nums[j] = nums[j], nums[i] })
 	}
+	needToSetNext := appendToQueue && len(tracks) > 0 && p.nowPlayingIdx == len(p.playQueue)-1
 	for _, i := range nums {
-		url, err := p.sm.Server.GetStreamURL(tracks[i].ID, p.transcodeCfg.ForceRawFile)
-		if err != nil {
-			return err
-		}
-		p.player.AppendFile(url)
 		// ensure a deep copy of the track info so that we can maintain our own state
 		// (tracking play count increases, favorite, and rating) without messing up
 		// other views' track models
 		tr := *tracks[i]
 		p.playQueue = append(p.playQueue, &tr)
 	}
+	if needToSetNext {
+		p.setNextTrack(p.nowPlayingIdx + 1)
+	}
 	return nil
 }

@@ -205,10 +226,7 @@ func (p *PlaybackManager) PlayAlbum(albumID string, firstTrack int, shuffle bool
 	if p.replayGainCfg.Mode == ReplayGainAuto {
 		p.SetReplayGainMode(player.ReplayGainAlbum)
 	}
-	if firstTrack <= 0 {
-		return p.player.PlayFromBeginning()
-	}
-	return p.player.PlayTrackAt(firstTrack)
+	return p.PlayTrackAt(firstTrack)
 }

 func (p *PlaybackManager) PlayPlaylist(playlistID string, firstTrack int, shuffle bool) error {
@@ -218,10 +236,7 @@ func (p *PlaybackManager) PlayPlaylist(playlistID string, firstTrack int, shuffl
 	if p.replayGainCfg.Mode == ReplayGainAuto {
 		p.SetReplayGainMode(player.ReplayGainTrack)
 	}
-	if firstTrack <= 0 {
-		return p.player.PlayFromBeginning()
-	}
-	return p.player.PlayTrackAt(firstTrack)
+	return p.PlayTrackAt(firstTrack)
 }

 func (p *PlaybackManager) PlayTrack(trackID string) error {
@@ -237,28 +252,32 @@ func (p *PlaybackManager) PlayTrack(trackID string) error {
 }

 func (p *PlaybackManager) PlayFromBeginning() error {
-	return p.player.PlayFromBeginning()
+	return p.PlayTrackAt(0)
 }

 func (p *PlaybackManager) PlayTrackAt(idx int) error {
-	return p.player.PlayTrackAt(idx)
+	if idx < 0 || idx >= len(p.playQueue) {
+		return errors.New("track index out of range")
+	}
+	p.nowPlayingIdx = idx - 1
+	return p.setTrack(idx, false)
 }

 func (p *PlaybackManager) PlayRandomSongs(genreName string) {
-	if songs, err := p.sm.Server.GetRandomTracks(genreName, 100); err != nil {
-		log.Printf("error getting random songs: %s", err.Error())
-	} else {
-		p.LoadTracks(songs, false, false)
-		if p.replayGainCfg.Mode == ReplayGainAuto {
-			p.SetReplayGainMode(player.ReplayGainTrack)
-		}
-		p.PlayFromBeginning()
-	}
+	p.fetchAndPlayTracks(func() ([]*mediaprovider.Track, error) {
+		return p.sm.Server.GetRandomTracks(genreName, 100)
+	})
 }

 func (p *PlaybackManager) PlaySimilarSongs(id string) {
-	if songs, err := p.sm.Server.GetSimilarTracks(id, 100); err != nil {
-		log.Printf("error getting similar songs: %s", err.Error())
+	p.fetchAndPlayTracks(func() ([]*mediaprovider.Track, error) {
+		return p.sm.Server.GetSimilarTracks(id, 100)
+	})
+}
+
+func (p *PlaybackManager) fetchAndPlayTracks(fetchFn func() ([]*mediaprovider.Track, error)) {
+	if songs, err := fetchFn(); err != nil {
+		log.Printf("error fetching tracks: %s", err.Error())
 	} else {
 		p.LoadTracks(songs, false, false)
 		if p.replayGainCfg.Mode == ReplayGainAuto {
@@ -295,23 +314,23 @@ func (p *PlaybackManager) OnTrackRatingChanged(id string, rating int) {

 func (p *PlaybackManager) RemoveTracksFromQueue(trackIDs []string) {
 	newQueue := make([]*mediaprovider.Track, 0, len(p.playQueue)-len(trackIDs))
-	rmCount := 0
 	idSet := sharedutil.ToSet(trackIDs)
 	isPlayingTrackRemoved := false
+	isNextPlayingTrackremoved := false
+	nowPlaying := p.NowPlayingIndex()
+	newNowPlaying := nowPlaying
 	for i, tr := range p.playQueue {
 		if _, ok := idSet[tr.ID]; ok {
-			// removing this track
-			if i == p.NowPlayingIndex() {
+			if i < nowPlaying {
+				// if removing a track earlier than the currently playing one (if any),
+				// decrement new now playing index by one to account for new position in queue
+				newNowPlaying--
+			} else if i == nowPlaying {
 				isPlayingTrackRemoved = true
 				// If we are removing the currently playing track, we need to scrobble it
 				p.checkScrobble()
-			}
-			if err := p.player.RemoveTrackAt(i - rmCount); err == nil {
-				rmCount++
-			} else {
-				log.Printf("error removing track: %v", err.Error())
-				// did not remove this track
-				newQueue = append(newQueue, tr)
+			} else if nowPlaying >= 0 && i == nowPlaying+1 {
+				isNextPlayingTrackremoved = true
 			}
 		} else {
 			// not removing this track
@@ -319,28 +338,54 @@ func (p *PlaybackManager) RemoveTracksFromQueue(trackIDs []string) {
 		}
 	}
 	p.playQueue = newQueue
-	p.nowPlayingIdx = p.player.GetStatus().PlaylistPos
-	// fire on song change callbacks in case the playing track was removed
+	p.nowPlayingIdx = newNowPlaying
 	if isPlayingTrackRemoved {
-		p.invokeOnSongChangeCallbacks()
+		if newNowPlaying == len(newQueue) {
+			// we had been playing the last track, and removed it
+			p.Stop()
+		} else {
+			p.nowPlayingIdx -= 1 // will be incremented in newtrack callback from player
+			p.setTrack(newNowPlaying, false)
+		}
+		// setNextTrack and onSongChange callbacks will be handled
+		// when we receive new track event from player
+	} else if isNextPlayingTrackremoved {
+		if newNowPlaying < len(newQueue)-1 {
+			p.setNextTrack(p.nowPlayingIdx + 1)
+		} else {
+			// no next track to play
+			p.setNextTrack(-1)
+		}
 	}
 }

 // Stop playback and clear the play queue.
 func (p *PlaybackManager) StopAndClearPlayQueue() {
 	p.player.Stop()
-	p.player.ClearPlayQueue()
 	p.doUpdateTimePos()
 	p.playQueue = nil
+	p.nowPlayingIdx = -1
 }

 func (p *PlaybackManager) SetReplayGainOptions(config ReplayGainConfig) {
-	p.replayGainCfg = config
-	mode := player.ReplayGainMode(config.Mode)
-	if config.Mode == ReplayGainAuto {
-		mode = player.ReplayGainTrack
+	rGainPlayer, ok := p.player.(player.ReplayGainPlayer)
+	if !ok {
+		log.Println("Error: player doesn't support ReplayGain")
+		return
 	}
-	p.player.SetReplayGainOptions(player.ReplayGainOptions{
+
+	p.replayGainCfg = config
+	mode := player.ReplayGainNone
+	switch config.Mode {
+	case ReplayGainAuto:
+		mode = player.ReplayGainTrack
+	case ReplayGainTrack:
+		mode = player.ReplayGainTrack
+	case ReplayGainAlbum:
+		mode = player.ReplayGainAlbum
+	}
+
+	rGainPlayer.SetReplayGainOptions(player.ReplayGainOptions{
 		Mode:            mode,
 		PreventClipping: config.PreventClipping,
 		PreampGain:      config.PreampGainDB,
@@ -348,7 +393,12 @@ func (p *PlaybackManager) SetReplayGainOptions(config ReplayGainConfig) {
 }

 func (p *PlaybackManager) SetReplayGainMode(mode player.ReplayGainMode) {
-	p.player.SetReplayGainOptions(player.ReplayGainOptions{
+	rGainPlayer, ok := p.player.(player.ReplayGainPlayer)
+	if !ok {
+		log.Println("Error: player doesn't support ReplayGain")
+		return
+	}
+	rGainPlayer.SetReplayGainOptions(player.ReplayGainOptions{
 		PreventClipping: p.replayGainCfg.PreventClipping,
 		PreampGain:      p.replayGainCfg.PreampGainDB,
 		Mode:            mode,
@@ -357,32 +407,33 @@ func (p *PlaybackManager) SetReplayGainMode(mode player.ReplayGainMode) {

 // Changes the loop mode of the player to the next one.
 // Useful for toggling UI elements, to change modes without knowing the current player mode.
-func (p *PlaybackManager) SetNextLoopMode() error {
-	if err := p.player.SetNextLoopMode(); err != nil {
-		return err
-	}
+func (p *PlaybackManager) SetNextLoopMode() {
+	switch p.loopMode {
+	case LoopNone:
+		p.SetLoopMode(LoopAll)
+	case LoopAll:
+		p.SetLoopMode(LoopOne)
+	case LoopOne:
+		p.SetLoopMode(LoopNone)

-	for _, cb := range p.onLoopModeChange {
-		cb(LoopMode(p.player.GetLoopMode()))
 	}
-
-	return nil
 }

-func (p *PlaybackManager) SetLoopMode(loopMode LoopMode) error {
-	if err := p.player.SetLoopMode(player.LoopMode(loopMode)); err != nil {
-		return err
-	}
+func (p *PlaybackManager) SetLoopMode(loopMode LoopMode) {
+	p.loopMode = loopMode
+	p.setNextTrackBasedOnLoopMode(true)

 	for _, cb := range p.onLoopModeChange {
 		cb(loopMode)
 	}
-
-	return nil
 }

-func (p *PlaybackManager) LoopMode() LoopMode {
-	return LoopMode(p.player.GetLoopMode())
+func (p *PlaybackManager) GetLoopMode() LoopMode {
+	return p.loopMode
+}
+
+func (p *PlaybackManager) PlayerStatus() player.Status {
+	return p.player.GetStatus()
 }

 func (p *PlaybackManager) SetVolume(vol int) error {
@@ -400,6 +451,143 @@ func (p *PlaybackManager) Volume() int {
 	return p.player.GetVolume()
 }

+func (p *PlaybackManager) SeekNext() error {
+	if p.CurrentPlayer().GetStatus().State == player.Stopped {
+		return nil
+	}
+	return p.PlayTrackAt(p.nowPlayingIdx + 1)
+}
+
+func (p *PlaybackManager) SeekBackOrPrevious() error {
+	if p.nowPlayingIdx == 0 || p.player.GetStatus().TimePos > 3 {
+		return p.player.SeekSeconds(0)
+	}
+	return p.PlayTrackAt(p.nowPlayingIdx - 1)
+}
+
+// Seek to given absolute position in the current track by seconds.
+func (p *PlaybackManager) SeekSeconds(sec float64) error {
+	return p.player.SeekSeconds(sec)
+}
+
+// Seek to a fractional position in the current track [0..1]
+func (p *PlaybackManager) SeekFraction(fraction float64) error {
+	if fraction < 0 {
+		fraction = 0
+	} else if fraction > 1 {
+		fraction = 1
+	}
+	target := p.curTrackTime * fraction
+	return p.player.SeekSeconds(target)
+}
+
+func (p *PlaybackManager) Stop() error {
+	return p.player.Stop()
+}
+
+func (p *PlaybackManager) Pause() error {
+	return p.player.Pause()
+}
+
+func (p *PlaybackManager) Continue() error {
+	if p.player.GetStatus().State == player.Stopped {
+		return p.PlayFromBeginning()
+	}
+	return p.player.Continue()
+}
+
+func (p *PlaybackManager) PlayPause() error {
+	switch p.player.GetStatus().State {
+	case player.Playing:
+		return p.player.Pause()
+	case player.Paused:
+		return p.player.Continue()
+	case player.Stopped:
+		return p.PlayFromBeginning()
+	}
+	return errors.New("unreached - invalid player state")
+}
+
+func (p *PlaybackManager) handleOnTrackChange() {
+	p.checkScrobble() // scrobble the previous song if needed
+	if p.player.GetStatus().State == player.Playing {
+		p.playTimeStopwatch.Start()
+	}
+	if p.loopMode != LoopOne {
+		p.nowPlayingIdx++
+		if p.loopMode == LoopAll && p.nowPlayingIdx == len(p.playQueue) {
+			p.nowPlayingIdx = 0 // wrapped around
+		}
+	}
+	p.curTrackTime = float64(p.playQueue[p.nowPlayingIdx].Duration)
+	p.sendNowPlayingScrobble() // Must come before invokeOnChangeCallbacks b/c track may immediately be scrobbled
+	p.invokeOnSongChangeCallbacks()
+	p.doUpdateTimePos()
+	p.setNextTrackBasedOnLoopMode(false)
+}
+
+func (p *PlaybackManager) handleOnStopped() {
+	p.playTimeStopwatch.Stop()
+	p.checkScrobble()
+	p.stopPollTimePos()
+	p.doUpdateTimePos()
+	p.invokeOnSongChangeCallbacks()
+	p.invokeNoArgCallbacks(p.onStopped)
+	p.nowPlayingIdx = -1
+}
+
+func (p *PlaybackManager) setNextTrackBasedOnLoopMode(onLoopModeChange bool) {
+	switch p.loopMode {
+	case LoopNone:
+		if p.nowPlayingIdx < len(p.playQueue)-1 {
+			p.setNextTrack(p.nowPlayingIdx + 1)
+		} else if onLoopModeChange {
+			// prev was LoopOne - need to erase next track
+			p.setNextTrack(-1)
+		}
+	case LoopOne:
+		p.setNextTrack(p.nowPlayingIdx)
+	case LoopAll:
+		if p.nowPlayingIdx >= len(p.playQueue)-1 {
+			p.setNextTrack(0)
+		} else if !onLoopModeChange {
+			// if onloopmodechange, prev mode was LoopNone and next track is already set
+			p.setNextTrack(p.nowPlayingIdx + 1)
+		}
+	}
+}
+
+func (p *PlaybackManager) setTrack(idx int, next bool) error {
+	if urlP, ok := p.player.(player.URLPlayer); ok {
+		url := ""
+		if idx >= 0 {
+			var err error
+			url, err = p.sm.Server.GetStreamURL(p.playQueue[idx].ID, p.transcodeCfg.ForceRawFile)
+			if err != nil {
+				return err
+			}
+		}
+		if next {
+			return urlP.SetNextFile(url)
+		}
+		return urlP.PlayFile(url)
+	} else if trP, ok := p.player.(player.TrackPlayer); ok {
+		var track *mediaprovider.Track
+		if idx >= 0 {
+			track = p.playQueue[idx]
+		}
+		if next {
+			return trP.SetNextTrack(track)
+		}
+		return trP.PlayTrack(track)
+	}
+	panic("Unsupported player type")
+}
+
+func (p *PlaybackManager) setNextTrack(idx int) error {
+	return p.setTrack(idx, true)
+}
+
 // call BEFORE updating p.nowPlayingIdx
 func (p *PlaybackManager) checkScrobble() {
 	if !p.scrobbleCfg.Enabled || len(p.playQueue) == 0 || p.nowPlayingIdx < 0 {
@@ -450,26 +638,40 @@ func (p *PlaybackManager) invokeOnSongChangeCallbacks() {
 	p.lastScrobbled = nil
 }

+func (pm *PlaybackManager) invokeNoArgCallbacks(cbs []func()) {
+	if pm.callbacksDisabled {
+		return
+	}
+	for _, cb := range cbs {
+		cb()
+	}
+}
+
 func (p *PlaybackManager) startPollTimePos() {
 	ctx, cancel := context.WithCancel(p.ctx)
 	p.cancelPollPos = cancel
-	p.pollingTick = time.NewTicker(250 * time.Millisecond)
+	pollingTick := time.NewTicker(250 * time.Millisecond)

-	// TODO: fix occasional nil pointer dereference on app quit
 	go func() {
 		for {
 			select {
 			case <-ctx.Done():
-				p.pollingTick.Stop()
-				p.pollingTick = nil
+				pollingTick.Stop()
 				return
-			case <-p.pollingTick.C:
+			case <-pollingTick.C:
 				p.doUpdateTimePos()
 			}
 		}
 	}()
 }

+func (p *PlaybackManager) stopPollTimePos() {
+	if p.cancelPollPos != nil {
+		p.cancelPollPos()
+		p.cancelPollPos = nil
+	}
+}
+
 func (p *PlaybackManager) doUpdateTimePos() {
 	if p.callbacksDisabled {
 		return
@@ -482,13 +684,3 @@ func (p *PlaybackManager) doUpdateTimePos() {
 		cb(s.TimePos, s.Duration)
 	}
 }
-
-func (p *PlaybackManager) stopPollTimePos() {
-	if p.cancelPollPos != nil {
-		p.cancelPollPos()
-		p.cancelPollPos = nil
-	}
-	if p.pollingTick != nil {
-		p.pollingTick.Stop()
-	}
-}