Cleaner code for the track-reordering

editor/syncdocument.cpp

@@ -8,13 +8,7 @@ SyncDocument::~SyncDocument()
 
 size_t SyncDocument::getTrackIndexFromPos(size_t track) const
 {
-	assert(track < tracks.size());
+	return track;
-	
-	sync::Data::TrackContainer::const_iterator trackIter = tracks.begin();
-	for (size_t currTrack = 0; currTrack < track; ++currTrack, ++trackIter);
-	
-	assert(tracks.end() != trackIter);
-	return trackIter->second;
 }
 
 /* void SyncDocument::purgeUnusedTracks()
@@ -38,7 +32,10 @@ bool SyncDocument::load(const std::string &fileName)
 			MSXML2::IXMLDOMNamedNodeMapPtr attribs = trackNode->Getattributes();
 			
 			std::string name = attribs->getNamedItem("name")->Gettext();
-			size_t trackIndex = getTrackIndex(name);
+			
+			// look up track-name, create it if it doesn't exist
+			int trackIndex = getTrackIndex(name);
+			if (0 > trackIndex) trackIndex = int(createTrack(name));
 			
 			MSXML2::IXMLDOMNodeListPtr rowNodes = trackNode->GetchildNodes();
 			for (int i = 0; i < rowNodes->Getlength(); ++i)
@@ -89,14 +86,12 @@ bool SyncDocument::save(const std::string &fileName)
 		MSXML2::IXMLDOMNodePtr rootNode = doc->createNode(varNodeType, _T("tracks"), _T(""));
 		doc->appendChild(rootNode);
 		
-		sync::Data::TrackContainer::iterator iter;
+		for (size_t i = 0; i < getTrackCount(); ++i)
-		for (iter = tracks.begin(); iter != tracks.end(); ++iter)
 		{
-			size_t index = iter->second;
+			const sync::Track &track = getTrack(i);
-			const sync::Track &track = getTrack(index);
 			
 			MSXML2::IXMLDOMElementPtr trackElem = doc->createElement(_T("track"));
-			trackElem->setAttribute(_T("name"), iter->first.c_str());
+			trackElem->setAttribute(_T("name"), track.getName().c_str());
 			rootNode->appendChild(trackElem);
 			
 			sync::Track::KeyFrameContainer::const_iterator it;

editor/synctracker2.cpp

@@ -523,7 +523,8 @@ int _tmain(int argc, _TCHAR* argv[])
 							clientSocket.recv(&trackName[0], str_len, 0);
 							
 							// find track
-							size_t serverIndex = document.getTrackIndex(trackName.c_str());
+							int serverIndex = document.getTrackIndex(trackName);
+							if (0 > serverIndex) serverIndex = int(document.createTrack(trackName));
 							
 							// setup remap
 							document.clientRemap[serverIndex] = clientIndex;

editor/trackview.cpp

@@ -117,19 +117,14 @@ void TrackView::paintTopMargin(HDC hdc, RECT rcTracks)
 	DrawEdge(hdc, &fillRect, BDR_RAISEDINNER | BDR_RAISEDOUTER, BF_ADJUST | BF_BOTTOM);
 	FillRect(hdc, &fillRect, GetSysColorBrush(COLOR_3DFACE));
 	
-	int firstTrack = min(max(scrollPosX / trackWidth, 0), getTrackCount() - 1);
+	int startTrack = scrollPosX / trackWidth;
-	int lastTrack  = min(max(firstTrack + windowTracks + 1, 0), getTrackCount() - 1);
+	int endTrack  = min(startTrack + windowTracks, getTrackCount());
 	
-	SyncDocument *document = getDocument();
-	if (NULL == document) return;
-
 	SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
 	
-	sync::Data::TrackContainer::iterator trackIter = document->tracks.begin();
+	for (int track = startTrack; track < endTrack; ++track)
-	for (int track = 0; track <= lastTrack; ++track, ++trackIter)
 	{
-		assert(trackIter != document->tracks.end());
+		sync::Track &t = document->getTrack(document->getTrackIndexFromPos(track));
-		if (track < firstTrack) continue;
 		
 		RECT topMargin;
 		
@@ -149,7 +144,7 @@ void TrackView::paintTopMargin(HDC hdc, RECT rcTracks)
 		DrawEdge(hdc, &fillRect, BDR_RAISEDINNER | BDR_RAISEDOUTER, BF_ADJUST | BF_LEFT | BF_RIGHT | BF_BOTTOM);
 		FillRect(hdc, &fillRect, bgBrush);
 		
-		const std::basic_string<TCHAR> &trackName = trackIter->first;
+		const std::basic_string<TCHAR> &trackName = t.getName();
 		
 		if (this->document->clientRemap.count(document->getTrackIndexFromPos(track)) == 0) SetTextColor(hdc, GetSysColor(COLOR_GRAYTEXT));
 		else SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
@@ -176,9 +171,6 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
 {
 	TCHAR temp[256];
 	
-	int firstTrack = min(max(scrollPosX / trackWidth, 0), getTrackCount() - 1);
-	int lastTrack  = min(max(firstTrack + windowTracks + 1, 0), getTrackCount() - 1);
-	
 	int firstRow = editRow - windowRows / 2 - 1;
 	int lastRow  = editRow + windowRows / 2 + 1;
 	/* clamp first & last row */
