Support for groups when connecting to demo

ogl_editor/src/Editor.c

@@ -70,7 +70,6 @@ static inline int getActiveTrack()
 	return s_editorData.trackData.activeTrack;
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline int getTrackCount()
@@ -166,6 +165,8 @@ void Editor_init()
 {
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 static char s_currentTrack[64] = "0";
 static char s_currentRow[64] = "0";
 static char s_startRow[64] = "0";
@@ -438,6 +439,13 @@ bool Editor_keyDown(int key, int modifiers)
 
 	switch (key)
 	{
+		case EMGUI_KEY_BACKSPACE:
+		{
+			deleteArea(row_pos, active_track, 1, 1);
+			break;
+		}
+
+
 		case EMGUI_ARROW_DOWN:
 		{
 			int row = row_pos;
@@ -491,14 +499,18 @@ bool Editor_keyDown(int key, int modifiers)
 
 		case EMGUI_ARROW_LEFT:
 		{
+			const int current_track = getActiveTrack();
 			int track = getPrevTrack();
 
 			if (modifiers & EMGUI_KEY_ALT)
 			{
-				Track* t = &trackData->tracks[getActiveTrack()];
+				Track* t = &trackData->tracks[current_track];
 
 				if (modifiers & EMGUI_KEY_CTRL) 
-					t->group->folded = true;
+				{
+					if (t->group->trackCount > 1)
+						t->group->folded = true;
+				}
 				else
 					t->folded = true;
 
@@ -513,7 +525,15 @@ bool Editor_keyDown(int key, int modifiers)
 
 			if (modifiers & EMGUI_KEY_SHIFT)
 			{
-				viewInfo->selectStopTrack = track;
+				Track* t = &trackData->tracks[track];
+
+				// if this track has a folded group we can't select it so set back the selection to the old one
+
+				if (t->group->folded)
+					setActiveTrack(current_track);
+				else
+					viewInfo->selectStopTrack = track;
+
 				break;
 			}
 
@@ -527,15 +547,19 @@ bool Editor_keyDown(int key, int modifiers)
 
 		case EMGUI_ARROW_RIGHT:
 		{
+			const int current_track = getActiveTrack();
 			int track = getNextTrack();
 			int track_count = getTrackCount();
 
 			if (modifiers & EMGUI_KEY_ALT)
 			{
-				Track* t = &trackData->tracks[getActiveTrack()];
+				Track* t = &trackData->tracks[current_track];
 
 				if (modifiers & EMGUI_KEY_CTRL) 
-					t->group->folded = false;
+				{
+					if (t->group->trackCount > 1)
+						t->group->folded = false;
+				}
 				else
 					t->folded = false;
 
@@ -553,7 +577,11 @@ bool Editor_keyDown(int key, int modifiers)
 
 			if (modifiers & EMGUI_KEY_SHIFT)
 			{
-				viewInfo->selectStopTrack = track;
+				Track* t = &trackData->tracks[track];
+				if (t->group->folded)
+					setActiveTrack(current_track);
+				else
+					viewInfo->selectStopTrack = track;
 				break;
 			}
 
@@ -780,6 +808,8 @@ static int processCommands()
 				// setup remap and send the keyframes to the demo
 				RemoteConnection_mapTrackName(trackName);
 				RemoteConnection_sendKeyFrames(trackName, s_editorData.trackData.syncData.tracks[serverIndex]);
+				TrackData_linkTrack(serverIndex, trackName, &s_editorData.trackData);
+
 				ret = 1;
 
 				break;

ogl_editor/src/TrackData.c

@@ -56,120 +56,87 @@ static int findSeparator(const char* name)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-static int countGroup(const char* name, struct sync_data* syncData, int index)
+Group* findOrCreateGroup(const char* name, TrackData* trackData)
 {
-	int i, group_count = 0, count = syncData->num_tracks;
+	Group* group;
+	int i, group_count = trackData->groupCount;
+	Group* groups = trackData->groups;
 
-	for (i = index; i < count; ++i)
+	for (i = 0; i < group_count; ++i)
 	{
-		if (strstr(syncData->tracks[i]->name, name))
+		group = &groups[i];
-			group_count++;
-	}
 
-	return group_count;
+		if (!group->name)
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static void insertTracksInGroup(Group* group, const char* name, bool* processedTracks, TrackData* trackData, int index)
-{
-	int i, group_index = 0, count = trackData->syncData.num_tracks;
-	struct sync_data* sync = &trackData->syncData;
-
-	for (i = index; i < count; ++i)
-	{
-		char* split_name;
-
-		if (processedTracks[i])
 			continue;
 
-		if ((split_name = strstr(sync->tracks[i]->name, name)))
+		if (!strcmp(name, group->name))
-		{
+			return &groups[i];
-			Track* t = &trackData->tracks[i];
-			int sep = findSeparator(sync->tracks[i]->name);
-			rlog(R_DEBUG, "Inserted track %s into group %s (%s)\n", sync->tracks[i]->name, group->name, split_name);
-			t->displayName = strdup(&split_name[sep + 1]);
-			t->group = group; 
-			group->t.tracks[group_index++] = t;
-			processedTracks[i] = true;
-		}
 	}
+
+	group = &groups[trackData->groupCount++];
+	memset(group, 0, sizeof(Group));
+
+	group->type = GROUP_TYPE_GROUP;
+	group->name = strdup(name);
+	group->displayName = strdup(name);
+	group->displayName[strlen(name)-1] = 0;
+	group->trackCount = 0;
+
+	return group;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void TrackData_linkTrack(int index, const char* name, TrackData* trackData)
+{
+	int found;
+	char group_name[256];
+	Group* group;
+	Group* groups = trackData->groups;
+	Track* track = &trackData->tracks[index];
+
+	if (track->group)
+		return;
+
+	found = findSeparator(name);
+
+	if (found == -1)
+	{
+		Group* group = &groups[trackData->groupCount++];
+		memset(group, 0, sizeof(Group));
+
+		group->type = GROUP_TYPE_TRACK;
+		group->t.track = track;
+		group->trackCount = 1;
+		track->group = group;
+		track->displayName = strdup(name); 
+		return;
+	}
+
+	memset(group_name, 0, sizeof(group_name));
+	memcpy(group_name, name, found + 1); 
+
+	group = findOrCreateGroup(group_name, trackData); 
+
+	if (group->trackCount == 0)
+		group->t.tracks = (Track**)malloc(sizeof(Track**));
+	else
+		group->t.tracks = (Track**)realloc(group->t.tracks, sizeof(Track**) * group->trackCount + 1);
+
+	group->t.tracks[group->trackCount++] = track;
+
+	track->group = group;
+	track->displayName = strdup(&name[found + 1]);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void TrackData_linkGroups(TrackData* trackData)
 {
-	int i, found, current_group = 0, track_count;
+	int i, track_count;
-	char group_name[256];
-	bool processed_tracks[EDITOR_MAX_TRACKS];
 	struct sync_data* sync = &trackData->syncData;
 
-	// set whatever we have processed a track or not
-
-	memset(processed_tracks, 0, sizeof(processed_tracks));
-
-	trackData->groupCount = 0;
-
-	if (!sync->tracks)
-		return;
-
 	for (i = 0, track_count = sync->num_tracks; i < track_count; ++i)
-	{
+		TrackData_linkTrack(i, sync->tracks[i]->name, trackData); 
-		int group_count;
-		Track* track;
-		const char* track_name = sync->tracks[i]->name;
-		Group* group = &trackData->groups[current_group];
-
-		if (processed_tracks[i])
-			continue;
-
-		track = &trackData->tracks[i];
-		found = findSeparator(track_name);
-
-		if (found == -1)
-		{
-			rlog(R_DEBUG, "Track %s didn't have any group. Adding as single track\n", track_name);
-			group->type = GROUP_TYPE_TRACK;
-			group->t.track = track;
-			group->trackCount = 1;
-			processed_tracks[i] = true;
-			track->group = group;
-			track->displayName = (char*)track_name; 
-			current_group++;
-			continue;
-		}
-
-		rlog(R_DEBUG, "Found track with grouping %s\n", track_name);
-
-		// Found a group, lets dig out the groupname
-
-		memset(group_name, 0, sizeof(group_name));
-		memcpy(group_name, track_name, found + 1); 
-
-		group->name = strdup(group_name);
-		group->displayName = strdup(group_name);
-		group->type = GROUP_TYPE_GROUP;
-		group->displayName[found] = 0;
-
-		rlog(R_DEBUG, "Group name %s\n", group_name);
-
-		// count tracks that are in the group and allocate space for them
-
-		group_count = countGroup(group_name, sync, i);
-
-		rlog(R_DEBUG, "Found %d tracks for group %s\n", group_count, group_name);
-
-		group->t.tracks = (Track**)malloc(sizeof(Track**) * group_count);
-		group->trackCount = group_count;
-
-		insertTracksInGroup(group, group_name, processed_tracks, trackData, i);
-
-		current_group++;
-	}
-
-	trackData->groupCount = current_group;
-
-	rlog(R_DEBUG, "Total amount of groups (and separate tracks) %d\n", current_group);
 }
 

ogl_editor/src/TrackData.h

@@ -74,4 +74,5 @@ typedef struct TrackData
 int TrackData_createGetTrack(TrackData* trackData, const char* name);
 uint32_t TrackData_getNextColor(TrackData* trackData);
 void TrackData_linkGroups(TrackData* trackData);
+void TrackData_linkTrack(int index, const char* name, TrackData* trackData);