Various fixes

* Removed concept of one entry groups. Now all groups has an array of tracks (even if just one) as it simplifies the code
* Rewrote the scrolling handling when auto selecting a new track. The new code should be more robust and doesn't rely on track ordering

ogl_editor/src/Editor.c

@@ -211,11 +211,15 @@ static int getNextTrack()
 	if (!group->folded)
 	{
 		if (track->groupIndex + 1 < group->trackCount)
-			return group->t.tracks[track->groupIndex + 1]->index; 
+			return group->tracks[track->groupIndex + 1]->index; 
 	}
 
+	printf("groupName %s : index %d\n", group->name, group->groupIndex);
+
 	groupIndex = group->groupIndex;
 
+	printf("%d %d\n", groupIndex, trackData->groupCount);
+
 	// We are at the last track in the last group so just return the current one
 
 	if (groupIndex >= trackData->groupCount-1)
@@ -224,11 +228,12 @@ static int getNextTrack()
 	// Get the next group and select the first track in it
 
 	group = &trackData->groups[groupIndex + 1];
+	printf("next group %s\n", group->name);
 
-	if (group->trackCount == 1)
+	printf("newIndex %d\n", group->tracks[0]->index);
-		return group->t.track->index;
+	return group->tracks[0]->index;
-	else
+
-		return group->t.tracks[0]->index;
+	printf("should not be here\n");
 	
 	return 0;
 }
@@ -253,7 +258,7 @@ static int getPrevTrack()
 	// Check If next track is within the group
 
 	if (track->groupIndex - 1 >= 0)
-		return group->t.tracks[track->groupIndex - 1]->index; 
+		return group->tracks[track->groupIndex - 1]->index; 
 
 	groupIndex = group->groupIndex - 1;
 
@@ -267,12 +272,7 @@ static int getPrevTrack()
 	group = &trackData->groups[groupIndex];
 	trackIndex = group->folded ? 0 : group->trackCount - 1;
 
-	if (group->trackCount == 1)
+	return group->tracks[trackIndex]->index;
-		return group->t.track->index;
-	else
-		return group->t.tracks[trackIndex]->index;
-	
-	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -446,6 +446,8 @@ void Editor_updateTrackScroll()
 	sel_track = TrackView_getScrolledTrack(view_info, track_data, track_data->activeTrack, 
 										   track_start_offset - track_start_pixel);
 
+	printf("sel_track %d\n", sel_track);
+
 	if (sel_track != track_data->activeTrack)
 		TrackData_setActiveTrack(track_data, sel_track);
 
@@ -1362,7 +1364,7 @@ static void onFoldGroup(bool fold)
 	if (t->group->trackCount > 1)
 	{
 		TrackViewInfo* viewInfo = getTrackViewInfo(); 
-		int firstTrackIndex = t->group->t.tracks[0]->index;
+		int firstTrackIndex = t->group->tracks[0]->index;
 		t->group->folded = fold;
 		setActiveTrack(firstTrackIndex);
 		viewInfo->selectStartTrack = viewInfo->selectStopTrack = firstTrackIndex;

ogl_editor/src/TrackData.c

@@ -112,11 +112,13 @@ void TrackData_linkTrack(int index, const char* name, TrackData* trackData)
 		Group* group = &groups[trackData->groupCount++];
 		memset(group, 0, sizeof(Group));
 		
+		group->tracks = (Track**)malloc(sizeof(Track**));
+		group->tracks[0] = track;
 		group->type = GROUP_TYPE_TRACK;
-		group->t.track = track;
 		group->trackCount = 1;
 		track->group = group;
 		track->displayName = strdup(name); 
+		group->groupIndex = trackData->groupCount - 1;
 
 		printf("Linking track %s to group %s\n", name, name); 
 
@@ -129,17 +131,19 @@ void TrackData_linkTrack(int index, const char* name, TrackData* trackData)
 	group = findOrCreateGroup(group_name, trackData); 
 
 	if (group->trackCount == 0)
-		group->t.tracks = (Track**)malloc(sizeof(Track**));
+		group->tracks = (Track**)malloc(sizeof(Track**));
 	else
-		group->t.tracks = (Track**)realloc(group->t.tracks, sizeof(Track**) * (group->trackCount + 1));
+		group->tracks = (Track**)realloc(group->tracks, sizeof(Track**) * (group->trackCount + 1));
 
 	printf("Linking track %s to group %s\n", name, group_name); 
 
 	track->groupIndex = group->trackCount;
-	group->t.tracks[group->trackCount++] = track;
+	group->tracks[group->trackCount++] = track;
 
 	track->group = group;
 	track->displayName = strdup(&name[found + 1]);
+
+	printf("groupDisplayName %s\n", group->displayName);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ogl_editor/src/TrackData.h

@@ -48,16 +48,12 @@ typedef struct Group
 	char* displayName;
 	int width;
 
-	bool folded;
-	union
-	{
-		Track* track;
 	Track** tracks;
-	} t;
 
 	enum GroupType type;
 	int trackCount;
 	int groupIndex;
+	bool folded;
 } Group;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ogl_editor/src/TrackView.c