@@ -225,14 +217,13 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
 	int selectTop    = min(selectStartRow, selectStopRow);
 	int selectBottom = max(selectStartRow, selectStopRow);
 	
-	sync::Data::TrackContainer::iterator trackIter = document->tracks.begin();
+	int startTrack = scrollPosX / trackWidth;
-	for (int track = 0; track <= lastTrack; ++track, ++trackIter)
+	int endTrack  = min(startTrack + windowTracks, getTrackCount());
+	
+	for (int track = startTrack; track < endTrack; ++track)
 	{
-		assert(trackIter != document->tracks.end());
+		const sync::Track &t = document->getTrack(document->getTrackIndexFromPos(track));
-		size_t trackIndex = trackIter->second;
+		
-		const sync::Track &t = document->getTrack(trackIndex);
-
-		if (track < firstTrack) continue;
 		for (int row = firstRow; row <= lastRow; ++row)
 		{
 			RECT patternDataRect;

example_bass/example_bass.cpp

@@ -17,19 +17,19 @@ class BassTimer : public sync::Timer
 public:
 	BassTimer(HSTREAM stream, float bpm, int rowsPerBeat) : stream(stream)
 	{
-		rowRate = (bpm / 60) * rowsPerBeat;
+		rowRate = (double(bpm) / 60) * rowsPerBeat;
 	}
 	
 	// BASS hooks
 	void  pause()           { BASS_ChannelPause(stream); }
 	void  play()            { BASS_ChannelPlay(stream, false); }
 	float getTime()         { return BASS_ChannelBytes2Seconds(stream, BASS_ChannelGetPosition(stream)); }
-	float getRow()          { return getTime() * rowRate; }
+	float getRow()          { return float(getTime() * rowRate); }
-	void  setRow(float row) { BASS_ChannelSetPosition(stream, BASS_ChannelSeconds2Bytes(stream, row / rowRate)); }
+	void  setRow(float row) { BASS_ChannelSetPosition(stream, BASS_ChannelSeconds2Bytes(stream, float(row / rowRate))); }
 	bool  isPlaying()       { return (BASS_ChannelIsActive(stream) == BASS_ACTIVE_PLAYING); }
 private:
 	HSTREAM stream;
-	float rowRate;
+	double rowRate;
 };
 
 #define WINDOWED 1
@@ -63,7 +63,7 @@ int main(int argc, char *argv[])
 		if (!stream) throw std::string("failed to open tune");
 		
 		// setup timer and construct sync-device
-		BassTimer timer(stream, 150.0f, 4);
+		BassTimer timer(stream, 150.0f, 8);
 		std::auto_ptr<sync::Device> syncDevice = std::auto_ptr<sync::Device>(sync::createDevice("sync", timer));
 		if (NULL == syncDevice.get()) throw std::string("something went wrong - failed to connect to host?");
 		

sync/data.cpp

@@ -12,29 +12,26 @@ Data::~Data()
 		delete actualTracks[i];
 }
 
-size_t Data::getTrackIndex(const std::basic_string<TCHAR> &name)
+size_t Data::createTrack(const std::basic_string<TCHAR> &name)
 {
-	TrackContainer::iterator iter = tracks.find(name);
+	assert(0 > getTrackIndex(name));
-	if (iter != tracks.end())
-	{
-		return iter->second;
-	}
-	
 	size_t index = actualTracks.size();
-	tracks[name] = index;
+	
-	actualTracks.push_back(new sync::Track);
+	// insert new track
+	actualTracks.push_back(new sync::Track(name));
+	
 	return index;
 }
 
-Track &Data::getTrack(const std::basic_string<TCHAR> &name)
+int Data::getTrackIndex(const std::basic_string<TCHAR> &name)
 {
-	size_t index = getTrackIndex(name);
+	// search for track
-	assert(index < int(actualTracks.size()));
+	size_t index;
-	assert(NULL != actualTracks[index]);
+	for (index = 0; index < actualTracks.size(); ++index)
-	return *actualTracks[index];
+	{
-}
+		if (name == actualTracks[index]->getName()) return int(index);
-
+	}
-size_t Data::getTrackCount() const
+	
-{
+	// not found
-	return tracks.size();
+	return -1;
 }

