vino/rocket
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Various fixes

Browse Source 
* 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
This commit is contained in:
Daniel Collin 2013-06-30 23:28:14 +02:00
parent 9f75f7e81f
commit 143379804c
4 changed files with 115 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
ogl_editor/src/Editor.c
View File

@ -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)
return group->t.track->index;
else
return group->t.tracks[0]->index;
printf("newIndex %d\n", group->tracks[0]->index);
return group->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->t.track->index;
else
return group->t.tracks[trackIndex]->index;
return 0;
return group->tracks[trackIndex]->index;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -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;

14
ogl_editor/src/TrackData.c
View File

@ -111,12 +111,14 @@ 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);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

8
ogl_editor/src/TrackData.h
View File

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

113
ogl_editor/src/TrackView.c
View File

@ -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,11 +732,7 @@ 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);
size += getGroupSize(viewInfo, group, 0);
}
return size;
@ -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]);
}