remote sync seems to work (apart from sticking data into container, that is)

client.cpp

@@ -27,6 +27,7 @@ int main(int argc, char *argv[])
 	
 	SyncDataClient syncData(serverSocket);
 	SyncTrack &track = syncData.getTrack("test");
+	SyncTrack &track2 = syncData.getTrack("test2");
 	
 	puts("recieving...");
 	bool done = false;

syncdata.h

@@ -75,7 +75,7 @@ public:
 		return iter->first;
 	}
 	
-private:
+// private:
 	
 	typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
 	KeyFrameContainer keyFrames;
@@ -84,14 +84,24 @@ private:
 class SyncData
 {
 public:
-	SyncTrack &getTrack(const std::basic_string<TCHAR> &name)
+	size_t getTrackIndex(const std::basic_string<TCHAR> &name)
 	{
 		TrackContainer::iterator iter = tracks.find(name);
-		if (iter != tracks.end()) return *actualTracks[iter->second];
+		if (iter != tracks.end()) return int(iter->second);
 		
-		tracks[name] = actualTracks.size();
+		size_t index = actualTracks.size();
+		tracks[name] = index;
 		actualTracks.push_back(new SyncTrack());
-		return *actualTracks.back();
+		return index;
+	}
+	
+	SyncTrack &getTrack(const std::basic_string<TCHAR> &name)
+	{
+		size_t index = getTrackIndex(name);
+		assert(index >= 0);
+		assert(index < int(actualTracks.size()));
+		assert(NULL != actualTracks[index]);
+		return *actualTracks[index];
 	}
 	
 	SyncTrack &getTrack(size_t track)

syncdataclient.cpp

@@ -4,22 +4,28 @@
 SyncTrack &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
 {
 	TrackContainer::iterator iter = tracks.find(name);
-	if (iter != tracks.end()) return iter->second;
+	if (iter != tracks.end()) return *actualTracks[iter->second];
 		
 	unsigned char cmd = GET_TRACK;
 	send(serverSocket, (char*)&cmd, 1, 0);
 
+	size_t clientIndex = actualTracks.size();
+	send(serverSocket, (char*)&clientIndex, sizeof(size_t), 0);
+	
 	// send request data
-	int name_len = name.size();
+	size_t name_len = name.size();
 	printf("len: %d\n", name_len);
-	send(serverSocket, (char*)&name_len, sizeof(int), 0);
+	send(serverSocket, (char*)&name_len, sizeof(size_t), 0);
 	
 	const char *name_str = name.c_str();
 	send(serverSocket, name_str, name_len, 0);
 	
-	SyncTrack track = SyncTrack();
+	SyncTrack *track = new SyncTrack();
 	/* todo: fill in based on the response */
-	return tracks[name] = track;
+
+	actualTracks.push_back(track);
+	tracks[name] = clientIndex;
+	return *track;
 }
 
 bool SyncDataClient::poll()
@@ -30,7 +36,7 @@ bool SyncDataClient::poll()
 	{
 		unsigned char cmd = 0;
 		int ret = recv(serverSocket, (char*)&cmd, 1, 0);
-		if (0 == ret)
+		if (0 >= ret)
 		{
 			done = true;
 			break;

synceditdata.h

@@ -14,6 +14,8 @@ public:
 	void sendSetKeyCommand(int track, int row, const SyncTrack::KeyFrame &key)
 	{
 		if (INVALID_SOCKET == clientSocket) return;
+		if (clientRemap.count(track) == 0) return;
+		track = int(clientRemap[track]);
 		
 		unsigned char cmd = SET_KEY;
 		send(clientSocket, (char*)&cmd, 1, 0);
@@ -223,8 +225,8 @@ public:
 	}
 	
 	SOCKET clientSocket;
-private:
+// private:
-//	std::map<SyncTrack*, int> clientRemap;
+	std::map<size_t, size_t> clientRemap;
 	
 	std::stack<Command*> undoStack;
 	std::stack<Command*> redoStack;

synctracker2.cpp

@@ -377,14 +377,12 @@ int _tmain(int argc, _TCHAR* argv[])
 				{
 					puts("connected.");
 					syncData.clientSocket = clientSocket;
-/*					for (int track = 0; track < syncData.getTrackCount(); ++track)
+					syncData.clientRemap.clear();
-					{
-						
-					} */
 				}
 			}
 		}
-		else
+		
+		if (INVALID_SOCKET != clientSocket)
 		{
 			// look for new commands
 			while (pollRead(clientSocket))
@@ -403,44 +401,45 @@ int _tmain(int argc, _TCHAR* argv[])
 					switch (cmd)
 					{
 					case GET_TRACK:
+						size_t clientIndex = 0;
+						int ret = recv(clientSocket, (char*)&clientIndex, sizeof(int), 0);
+						printf("client index: %d\n", clientIndex);
+						
 						// get len
 						int str_len = 0;
-						int ret = recv(clientSocket, (char*)&str_len, sizeof(int), 0);
+						ret = recv(clientSocket, (char*)&str_len, sizeof(int), 0);
-						assert(ret == sizeof(size_t));
-						printf("len: %d\n", str_len);
 						
 //						int clientAddr = 0;
 //						int ret = recv(clientSocket, (char*)&clientAddr, sizeof(int), 0);
 						
 						// get string
 						std::string trackName;
-						trackName.resize(str_len * 2);
+						trackName.resize(str_len);
 						recv(clientSocket, &trackName[0], str_len, 0);
-						trackName.push_back('\0');
 						
-						// 
+						// find track
-						printf("name: %s\n", trackName.c_str());
+						size_t serverIndex = syncData.getTrackIndex(trackName.c_str());
+						printf("name: \"%s\"\n", trackName.c_str());
 						
-						const SyncTrack &track = syncData.getTrack(trackName);
+						// setup remap
-//						clientRemap[track] = clientAddr;
+						syncData.clientRemap[serverIndex] = clientIndex;
 						
-						for (size_t keyframe = 0; keyframe < track.getFrameCount(); ++keyframe)
+						const SyncTrack &track = *syncData.actualTracks[serverIndex];
+						
+						SyncTrack::KeyFrameContainer::const_iterator it;
+						for (it = track.keyFrames.begin(); it != track.keyFrames.end(); ++it)
 						{
-//							printf("name: %s\n", trackName.c_str());
+							int row = int(it->first);
+							const SyncTrack::KeyFrame &key = it->second;
+							syncData.sendSetKeyCommand(int(serverIndex), row, key);
 						}
 						
+						InvalidateRect(trackViewWin, NULL, FALSE);
 						break;
+//					case SOMETHING_ELSE:
 					}
-//					printf("cmd: %02x\n", cmd);
-//					if (cmd == 1) printf("yes, master!\n");
 				}
 			}
-			
-			// terminate connection
-/*			cmd = 0x0;
-			send(clientSocket, (char*)&cmd, 1, 0);
-			closesocket(clientSocket);
-			clientSocket = INVALID_SOCKET; */
 		}
 #endif
 		while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
@@ -455,6 +454,7 @@ int _tmain(int argc, _TCHAR* argv[])
 		Sleep(1);
 	}
 	
+	closesocket(clientSocket);
 	closesocket(serverSocket);
 	closeNetwork();