WIP on group support

ogl_editor/src/Editor.c

@@ -58,6 +58,9 @@ static inline struct sync_track** getTracks()
 
 static inline void setActiveTrack(int track)
 {
+	const int current_track = s_editorData.trackData.activeTrack;
+	s_editorData.trackData.tracks[current_track].selected = false;
+	s_editorData.trackData.tracks[track].selected = true;
 	s_editorData.trackData.activeTrack = track;
 }
 
@@ -68,6 +71,7 @@ static inline int getActiveTrack()
 	return s_editorData.trackData.activeTrack;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline int getTrackCount()
@@ -77,6 +81,51 @@ static inline int getTrackCount()
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+static int getNextTrack()
+{
+	TrackData* trackData = &s_editorData.trackData;
+	int i, track_count = getTrackCount(); 
+	int active_track = getActiveTrack();
+
+	for (i = active_track + 1; i < track_count; ++i)
+	{
+		// if track has no group its always safe to assume that can select the track
+
+		if (!trackData->tracks[i].group)
+			return i;
+
+		if (!trackData->tracks[i].group->folded)
+			return i;
+	}
+
+	return active_track;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static int getPrevTrack()
+{
+	TrackData* trackData = &s_editorData.trackData;
+	int i, active_track = getActiveTrack();
+
+	for (i = active_track - 1; i >= 0; --i)
+	{
+		// if track has no group its always safe to assume that can select the track
+
+		if (!trackData->tracks[i].group)
+			return i;
+
+		if (!trackData->tracks[i].group->folded)
+			return i;
+	}
+
+	return active_track;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Editor_create()
 {
 	int id;
@@ -225,16 +274,29 @@ static void drawStatus()
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// In some cases we need an extra update in case some controls has been re-arranged in such fashion so
+// the trackview will report back if that is needed (usually happens if tracks gets resized)
+
+static bool internalUpdate()
+{
+	int refresh;
+
+	Emgui_begin();
+	drawStatus();
+	refresh = TrackView_render(&s_editorData.trackViewInfo, &s_editorData.trackData);
+	Emgui_end();
+
+	return refresh; 
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void Editor_update()
 {
-	Emgui_begin();
+	bool need_update = internalUpdate();
 
-	drawStatus();
+	if (need_update)
-
+		internalUpdate();
-	TrackView_render(&s_editorData.trackViewInfo, &s_editorData.trackData);
-
-	Emgui_end();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -418,7 +480,7 @@ bool Editor_keyDown(int key, int modifiers)
 
 		case EMGUI_ARROW_LEFT:
 		{
-			int track = getActiveTrack() - 1;
+			int track = getPrevTrack();
 
 			if (modifiers & EMGUI_KEY_ALT)
 			{
@@ -448,7 +510,7 @@ bool Editor_keyDown(int key, int modifiers)
 
 		case EMGUI_ARROW_RIGHT:
 		{
-			int track = getActiveTrack() + 1;
+			int track = getNextTrack();
 			int track_count = getTrackCount();
 
 			if (modifiers & EMGUI_KEY_ALT)
@@ -464,7 +526,6 @@ bool Editor_keyDown(int key, int modifiers)
 			if (modifiers & EMGUI_KEY_COMMAND)
 				track = track_count - 1;
 
-
 			setActiveTrack(track);
 
 			if (modifiers & EMGUI_KEY_SHIFT)

ogl_editor/src/TrackData.c

@@ -78,13 +78,19 @@ static void insertTracksInGroup(Group* group, const char* name, bool* processedT
 
 	for (i = index; i < count; ++i)
 	{
+		char* split_name;
+
 		if (processedTracks[i])
 			continue;
 
-		if (strstr(sync->tracks[i]->name, name))
+		if ((split_name = strstr(sync->tracks[i]->name, name)))
 		{
-			rlog(R_DEBUG, "Inserted track %s into group %s\n", sync->tracks[i]->name, group->name);
+			Track* t = &trackData->tracks[i];
-			group->t.tracks[group_index++] = &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;
 		}
 	}
@@ -139,7 +145,9 @@ void TrackData_linkGroups(TrackData* trackData)
 		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);
 

ogl_editor/src/TrackData.h

@@ -18,14 +18,20 @@ enum GroupType
 	GROUP_TYPE_GROUP,
 };
 
+struct Group;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 typedef struct Track
 {
+	char* displayName;
+	struct Group* group;
+
 	uint32_t index;
 	uint32_t color;
 	bool hidden;
 	bool folded;
+	bool selected;
 
 } Track;
 
@@ -35,6 +41,8 @@ typedef struct Track
 typedef struct Group
 {
 	const char* name;
+	char* displayName;
+
 	bool folded;
 	union
 	{

ogl_editor/src/TrackView.c

@@ -18,6 +18,8 @@ const int min_track_size = 100;
 const int colorbar_adjust = ((font_size * 3) + 2);
 static const int name_adjust = font_size * 2;
 
+static bool s_needsUpdate = false;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void TrackView_init()
@@ -67,6 +69,18 @@ static bool drawColorButton(uint32_t color, int x, int y, int size)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+static void drawFoldButton(int x, int y, bool* fold)
+{
+	bool old_state = *fold;
+
+	Emgui_radioButtonImage(g_arrow_left_png, g_arrow_left_png_len, g_arrow_right_png, g_arrow_right_png_len,
+							EMGUI_LOCATION_MEMORY, Emgui_color32(255, 255, 255, 255), x, y, fold);
+
+	s_needsUpdate = old_state != *fold ? true : s_needsUpdate;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 struct TrackInfo
 {
 	TrackViewInfo* viewInfo;
@@ -79,6 +93,7 @@ struct TrackInfo
 	int startPos;
 	int endPos; 
 	int endSizeY;
+	int midPos;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -88,7 +103,7 @@ static int renderName(const char* name, int x, int y, int minSize, bool folded)
 	int size = min_track_size;
 	int text_size;
 	int x_adjust = 0;
-	int spacing = folded ? 0 : 30;
+	int spacing = 30;
 
 	text_size = (Emgui_getTextSize(name) & 0xffff) + spacing;
 
@@ -115,50 +130,13 @@ static int renderName(const char* name, int x, int y, int minSize, bool folded)
 static int renderGroupHeader(Group* group, int x, int y, int groupSize)
 {
 	drawColorButton(Emgui_color32(127, 127, 127, 255), x + 3, y - colorbar_adjust, groupSize);
-	renderName(group->name, x, y - name_adjust, groupSize, group->folded);
+	renderName(group->displayName, x, y - name_adjust, groupSize, group->folded);
 
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-static int renderTrackName(const struct TrackInfo* info, struct sync_track* track, int startX, bool folded)
-{
-	int size = min_track_size;
-	int text_size;
-	int x_adjust = 0;
-	int spacing = folded ? 0 : 30;
-
-	if (!track)
-		return folded ? 1 : size;
-
-	Emgui_setFont(info->viewInfo->smallFontId);
-	text_size = (Emgui_getTextSize(track->name) & 0xffff) + spacing;
-
-	// if text is smaller than min size we center the text
-
-	if (text_size < min_track_size) 
-		x_adjust = (min_track_size - text_size) / 2;
-	else
-		size = text_size + 1; 
-
-	if (folded)
-	{
-		Emgui_drawTextFlipped(track->name, (startX + 3), info->startY + text_size, Emgui_color32(0xff, 0xff, 0xff, 0xff));
-		size = text_size;
-	}
-	else
-	{
-		Emgui_drawText(track->name, (startX + 3) + x_adjust + 16, info->startY - name_adjust, Emgui_color32(0xff, 0xff, 0xff, 0xff));
-	}
-
-	Emgui_setDefaultFont();
-
-	return size;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 static void renderInterpolation(const struct TrackInfo* info, struct sync_track* track, int size, int idx, int x, int y, bool folded) 
 {
 	int fidx;
@@ -218,12 +196,15 @@ static void renderText(const struct TrackInfo* info, struct sync_track* track, i
 
 static int getTrackSize(TrackData* trackData, Track* track)
 {
+	int size = 0;
+
 	if (track->folded)
 		return track_size_folded; 
 
-	// TODO: Need to verify that this is correct
+	size = (Emgui_getTextSize(track->displayName) & 0xffff) + 31; 
+	size = emaxi(size, min_track_size);
 
-	return (Emgui_getTextSize(trackData->syncData.tracks[track->index]->name) & 0xffff) + 31;
+	return size;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -231,10 +212,16 @@ static int getTrackSize(TrackData* trackData, Track* track)
 int getGroupSize(TrackData* trackData, Group* group)
 {
 	int i, size = 0, count = group->trackCount;
+	int text_size = (Emgui_getTextSize(group->name) & 0xffff) + 40;
+
+	if (group->folded)
+		return track_size_folded; 
 
 	for (i = 0; i < count; ++i)
 		size += getTrackSize(trackData, group->t.tracks[i]);
 
+	size = emaxi(size, text_size);
+
 	return size;
 }
 
@@ -252,18 +239,29 @@ static int renderChannel(struct TrackInfo* info, int startX, int editRow, Track*
 	const uint32_t color = trackData->color;
 	bool folded;
 
-	Emgui_radioButtonImage(g_arrow_left_png, g_arrow_left_png_len,
+	if (trackData->selected)
-						   g_arrow_right_png, g_arrow_right_png_len,
+	{
-						   EMGUI_LOCATION_MEMORY, Emgui_color32(255, 255, 255, 255), 
+		Emgui_fill(Emgui_color32(0xff, 0xff, 0x00, 0x80), startX, info->midPos, size, font_size + 1);
-						   startX + 6, info->startY - (font_size + 5),
+
-						   &trackData->folded);
+		//if (trackData->editText)
+		//	Emgui_drawText(trackData->editText, x_pos, info->midPos, Emgui_color32(255, 255, 255, 255));
+	}
+
+	drawFoldButton(startX + 6, info->startY - (font_size + 5), &trackData->folded);
 
 	folded = trackData->folded;
 	
 	if (info->trackData->syncData.tracks)
 		track = info->trackData->syncData.tracks[trackData->index];
 
-	size = renderTrackName(info, track, startX, folded);
+	Emgui_setFont(info->viewInfo->smallFontId);
+
+	if (trackData->displayName)
+		size = renderName(trackData->displayName, startX, info->startY - (font_size * 2), min_track_size, trackData->folded);
+	else
+		size = renderName(track->name, startX, info->startY - (font_size * 2), min_track_size, trackData->folded);
+
+	Emgui_setDefaultFont();
 
 	if (folded)
 	{
@@ -330,12 +328,14 @@ static int renderChannel(struct TrackInfo* info, int startX, int editRow, Track*
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-static int renderGroup(Group* group, int posX, struct TrackInfo* info, TrackData* trackData)
+static int renderGroup(Group* group, int posX, struct TrackInfo info, TrackData* trackData)
 {
 	int i, size, track_count = group->trackCount;
-	int oldY = info->startY;
+	int oldY = info.startY;
 
-	Emgui_setFont(info->viewInfo->smallFontId);
+	drawFoldButton(posX + 6, oldY - (font_size + 5), &group->folded);
+
+	Emgui_setFont(info.viewInfo->smallFontId);
 
 	size = getGroupSize(trackData, group);
 
@@ -347,12 +347,15 @@ static int renderGroup(Group* group, int posX, struct TrackInfo* info, TrackData
 
 	// ----
 
-	info->startY += 40;
+	info.startPos += 5;
+	info.startY += 40;
 
-	for (i = 0; i < track_count; ++i)
+	if (!group->folded)
-		posX += renderChannel(info, posX, -1, group->t.tracks[i]);
+	{
+		for (i = 0; i < track_count; ++i)
+			posX += renderChannel(&info, posX, -1, group->t.tracks[i]);
+	}
 
-	info->startY = oldY;
 
 	Emgui_setDefaultFont();
 	
@@ -399,6 +402,7 @@ void renderGroups(TrackViewInfo* viewInfo, TrackData* trackData)
 	info.startPos = y_pos_row;
 	info.endPos = y_pos_row + end_row; 
 	info.endSizeY = y_end_border;
+	info.midPos = mid_screen_y + adjust_top_size;
 
 	if (trackData->groupCount == 0)
 	{
@@ -422,7 +426,7 @@ void renderGroups(TrackViewInfo* viewInfo, TrackData* trackData)
 		}
 		else
 		{
-			size = renderGroup(group, x_pos, &info, trackData);
+			size = renderGroup(group, x_pos, info, trackData);
 		}
 
 		x_pos += size;
@@ -431,6 +435,7 @@ void renderGroups(TrackViewInfo* viewInfo, TrackData* trackData)
 			break;
 	}
 
+	Emgui_fill(Emgui_color32(127, 127, 127, 56), 0, mid_screen_y + adjust_top_size, viewInfo->windowSizeX, font_size + 1);
 	/*
 	end_track = syncData->num_tracks;
 
@@ -482,9 +487,14 @@ void renderGroups(TrackViewInfo* viewInfo, TrackData* trackData)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
+bool TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
 {
+	s_needsUpdate = false;
+
 	renderGroups(viewInfo, trackData);
+
+	return s_needsUpdate;
+
 	/*
 	struct TrackInfo info;
 	struct sync_data* syncData = &trackData->syncData;

ogl_editor/src/TrackView.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Types.h"
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 struct TrackData* trackData;
@@ -25,5 +27,5 @@ typedef struct TrackViewInfo
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void TrackView_init();
-void TrackView_render(TrackViewInfo* viewInfo, struct TrackData* trackData);
+bool TrackView_render(TrackViewInfo* viewInfo, struct TrackData* trackData);
 

ogl_editor/src/loadsave.c

@@ -130,6 +130,8 @@ static void parseXml(mxml_node_t* rootNode, TrackData* trackData)
 	}
 
 	TrackData_linkGroups(trackData);
+
+	trackData->tracks[0].selected = true;
 }