static void renderText(const struct TrackInfo* info, struct sync_track* track, int row, int idx, int x, int y, bool folded)
{
uint32_t color = (row & 7) ? Emgui_color32(0x4f, 0x4f, 0x4f, 0xff) : Emgui_color32(0x7f, 0x7f, 0x7f, 0xff);
if (folded)
{
if (idx >= 0)
Emgui_fill(color, x, y - font_size_half, 8, 8);
else
Emgui_drawText("-", x, y - font_size_half, color);
}
else
{
if (idx >= 0)
{
char temp[256];
float value = track->keys[idx].value;
snprintf(temp, 256, "% .2f", value);
Emgui_drawText(temp, x, y - font_size_half, Emgui_color32(255, 255, 255, 255));
}
else
{
Emgui_drawText("---", x, y - font_size_half, color);
}
}
}
static void renderInterpolation(const struct TrackInfo* info, struct sync_track* track, int size, int idx, int x, int y, bool folded)
{
int fidx;
enum key_type interpolationType;
uint32_t color = 0;
// This is kinda crappy implementation as we will overdraw this quite a bit but might be fine
fidx = idx >= 0 ? idx : -idx - 2;
interpolationType = (fidx >= 0) ? track->keys[fidx].type : KEY_STEP;
switch (interpolationType)
{
case KEY_STEP :
color = Emgui_color32(0, 0, 0, 255);;
break;
case KEY_LINEAR :
color = Emgui_color32(255, 0, 0, 255);
break;
case KEY_SMOOTH :
color = Emgui_color32(0, 255, 0, 255);
break;
case KEY_RAMP :
color = Emgui_color32(0, 0, 255, 255);
break;
default:
break;
}
if (info->viewInfo)
Emgui_fill(color, x + (size - 8), y - font_size_half, 2, (info->endSizeY - y) + font_size - 1);
}
static bool drawColorButton(uint32_t color, int x, int y, int size)
{
const uint32_t colorFade = Emgui_color32(32, 32, 32, 255);
Emgui_fill(color, x, y, size - 8, 8);
return Emgui_buttonCoords("", colorFade, x, y, size - 8, 8);
}
static void drawStatus()
{
int size = 0;
const int sizeY = s_editorData.trackViewInfo.windowSizeY;
const int sizeX = s_editorData.trackViewInfo.windowSizeX;
const int prevRow = getRowPos();
Emgui_setFont(s_editorData.trackViewInfo.smallFontId);
Emgui_fill(Emgui_color32(20, 20, 20, 255), 2, sizeY - 15, sizeX - 3, 13);
Emgui_drawBorder(Emgui_color32(10, 10, 10, 255), Emgui_color32(10, 10, 10, 255), 0, sizeY - 17, sizeX - 2, 15);
size = drawConnectionStatus(0, sizeY);
size += drawCurrentValue(size, sizeY);
size += drawNameValue("Row", size, sizeY, &s_editorData.trackViewInfo.rowPos, 0, 20000 - 1, s_currentRow);
size += drawNameValue("Start Row", size, sizeY, &s_editorData.trackData.startRow, 0, 10000000, s_startRow);
size += drawNameValue("End Row", size, sizeY, &s_editorData.trackData.endRow, 0, 10000000, s_endRow);
if (getRowPos() != prevRow)
RemoteConnection_sendSetRowCommand(getRowPos());
Emgui_setDefaultFont();
}
bool TrackView_render(TrackViewInfo* viewInfo, TrackData* trackData)
{
struct TrackInfo info;
int start_track = 0; //viewInfo->startTrack;
int x_pos = 128;
int end_track = 0;
int i = 0;
//int track_size;
int adjust_top_size;
int mid_screen_y ;
int y_pos_row, end_row, y_end_border;
s_needsUpdate = false;
// Calc to position the selection in the ~middle of the screen
adjust_top_size = 5 * font_size;
mid_screen_y = (viewInfo->windowSizeY / 2) & ~(font_size - 1);
y_pos_row = viewInfo->rowPos - (mid_screen_y / font_size);
// TODO: Calculate how many channels we can draw given the width
end_row = viewInfo->windowSizeY / font_size;
y_end_border = viewInfo->windowSizeY - 48; // adjust to have some space at the end of the screen
// Shared info for all tracks
info.editText = trackData->editText;
info.selectLeft = emini(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
info.selectRight = emaxi(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
info.selectTop = emini(viewInfo->selectStartRow, viewInfo->selectStopRow);
info.selectBottom = emaxi(viewInfo->selectStartRow, viewInfo->selectStopRow);
info.viewInfo = viewInfo;
info.trackData = trackData;
info.startY = adjust_top_size;
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)
return false;
x_pos = TrackView_getStartOffset() + -viewInfo->startPixel;
printRowNumbers(2, adjust_top_size, end_row, y_pos_row, font_size, trackData->highlightRowStep, y_end_border);
Emgui_drawBorder(border_color, border_color, 48, info.startY - font_size * 4, viewInfo->windowSizeX - 80, (info.endSizeY - info.startY) + 40);
Emgui_setLayer(1);
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 = start_track, end_track = trackData->syncData.num_tracks; i < end_track; )
{
Track* track = &trackData->tracks[i];
Group* group = track->group;
if (group->trackCount == 1)
{
int track_size = getTrackSize(viewInfo, track);
if ((x_pos + track_size > 0) && (x_pos < viewInfo->windowSizeX))
{
// if selected track is less than the first rendered track then we need to reset it to this one
Emgui_setFont(info.viewInfo->smallFontId);
renderChannel(&info, x_pos, track, false);
}
x_pos += track_size;
++i;
}
else
{
x_pos += renderGroup(group, track, x_pos, &i, info, trackData);
}
}
Emgui_setDefaultFont();
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;
}
static int renderChannel(struct TrackInfo* info, int startX, Track* trackData, bool valuesOnly)
{
int y, y_offset;
int text_size = 0;
int size = min_track_size;
int startPos = info->startPos;
const int trackIndex = trackData->index;
const int endPos = info->endPos;
struct sync_track* track = 0;
const uint32_t color = trackData->color;
bool folded = false;
if (!valuesOnly)
{
drawFoldButton(startX + 6, info->startY - (font_size + 5), &trackData->folded, trackData->active);
folded = trackData->folded;
if (info->trackData->syncData.tracks)
track = info->trackData->syncData.tracks[trackData->index];
size = renderName(trackData->displayName, startX, info->startY - (font_size * 2), min_track_size, folded, trackData->active);
if (folded)
{
text_size = size;
size = track_size_folded;
}
if (trackData->active)
{
if (drawColorButton(color, startX + 4, info->startY - colorbar_adjust, size))
{
Dialog_showColorPicker(&trackData->color);
if (trackData->color != color)
s_needsUpdate = true;
}
}
else
{
Emgui_fill(border_color, startX + 4, info->startY - colorbar_adjust, size - 8, 8);
}
}
Emgui_setDefaultFont();
y_offset = info->startY;
folded = valuesOnly ? true : folded;
size = valuesOnly ? track_size_folded : size;
if (valuesOnly)
{
Emgui_fill(border_color, startX + size, info->startY - font_size * 4, 2, (info->endSizeY - info->startY) + 40);
Emgui_fill(border_color, startX, info->startY - font_size * 4, 2, (info->endSizeY - info->startY) + 40);
}
else
{
Emgui_drawBorder(border_color, border_color, startX, info->startY - font_size * 4, size, (info->endSizeY - info->startY) + 40);
}
// if folded we should skip rendering the rows that are covered by the text
if (folded)
{
int skip_rows = (text_size + font_size * 2) / font_size;
if (startPos + skip_rows > 0)
{
startPos += skip_rows;
y_offset += skip_rows * font_size;
}
}
if (startPos < 0)
{
y_offset = info->startY + (font_size * -startPos);
startPos = 0;
}
y_offset += font_size_half;
for (y = startPos; y < endPos; ++y)
{
int idx = -1;
int offset = startX + 6;
bool selected;
if (track)
idx = sync_find_key(track, y);
renderInterpolation(info, track, size, idx, offset, y_offset, folded);
if (!(trackData->selected && info->viewInfo->rowPos == y && info->editText))
renderText(info, track, y, idx, offset, y_offset, folded);
selected = (trackIndex >= info->selectLeft && trackIndex <= info->selectRight) &&
(y >= info->selectTop && y <= info->selectBottom);
if (selected)
Emgui_fill(selection_color, startX, y_offset - font_size_half, size, font_size);
if (y != 0)
{
if (TrackData_hasBookmark(info->trackData, y))
Emgui_fill(bookmark_color, startX, y_offset - font_size_half, size, 8);
}
y_offset += font_size;
if (y_offset > (info->endSizeY + font_size_half))
break;
}
if (!Emgui_hasKeyboardFocus())
{
if (trackData->selected)
{
Emgui_fill(trackData->group->folded ? dark_active_track_color : active_track_color, startX, info->midPos, size, font_size + 1);
if (info->editText)
Emgui_drawText(info->editText, startX + 2, info->midPos, Emgui_color32(255, 255, 255, 255));
}
}
Emgui_setFont(info->viewInfo->smallFontId);
return size;
}
