cleaned up the interface. time to give the code-structure a big overhaul.

client.cpp

@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include "network.h"
 #include "syncdataclient.h"
+#include "syncdevice.h"
 
 int main(int argc, char *argv[])
 {
@@ -27,7 +28,7 @@ int main(int argc, char *argv[])
 	
 	SyncDataClient syncData(serverSocket);
 	SyncTrack &track = syncData.getTrack("test");
-	SyncTrack &track2 = syncData.getTrack("test2");
+//	SyncTrack &track2 = syncData.getTrack("test2");
 	
 	puts("recieving...");
 	bool done = false;

example.cpp

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include "sync/device.h"
+
+#if 0
+
+class BassTimer : public sync::Timer
+{
+public:
+	BassTimer(HSTREAM stream, float bpm) : stream(stream)
+	{
+		rowRate = bpm / 60;
+	}
+	
+	// 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; }
+	void  setRow(float pos) { BASS_ChannelSetPosition(stream, BASS_ChannelSeconds2Bytes(stream, row / rowRate)); }
+	bool  isPlaying()       { return (BASS_ChannelIsActive(stream) == BASS_ACTIVE_PLAYING); }
+private:
+	HSTREAM stream;
+	float rowRate;
+};
+
+#else
+
+#include <cmath>
+
+class NullTimer : public sync::Timer
+{
+public:
+	NullTimer() : paused(true), row(0) {}
+	void  pause()           { paused = true; }
+	void  play()            { paused = false; }
+	
+	float getRow()
+	{ 
+		if (!paused) return row++;
+		else return row;
+	}
+	
+	void  setRow(float row) { row = int(floor(row)); }
+	bool  isPlaying()       { return !paused; }
+	
+private:
+	bool paused;
+	int row;
+};
+
+#endif
+
+#include <memory>
+int main(int argc, char *argv[])
+{
+//	BassTimer timer(stream, 120.0f);
+	NullTimer timer;
+	std::auto_ptr<sync::Device> syncDevice = std::auto_ptr<sync::Device>(sync::createDevice("sync", timer));
+	if (NULL == syncDevice.get())
+	{
+		printf("wft?!");
+		return -1;
+	}
+	
+	sync::Track &track = syncDevice->getTrack("test");
+	
+//	timer.play();
+	while (1)
+	{
+		float row = timer.getRow();
+		if (!syncDevice->update(row)) break;
+		
+		printf("%2.2f: %2.2f                \r", row, track.getValue(row));
+	}
+
+	return 0;
+}

sync/device.h

@@ -0,0 +1,33 @@
+#ifndef SYNC_H
+#define SYNC_H
+
+#include <string>
+#include "track.h"
+
+namespace sync
+{
+	class Timer
+	{
+	public:
+		virtual ~Timer() {};
+		
+		virtual void  pause() = 0;
+		virtual void  play() = 0;
+		virtual float getRow() = 0;
+		virtual void  setRow(float pos) = 0;
+		virtual bool  isPlaying() = 0;
+	};
+	
+	class Device
+	{
+	public:
+		virtual ~Device() {}
+		
+		virtual Track &getTrack(const std::string &trackName) = 0;
+		virtual bool update(float row) = 0;
+	};
+	
+	Device *createDevice(const std::string &baseName, Timer &timer);
+}
+
+#endif /* SYNC_H */

sync/device_client.cpp

@@ -0,0 +1,61 @@
+#include "device.h"
+#include "../network.h"
+#include "../syncdataclient.h"
+
+using namespace sync;
+
+class ClientDevice : public Device
+{
+public:
+	ClientDevice(SOCKET serverSocket, Timer &timer) : syncData(serverSocket), timer(timer) {}
+	~ClientDevice();
+
+	Track &getTrack(const std::string &trackName);
+	bool update(float row);
+	
+private:
+	SyncDataClient syncData;
+	Timer &timer;
+};
+
+ClientDevice::~ClientDevice()
+{
+	
+}
+
+Track &ClientDevice::getTrack(const std::string &trackName)
+{
+	return syncData.getTrack(trackName);
+}
+
+bool ClientDevice::update(float row)
+{
+	return !syncData.poll();
+}
+
+Device *sync::createDevice(const std::string &baseName, Timer &timer)
+{
+	if (false == initNetwork())
+	{
+		printf("noes 1!\n");
+		return NULL;
+	}
+	
+	struct hostent *myhost = gethostbyname("localhost");
+	struct sockaddr_in sain;
+	sain.sin_family = AF_INET;
+	sain.sin_port = htons(1338);
+	sain.sin_addr.s_addr= *( (unsigned long *)(myhost->h_addr_list[0]) );
+	
+	// connect to server
+	SOCKET serverSocket = serverConnect(&sain);
+	if (INVALID_SOCKET == serverSocket)
+	{
+		printf("noes 2!\n");
+		return NULL;
+	}
+	
+	Device *device = new ClientDevice(serverSocket, timer);
+
+	return device;
+}

sync/track.cpp

@@ -0,0 +1,57 @@
+#include "track.h"
+using namespace sync;
+
+#include <cmath>
+#include <cstddef>
+
+float Track::getValue(float time) const
+{
+	if (keyFrames.size() == 0) return 0.0f;
+	
+	int currRow = int(floor(time));
+	
+	// find bounding keyframes
+	KeyFrameContainer::const_iterator upper = keyFrames.upper_bound(currRow);
+	KeyFrameContainer::const_iterator lower = upper;
+	lower--;
+	
+	// bounds check
+	if (lower == keyFrames.end()) return upper->second.value;
+	if (upper == keyFrames.end()) return lower->second.value;
+	
+	float delta = upper->second.value - lower->second.value;
+	
+	// lerp, bitch
+	float d = (time - lower->first) / (upper->first - lower->first);
+	return lower->second.value + delta * d;
+}
+
+bool Track::isKeyFrame(size_t row) const
+{
+	return keyFrames.find(row) != keyFrames.end();
+}
+
+const Track::KeyFrame *Track::getKeyFrame(size_t row) const
+{
+	KeyFrameContainer::const_iterator iter = keyFrames.find(row);
+	if (iter == keyFrames.end()) return NULL;
+	return &iter->second;
+}
+
+void Track::deleteKeyFrame(size_t row)
+{
+	keyFrames.erase(row);
+}
+
+void Track::setKeyFrame(size_t row, const KeyFrame &keyFrame)
+{
+	keyFrames[row] = keyFrame;
+}
+
+size_t Track::getFrameCount() const
+{
+	if (keyFrames.empty()) return 0;
+	KeyFrameContainer::const_iterator iter = keyFrames.end();
+	iter--;
+	return iter->first;
+}

sync/track.h

@@ -0,0 +1,35 @@
+#ifndef SYNC_TRACK_H
+#define SYNC_TRACK_H
+
+#include <map>
+
+namespace sync
+{
+	class Track
+	{
+	public:
+		struct KeyFrame
+		{
+			KeyFrame() : lerp(false) {}
+			KeyFrame(float value) : value(value), lerp(false) {}
+			float value;
+			bool lerp;
+		};
+		
+		float  getValue(float time) const;
+		bool   isKeyFrame(size_t row) const;
+		const  KeyFrame *getKeyFrame(size_t row) const;
+		size_t getFrameCount() const;
+		
+		void deleteKeyFrame(size_t row);
+		void setKeyFrame(size_t row, const KeyFrame &keyFrame);
+		void setKeyFrame(size_t row, const float value);
+		
+	// private:
+		
+		typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
+		KeyFrameContainer keyFrames;
+	};
+}
+
+#endif // SYNC_TRACK_H

syncdata.h

@@ -7,79 +7,7 @@
 #include <exception>
 #include <cmath>
 
-class SyncTrack
+#include "sync/track.h"
-{
-public:
-	struct KeyFrame
-	{
-		KeyFrame() : lerp(false) {}
-		KeyFrame(float value) : value(value), lerp(false) {}
-		float value;
-		bool lerp;
-	};
-	
-	float getValue(float time)
-	{
-		if (keyFrames.size() == 0) return 0.0f;
-		
-		int currRow = int(floor(time));
-		
-		// find bounding keyframes
-		KeyFrameContainer::const_iterator upper = keyFrames.upper_bound(currRow);
-		KeyFrameContainer::const_iterator lower = upper;
-		lower--;
-		
-		// bounds check
-		if (lower == keyFrames.end()) return upper->second.value;
-		if (upper == keyFrames.end()) return lower->second.value;
-		
-		float delta = upper->second.value - lower->second.value;
-		
-		// lerp, bitch
-		float d = (time - lower->first) / (upper->first - lower->first);
-		return lower->second.value + delta * d;
-	}
-	
-	bool isKeyFrame(size_t row) const
-	{
-		return keyFrames.find(row) != keyFrames.end();
-	}
-	
-	const KeyFrame *getKeyFrame(size_t row) const
-	{
-		KeyFrameContainer::const_iterator iter = keyFrames.find(row);
-		if (iter == keyFrames.end()) return NULL;
-		return &iter->second;
-	}
-	
-	void deleteKeyFrame(size_t row)
-	{
-		keyFrames.erase(row);
-	}
-	
-	void setKeyFrame(size_t row, const KeyFrame &keyFrame)
-	{
-		keyFrames[row] = keyFrame;
-	}
-	
-	void setKeyFrame(size_t row, const float value)
-	{
-		setKeyFrame(row, KeyFrame(value));
-	}
-	
-	size_t getFrameCount() const
-	{
-		if (keyFrames.empty()) return 0;
-		KeyFrameContainer::const_iterator iter = keyFrames.end();
-		iter--;
-		return iter->first;
-	}
-	
-// private:
-	
-	typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
-	KeyFrameContainer keyFrames;
-};
 
 class SyncData
 {
@@ -91,11 +19,11 @@ public:
 		
 		size_t index = actualTracks.size();
 		tracks[name] = index;
-		actualTracks.push_back(new SyncTrack());
+		actualTracks.push_back(new sync::Track);
 		return index;
 	}
 	
-	SyncTrack &getTrack(const std::basic_string<TCHAR> &name)
+	sync::Track &getTrack(const std::basic_string<TCHAR> &name)
 	{
 		size_t index = getTrackIndex(name);
 		assert(index >= 0);
@@ -104,7 +32,7 @@ public:
 		return *actualTracks[index];
 	}
 	
-	SyncTrack &getTrack(size_t track)
+	sync::Track &getTrack(size_t track)
 	{
 		assert(track >= 0);
 		assert(track < tracks.size());
@@ -120,6 +48,6 @@ public:
 	typedef std::map<const std::basic_string<TCHAR>, size_t> TrackContainer;
 //	typedef std::map<const std::basic_string<TCHAR>, SyncTrack> TrackContainer;
 	TrackContainer tracks;
-	std::vector<SyncTrack*> actualTracks;
+	std::vector<sync::Track*> actualTracks;
 };
 

syncdataclient.cpp

@@ -1,7 +1,7 @@
 #include "syncdataclient.h"
 #include "network.h"
 
-SyncTrack &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
+sync::Track &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
 {
 	TrackContainer::iterator iter = tracks.find(name);
 	if (iter != tracks.end()) return *actualTracks[iter->second];
@@ -20,7 +20,7 @@ SyncTrack &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
 	const char *name_str = name.c_str();
 	send(serverSocket, name_str, name_len, 0);
 	
-	SyncTrack *track = new SyncTrack();
+	sync::Track *track = new sync::Track();
 	/* todo: fill in based on the response */
 
 	actualTracks.push_back(track);

syncdataclient.h

@@ -6,9 +6,9 @@ class SyncDataClient : public SyncData
 public:
 	SyncDataClient(SOCKET serverSocket) : serverSocket(serverSocket) {}
 	
-	SyncTrack &getTrack(const std::basic_string<TCHAR> &name);
+	sync::Track &getTrack(const std::basic_string<TCHAR> &name);
 	bool poll();
 private:
-	std::map<int, SyncTrack*> serverRemap;
+	std::map<int, sync::Track*> serverRemap;
 	SOCKET serverSocket;
 };

synceditdata.h

@@ -11,7 +11,7 @@ class SyncEditData : public SyncData
 public:
 	SyncEditData() : SyncData() {}
 	
-	void sendSetKeyCommand(int track, int row, const SyncTrack::KeyFrame &key)
+	void sendSetKeyCommand(int track, int row, const sync::Track::KeyFrame &key)
 	{
 		if (INVALID_SOCKET == clientSocket) return;
 		if (clientRemap.count(track) == 0) return;
@@ -46,12 +46,12 @@ public:
 	class InsertCommand : public Command
 	{
 	public:
-		InsertCommand(int track, int row, const SyncTrack::KeyFrame &key) : track(track), row(row), key(key) {}
+		InsertCommand(int track, int row, const sync::Track::KeyFrame &key) : track(track), row(row), key(key) {}
 		~InsertCommand() {}
 		
 		virtual void exec(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			assert(!t.isKeyFrame(row));
 			t.setKeyFrame(row, key);
 			
@@ -60,7 +60,7 @@ public:
 		
 		virtual void undo(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			assert(t.isKeyFrame(row));
 			t.deleteKeyFrame(row);
 			
@@ -69,7 +69,7 @@ public:
 		
 	private:
 		int track, row;
-		SyncTrack::KeyFrame key;
+		sync::Track::KeyFrame key;
 	};
 	
 	class DeleteCommand : public Command
@@ -80,7 +80,7 @@ public:
 		
 		virtual void exec(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			assert(t.isKeyFrame(row));
 			oldKey = *t.getKeyFrame(row);
 			t.deleteKeyFrame(row);
@@ -90,7 +90,7 @@ public:
 		
 		virtual void undo(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			assert(!t.isKeyFrame(row));
 			t.setKeyFrame(row, oldKey);
 			
@@ -99,19 +99,19 @@ public:
 		
 	private:
 		int track, row;
-		SyncTrack::KeyFrame oldKey;
+		sync::Track::KeyFrame oldKey;
 	};
 
 	
 	class EditCommand : public Command
 	{
 	public:
-		EditCommand(int track, int row, const SyncTrack::KeyFrame &key) : track(track), row(row), key(key) {}
+		EditCommand(int track, int row, const sync::Track::KeyFrame &key) : track(track), row(row), key(key) {}
 		~EditCommand() {}
 		
 		virtual void exec(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			
 			// store old key
 			assert(t.isKeyFrame(row));
@@ -125,7 +125,7 @@ public:
 		
 		virtual void undo(SyncEditData *data)
 		{
-			SyncTrack &t = data->getTrack(this->track);
+			sync::Track &t = data->getTrack(this->track);
 			
 			assert(t.isKeyFrame(row));
 			t.setKeyFrame(row, oldKey);
@@ -135,7 +135,7 @@ public:
 		
 	private:
 		int track, row;
-		SyncTrack::KeyFrame oldKey, key;
+		sync::Track::KeyFrame oldKey, key;
 	};
 	
 	class MultiCommand : public Command
@@ -215,9 +215,9 @@ public:
 		}
 	}
 	
-	Command *getSetKeyFrameCommand(int track, int row, const SyncTrack::KeyFrame &key)
+	Command *getSetKeyFrameCommand(int track, int row, const sync::Track::KeyFrame &key)
 	{
-		SyncTrack &t = getTrack(track);
+		sync::Track &t = getTrack(track);
 		SyncEditData::Command *cmd;
 		if (t.isKeyFrame(row)) cmd = new EditCommand(track, row, key);
 		else                   cmd = new InsertCommand(track, row, key);

synctracker2.cpp

@@ -67,7 +67,7 @@ static LRESULT CALLBACK setRowsDialogProc(HWND hDlg, UINT message, WPARAM wParam
 		EndDialog(hDlg, LOWORD(wParam));
 		return TRUE;
 	}
-
+	
 	return FALSE;
 }
 
@@ -114,7 +114,7 @@ static LRESULT CALLBACK biasSelectionDialogProc(HWND hDlg, UINT message, WPARAM
 		EndDialog(hDlg, LOWORD(wParam));
 		return TRUE;
 	}
-
+	
 	return FALSE;
 }
 
@@ -163,12 +163,12 @@ static LRESULT CALLBACK mainWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARA
 	case WM_SETFOCUS:
 		SetFocus(trackViewWin); // needed to forward keyboard input
 		break;
-
+	
 	case WM_SETROWS:
 		printf("rows: %d\n", int(lParam));
 		trackView->setRows(int(lParam));
 		break;
-
+	
 	case WM_BIASSELECTION:
 		trackView->editBiasValue(float(lParam));
 		break;
@@ -283,13 +283,14 @@ int _tmain(int argc, _TCHAR* argv[])
 	
 	SyncEditData syncData;
 	syncData.clientSocket = INVALID_SOCKET;
-
+#if 0
+	
 	SyncTrack &camXTrack = syncData.getTrack(_T("cam.x"));
 	SyncTrack &camXTrack2 = syncData.getTrack(_T("cam.x"));
 	camXTrack.setKeyFrame(1, 2.0f);
 	camXTrack.setKeyFrame(4, 3.0f);
 	printf("%p %p\n", &camXTrack, &camXTrack2);
-
+	
 	SyncTrack &camYTrack = syncData.getTrack(_T("cam.y"));
 	SyncTrack &camZTrack = syncData.getTrack(_T("cam.z"));
 	
@@ -313,6 +314,7 @@ int _tmain(int argc, _TCHAR* argv[])
 		float time = float(i) / 2;
 		printf("%f %d - %f\n", time, camXTrack.isKeyFrame(i), camXTrack.getValue(time));
 	}
+#endif
 	
 	ATOM mainClass      = registerMainWindowClass(hInstance);
 	ATOM trackViewClass = registerTrackViewWindowClass(hInstance);
@@ -426,13 +428,13 @@ int _tmain(int argc, _TCHAR* argv[])
 						// setup remap
 						syncData.clientRemap[serverIndex] = clientIndex;
 						
-						const SyncTrack &track = *syncData.actualTracks[serverIndex];
+						const sync::Track &track = *syncData.actualTracks[serverIndex];
 						
-						SyncTrack::KeyFrameContainer::const_iterator it;
+						sync::Track::KeyFrameContainer::const_iterator it;
 						for (it = track.keyFrames.begin(); it != track.keyFrames.end(); ++it)
 						{
 							int row = int(it->first);
-							const SyncTrack::KeyFrame &key = it->second;
+							const sync::Track::KeyFrame &key = it->second;
 							syncData.sendSetKeyCommand(int(serverIndex), row, key);
 						}
 						

synctracker2.vcproj

@@ -192,6 +192,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\sync\track.cpp"
+				>
+			</File>
+			<File
 				RelativePath=".\trackview.cpp"
 				>
 			</File>

trackview.cpp

@@ -263,7 +263,7 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
 			
 //			InvertRect(hdc, &fillRect);
 			
-			const SyncTrack &track = *syncData->actualTracks[trackIter->second];
+			const sync::Track &track = *syncData->actualTracks[trackIter->second];
 			bool key = track.isKeyFrame(row);
 			
 			/* format the text */
@@ -317,7 +317,7 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
 struct CopyEntry
 {
 	int track, row;
-	SyncTrack::KeyFrame keyFrame;
+	sync::Track::KeyFrame keyFrame;
 };
 
 
@@ -343,13 +343,13 @@ void TrackView::editCopy()
 	for (int track = selectLeft; track <= selectRight; ++track)
 	{
 		int localTrack = track - selectLeft;
-		const SyncTrack &t = syncData->getTrack(track);
+		const sync::Track &t = syncData->getTrack(track);
 		for (int row = selectTop; row <= selectBottom; ++row)
 		{
 			int localRow = row - selectTop;
 			if (t.isKeyFrame(row))
 			{
-				const SyncTrack::KeyFrame *keyFrame = t.getKeyFrame(row);
+				const sync::Track::KeyFrame *keyFrame = t.getKeyFrame(row);
 				assert(NULL != keyFrame);
 				
 				CopyEntry ce;
@@ -647,9 +647,9 @@ void TrackView::editEnterValue()
 {
 	if (editString.size() > 0)
 	{
-		SyncTrack &t = syncData->getTrack(editTrack);
+		sync::Track &t = syncData->getTrack(editTrack);
 		
-		SyncTrack::KeyFrame newKey;
+		sync::Track::KeyFrame newKey;
 		if (t.isKeyFrame(editRow)) newKey = *t.getKeyFrame(editRow); // copy old key
 		newKey.value = float(_tstof(editString.c_str())); // modify value
 		
@@ -672,7 +672,7 @@ void TrackView::editDelete()
 	SyncEditData::MultiCommand *multiCmd = new SyncEditData::MultiCommand();
 	for (int track = selectLeft; track <= selectRight; ++track)
 	{
-		SyncTrack &t = syncData->getTrack(track);
+		sync::Track &t = syncData->getTrack(track);
 		for (int row = selectTop; row <= selectBottom; ++row)
 		{
 			if (t.isKeyFrame(row))
@@ -705,12 +705,12 @@ void TrackView::editBiasValue(float amount)
 	SyncEditData::MultiCommand *multiCmd = new SyncEditData::MultiCommand();
 	for (int track = selectLeft; track <= selectRight; ++track)
 	{
-		SyncTrack &t = syncData->getTrack(track);
+		sync::Track &t = syncData->getTrack(track);
 		for (int row = selectTop; row <= selectBottom; ++row)
 		{
 			if (t.isKeyFrame(row))
 			{
-				SyncTrack::KeyFrame newKey = *t.getKeyFrame(row); // copy old key
+				sync::Track::KeyFrame newKey = *t.getKeyFrame(row); // copy old key
 				newKey.value += amount; // modify value
 				
 				// add sub-command