@@ -261,7 +261,7 @@ static int findStartTrack(Group* group, Track* startTrack)
 
 	for (i = 0; i < track_count; ++i)
 	{
-		if (group->t.tracks[i] == startTrack)
+		if (group->tracks[i] == startTrack)
 			return i;
 	}
 
@@ -291,14 +291,16 @@ int getGroupSize(TrackViewInfo* viewInfo, Group* group, int startTrack)
 {
 	int i, size = 0, count = group->trackCount;
 
-	if (group->width == 0)
+	if (group->width == 0 && group->name)
 		group->width = (Emgui_getTextSize(group->name) & 0xffff) + 40;
+    else
+		group->width = (Emgui_getTextSize(group->tracks[0]->displayName) & 0xffff) + 40;
     
 	if (group->folded)
 		return track_size_folded; 
 
 	for (i = startTrack; i < count; ++i)
-		size += getTrackSize(viewInfo, group->t.tracks[i]);
+		size += getTrackSize(viewInfo, group->tracks[i]);
 
 	size = emaxi(size, group->width);
 
@@ -465,7 +467,7 @@ static int renderGroup(Group* group, Track* startTrack, int posX, int* trackOffs
 	{
 		for (i = startTrackIndex; i < track_count; ++i)
 		{
-			Track* t = group->t.tracks[i];
+			Track* t = group->tracks[i];
 			posX += renderChannel(&info, posX, t, false);
 
 			if (posX >= windowSizeX)
@@ -479,7 +481,7 @@ static int renderGroup(Group* group, Track* startTrack, int posX, int* trackOffs
 	}
 	else
 	{
-		renderChannel(&info, posX, group->t.tracks[0], true);
+		renderChannel(&info, posX, group->tracks[0], true);
 	}
 
 	Emgui_setDefaultFont();
@@ -489,6 +491,7 @@ static int renderGroup(Group* group, Track* startTrack, int posX, int* trackOffs
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/*
 static int processTrack(Track* track, int posX, int* startTrack, int* endTrack, TrackViewInfo* viewInfo)
 {
 	int track_size = getTrackSize(viewInfo, track);
@@ -501,9 +504,81 @@ static int processTrack(Track* track, int posX, int* startTrack, int* endTrack,
 
 	return track_size;
 }
+*/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// This function will figure out what the next track to be selected is when the trackView is scrolled.
+// 
+// The way it does that is by looking at all the groups (which a linear, while tracks are not) and figure out the start
+// visible track and the end visible track. It also check if the current track is the activeTrack and if it's hidden on
+// the left or right side.
+//
+// This code actually does more work than needed (possible to just break out when we found on which side the track
+// is hidden but this code should be fairly fast anyway.
 
+
+int TrackView_getScrolledTrack(TrackViewInfo* viewInfo, TrackData* trackData, int activeTrack, int posX)
+{
+	int i, j, foundState = 0, group_count = trackData->groupCount;
+	Track* activeTrackPtr = &trackData->tracks[activeTrack];
+	const int window_size = viewInfo->windowSizeX - 80;
+
+	posX -= 40;
+
+	for (i = 0; i < group_count; ++i)
+	{
+		Group* group = &trackData->groups[i]; 
+		int track_count = group->trackCount;
+		const bool folded = group->folded;
+
+		if (folded)
+			track_count = 1;
+
+		int t_pos = posX;
+
+		for (j = 0; j < track_count; ++j)
+		{
+			Track* currentTrack = group->tracks[j];
+			const int track_size = folded ? track_size_folded : getTrackSize(viewInfo, currentTrack); 
+
+			// if we are on the current track we check where the current position is located
+			// so if we are above the window limit wi
+
+			if (currentTrack == activeTrackPtr) 
+			{
+				if (t_pos < 0 && currentTrack == activeTrackPtr)
+					foundState = -1;
+
+				// if we are with in the limits we can just return directly here
+
+				if (t_pos >= 0 && (t_pos + track_size) < window_size)
+					return activeTrack;
+			}
+
+			// if we just crossed over to positive side and the activeTrack was found negative then the current track 
+			// should be the next active one
+
+			if (t_pos >= 0 && foundState == -1) 
+				return currentTrack->index;
+
+			// if we have crossed the page boundry and not yet has returned the track the last visible one 
+			// will be seleceted as the active one
+
+			if (t_pos + track_size > window_size)
+				return currentTrack->index;
+            
+            t_pos += track_size;
+		}
+
+		posX += getGroupSize(viewInfo, group, 0);
+	}
+
+	return activeTrack;
+}
+
+
+
+/*
 int TrackView_getScrolledTrack(TrackViewInfo* viewInfo, TrackData* trackData, int activeTrack, int posX)
 {
 	int i, j,  track_count = trackData->syncData.num_tracks;
@@ -524,12 +599,12 @@ int TrackView_getScrolledTrack(TrackViewInfo* viewInfo, TrackData* trackData, in
 		{
 			if (group->folded)
 			{
-				posX += processTrack(group->t.tracks[0], posX, &start_track, &end_track, viewInfo);
+				posX += processTrack(group->tracks[0], posX, &start_track, &end_track, viewInfo);
 			}
 			else
 			{
 				for (j = 0; j < group->trackCount; ++j)
-					processTrack(group->t.tracks[j], posX, &start_track, &end_track, viewInfo);
+					processTrack(group->tracks[j], posX, &start_track, &end_track, viewInfo);
 
 				posX += getGroupSize(viewInfo, group, 0);
 			}
@@ -552,6 +627,7 @@ int TrackView_getScrolledTrack(TrackViewInfo* viewInfo, TrackData* trackData, in
 
 	return activeTrack;
 }
+*/
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -607,18 +683,14 @@ bool TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
 	Emgui_setScissor(48, 0, viewInfo->windowSizeX - 80, viewInfo->windowSizeY);
 	Emgui_setFont(viewInfo->smallFontId);
 
-	///sel_track = setActiveTrack(viewInfo, trackData, trackData->activeTrack, x_pos);
-
-	//if (sel_track != trackData->activeTrack)
-	//	TrackData_setActiveTrack(trackData, sel_track);
 
 	for (i = 0, group_count = trackData->groupCount; i < group_count; ++i)
 	{
 		Group* group = &trackData->groups[i];
 
-		if (group->trackCount == 1)
+		if (group->trackCount == 1 && !group->displayName)
 		{
-			Track* track = group->t.track;
+			Track* track = group->tracks[0];
 			int track_size = getTrackSize(viewInfo, track);
 		
 			if ((x_pos + track_size > 0) && (x_pos < viewInfo->windowSizeX))
@@ -634,7 +706,7 @@ bool TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
 		else
 		{
 			int temp;
-			x_pos += renderGroup(group, group->t.tracks[0], x_pos, &temp, info, trackData);
+			x_pos += renderGroup(group, group->tracks[0], x_pos, &temp, info, trackData);
 		}
 	}
 
@@ -642,9 +714,6 @@ bool TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
 
 	Emgui_fill(Emgui_color32(127, 127, 127, 56), 0, mid_screen_y + adjust_top_size, viewInfo->windowSizeX, font_size + 1);
 
-	//Emgui_setLayer(1);
-	//drawBookmarks(trackData, 2, adjust_top_size, end_row, y_pos_row, viewInfo->windowSizeX, y_end_border);
-
 	Emgui_setLayer(0);
 
 	return s_needsUpdate;
@@ -663,10 +732,6 @@ int TrackView_getWidth(TrackViewInfo* viewInfo, struct TrackData* trackData)
 	for (i = 0; i < group_count; ++i)
 	{
 		Group* group = &trackData->groups[i];
-
-		if (group->trackCount == 1)
-			size += getTrackSize(viewInfo, group->t.track);
-		else
 		size += getGroupSize(viewInfo, group, 0);
 	}
 
@@ -731,7 +796,7 @@ int TrackView_getTracksOffset(TrackViewInfo* viewInfo, TrackData* trackData, int
 			if (i + j == nextTrack)
 				goto end;
 			
-			size += getTrackSize(viewInfo, t->group->t.tracks[j]); 
+			size += getTrackSize(viewInfo, t->group->tracks[j]); 
 
 		}