static void endEditing()
{
const char* track_name;
struct track_key key;
struct sync_track* track;
int row_pos = getRowPos();
int active_track = getActiveTrack();
if (!is_editing || !getTracks())
return;
track = getTracks()[active_track];
if (strcmp(s_editBuffer, ""))
{
key.row = row_pos;
key.value = (float)atof(s_editBuffer);
key.type = 0;
if (track->num_keys > 0)
{
int idx = sync_find_key(track, getRowPos());
if (idx > 0)
{
// exact match, keep current type
key.type = track->keys[emaxi(idx, 0)].type;
}
else
{
// no match, grab type from previous key
if (idx < 0)
idx = -idx - 1;
key.type = track->keys[emaxi(idx - 1, 0)].type;
}
}
track_name = track->name;
Commands_addOrUpdateKey(active_track, &key);
updateNeedsSaving();
}
is_editing = false;
s_editorData.trackData.editText = 0;
}
static bool doEditing(int key)
{
// special case if '.' key (in case of dvorak) would clatch with the same key for biasing we do this special case
if ((key == '.' || key == EMGUI_KEY_BACKSPACE) && !is_editing)
return false;
if ((key >= '0' && key <= '9') || key == '.' || key == '-' || key == EMGUI_KEY_BACKSPACE)
{
if (!is_editing)
{
memset(s_editBuffer, 0, sizeof(s_editBuffer));
is_editing = true;
}
if (key == EMGUI_KEY_BACKSPACE)
s_editBuffer[emaxi(strlen(s_editBuffer) - 1, 0)] = 0;
else
s_editBuffer[strlen(s_editBuffer)] = (char)key;
s_editorData.trackData.editText = s_editBuffer;
return true;
}
return false;
}
static void biasSelection(float value)
{
int track, row;
struct sync_track** tracks = getTracks();
TrackViewInfo* viewInfo = getTrackViewInfo();
int selectLeft = mini(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
int selectRight = maxi(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
int selectTop = mini(viewInfo->selectStartRow, viewInfo->selectStopRow);
int selectBottom = maxi(viewInfo->selectStartRow, viewInfo->selectStopRow);
// If we have no selection and no currenty key bias the previous key
if (selectLeft == selectRight && selectTop == selectBottom)
{
int idx;
struct sync_track* track;
struct sync_track** tracks = getTracks();
if (!tracks || !tracks[getActiveTrack()]->keys)
return;
track = tracks[getActiveTrack()];
idx = sync_find_key(track, getRowPos());
if (idx < 0)
{
idx = -idx - 1;
selectTop = selectBottom = track->keys[emaxi(idx - 1, 0)].row;
}
}
Commands_beginMulti("biasSelection");
for (track = selectLeft; track <= selectRight; ++track)
{
struct sync_track* t = tracks[track];
for (row = selectTop; row <= selectBottom; ++row)
{
struct track_key newKey;
int idx = sync_find_key(t, row);
if (idx < 0)
continue;
newKey = t->keys[idx];
newKey.value += value;
Commands_updateKey(track, &newKey);
}
}
Commands_endMulti();
updateNeedsSaving();
}
static int getTrackSize(TrackViewInfo* viewInfo, Track* track)
{
if (track->folded)
return track_size_folded;
if (track->width == 0)
{
Emgui_setFont(viewInfo->smallFontId);
track->width = (Emgui_getTextSize(track->displayName) & 0xffff) + 31;
track->width = emaxi(track->width, min_track_size);
}
return track->width;
}
static void drawHorizonalSlider()
{
int large_val;
TrackViewInfo* info = getTrackViewInfo();
const int old_start = s_editorData.trackViewInfo.startPixel;
const int total_track_width = TrackView_getWidth(info, getTrackData()) - (info->windowSizeX / 2);
large_val = emaxi(total_track_width / 10, 1);
Emgui_slider(0, info->windowSizeY - 36, info->windowSizeX, 14, 0, total_track_width, large_val,
EMGUI_SLIDERDIR_HORIZONTAL, 1, &s_editorData.trackViewInfo.startPixel);
if (old_start != s_editorData.trackViewInfo.startPixel)
Editor_updateTrackScroll();
}
int getGroupSize(TrackViewInfo* viewInfo, Group* group, int startTrack)
{
int i, size = 0, count = group->trackCount;
if (group->width == 0)
group->width = (Emgui_getTextSize(group->name) & 0xffff) + 40;
if (group->folded)
return track_size_folded;
for (i = startTrack; i < count; ++i)
size += getTrackSize(viewInfo, group->t.tracks[i]);
size = emaxi(size, group->width);
return size;
}
static void onPrevNextKey(bool prevKey, enum Selection selection)
{
struct sync_track* track;
struct sync_track** tracks = getTracks();
TrackViewInfo* viewInfo = getTrackViewInfo();
if (!tracks || !tracks[getActiveTrack()]->keys)
return;
track = tracks[getActiveTrack()];
if (prevKey)
{
int idx = sync_find_key(track, getRowPos());
if (idx < 0)
idx = -idx - 1;
setRowPos(track->keys[emaxi(idx - 1, 0)].row);
if (selection == DO_SELECTION)
viewInfo->selectStopRow = getRowPos();
else
viewInfo->selectStartRow = viewInfo->selectStopRow = getRowPos();
}
else
{
int row = 0;
int idx = key_idx_floor(track, getRowPos());
if (idx < 0)
row = track->keys[0].row;
else if (idx > (int)track->num_keys - 2)
row = track->keys[track->num_keys - 1].row;
else
row = track->keys[idx + 1].row;
setRowPos(row);
if (selection == DO_SELECTION)
viewInfo->selectStopRow = row;
else
viewInfo->selectStartRow = viewInfo->selectStopRow = row;
}
}
static void onEnterCurrentValue()
{
int idx;
struct track_key key;
struct sync_track* track;
struct sync_track** tracks = getTracks();
const int rowPos = getRowPos();
const int activeTrack = getActiveTrack();
if (!tracks)
return;
track = tracks[activeTrack];
if (!track->keys)
{
key.row = rowPos;
key.value = 0.0f;
key.type = 0;
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
return;
}
idx = sync_find_key(track, rowPos);
if (idx < 0)
idx = -idx - 1;
key.row = rowPos;
if (track->num_keys > 0)
{
key.value = (float)sync_get_val(track, rowPos);
key.type = track->keys[emaxi(idx - 1, 0)].type;
}
else
{
key.value = 0.0f;
key.type = 0;
}
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
}
void Editor_updateTrackScroll()
{
int track_start_offset, sel_track, total_track_width = 0;
int track_start_pixel = s_editorData.trackViewInfo.startPixel;
TrackData* track_data = getTrackData();
TrackViewInfo* view_info = getTrackViewInfo();
total_track_width = TrackView_getWidth(getTrackViewInfo(), getTrackData());
track_start_offset = TrackView_getStartOffset();
track_start_pixel = eclampi(track_start_pixel, 0, emaxi(total_track_width - (view_info->windowSizeX / 2), 0));
sel_track = TrackView_getScrolledTrack(view_info, track_data, track_data->activeTrack,
track_start_offset - track_start_pixel);
if (sel_track != track_data->activeTrack)
TrackData_setActiveTrack(track_data, sel_track);
s_editorData.trackViewInfo.startPixel = track_start_pixel;
}
static void drawVerticalSlider()
{
int start_row = 0, end_row = 10000, width, large_val;
TrackData* trackData = getTrackData();
TrackViewInfo* info = getTrackViewInfo();
const int rowPos = getRowPos();
if (trackData)
{
start_row = trackData->startRow;
end_row = trackData->endRow;
}
width = end_row - start_row;
large_val = emaxi(width / 10, 1);
Emgui_slider(info->windowSizeX - 26, 0, 20, info->windowSizeY, 0, width, large_val,
EMGUI_SLIDERDIR_VERTICAL, 1, &s_editorData.trackViewInfo.rowPos);
if (rowPos != getRowPos())
Editor_updateTrackScroll();
}
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;
}