sync/data.h

@@ -26,20 +26,27 @@ namespace sync
 	{
 	public:
 		~Data();
-		size_t getTrackIndex(const std::basic_string<TCHAR> &name);
-		Track &getTrack(const std::basic_string<TCHAR> &name);
 		
-		Track &getTrack(size_t track)
+		int
+		getTrackIndex(const std::basic_string<TCHAR> &name);
+		
+		size_t
+		createTrack(const std::basic_string<TCHAR> &name);
+		
+		Track &
+		getTrack(size_t track)
 		{
 			assert(track < actualTracks.size());
 			assert(NULL != actualTracks[track]);
 			return *actualTracks[track];
 		}
 		
-		size_t getTrackCount() const;
+		size_t
+		getTrackCount() const
+		{
+			return actualTracks.size();
+		}
 		
-		typedef std::map<const std::basic_string<TCHAR>, size_t> TrackContainer;
-		TrackContainer tracks;
 	protected:
 		std::vector<Track*> actualTracks;
 	};

sync/device_client.cpp

@@ -35,7 +35,7 @@ private:
 	sync::Data syncData;
 	Timer &timer;
 	
-	int    serverRow;
+	int serverRow;
 	NetworkSocket serverSocket;
 };
 
@@ -45,8 +45,8 @@ ClientDevice::~ClientDevice()
 
 Track &ClientDevice::getTrack(const std::string &trackName)
 {
-	sync::Data::TrackContainer::iterator iter = syncData.tracks.find(trackName);
+	int index = syncData.getTrackIndex(trackName);
-	if (iter != syncData.tracks.end()) return syncData.getTrack(iter->second);
+	if (0 <= index) return syncData.getTrack(size_t(index));
 	
 	// send request data
 	unsigned char cmd = GET_TRACK;
@@ -59,7 +59,8 @@ Track &ClientDevice::getTrack(const std::string &trackName)
 	serverSocket.send(name_str, int(name_len), 0);
 	
 	// insert new track
-	return syncData.getTrack(trackName);
+	index = int(syncData.createTrack(trackName));
+	return syncData.getTrack(size_t(index));
 }
 
 bool ClientDevice::update(float row)
@@ -182,12 +183,10 @@ static bool saveTrack(const sync::Track &track, std::string fileName)
 
 void ClientDevice::saveTracks()
 {
-	sync::Data::TrackContainer::iterator iter;
+	for (size_t i = 0; i < syncData.getTrackCount(); ++i)
-	for (iter = syncData.tracks.begin(); iter != syncData.tracks.end(); ++iter)
 	{
-		size_t index = iter->second;
+		const sync::Track &track = syncData.getTrack(i);
-		const sync::Track &track = syncData.getTrack(index);
+		saveTrack(track, getTrackFileName(track.getName()));
-		saveTrack(track, getTrackFileName(iter->first));
 	}
 }
 

sync/device_player.cpp

@@ -62,12 +62,11 @@ static bool loadTrack(sync::Track &track, std::string fileName)
 
 Track &PlayerDevice::getTrack(const std::string &trackName)
 {
-	sync::Data::TrackContainer::iterator iter = syncData.tracks.find(trackName);
+	int trackIndex = syncData.getTrackIndex(trackName);
-	if (iter != syncData.tracks.end()) return syncData.getTrack(iter->second);
+	if (0 <= trackIndex) return syncData.getTrack(trackIndex);
 	
-	size_t trackIndex = syncData.getTrackIndex(trackName);
+	trackIndex = int(syncData.createTrack(trackName));
 	sync::Track &track = syncData.getTrack(trackIndex);
-	
 	loadTrack(track, getTrackFileName(trackName));
 	return track;
 }

sync/track.h

@@ -12,6 +12,11 @@ namespace sync
 	class Track
 	{
 	public:
+		explicit Track(const std::string &name) : name(name)
+		{
+			
+		}
+		
 		struct KeyFrame
 		{
 			enum InterpolationType
@@ -44,10 +49,12 @@ namespace sync
 		
 		void truncate();
 		
-	// private:
+		const std::string &getName() const { return name; }
 		
 		typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
 		KeyFrameContainer keyFrames;
+	private:
+		std::string name;
 	};
 }
 

sync_player.vcproj

@@ -43,7 +43,7 @@
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
+				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"