drag_cursor_motion(cursor_x, cursor_y,
over_track, over_edit, over_pluginset, over_plugin);
}
- if( over_track && !*over_track )
+ if( over_track && !*over_track )
*over_track = pane->over_patchbay();
return 0;
}
// Find the edit and track the cursor is over
for(Track *track = mwindow->edl->tracks->first; track; track = track->next)
{
+ if( track->is_hidden() ) continue;
int64_t track_x, track_y, track_w, track_h;
track_dimensions(track, track_x, track_y, track_w, track_h);
mwindow->session->edit_highlighted->length);
}
start = mwindow->edl->align_to_frame(start, 0);
- mwindow->insert_effects_canvas(start, length);
+ mwindow->insert_effects_canvas(track, start, length);
*redraw = 1;
}
if( mwindow->session->track_highlighted )
double track_position = track->from_units(drop_position);
track_position = mwindow->edl->align_to_frame(track_position, 0);
mwindow->move_edits(mwindow->session->drag_edits,
- track, track_position, !insertion);
+ track, track_position, insertion);
}
result = 1;
edit_track = edit_track->previous;
drop_track = drop_track->previous;
}
- if( drop_track && test_track_group(drag_group, drop_track) ) {
- double position = mwindow->edl->get_cursor_position(cursor_x, pane->number);
- position = mwindow->edl->align_to_frame(position, 0);
- position -= mwindow->session->drag_group_position;
- mwindow->move_group(drag_group, drop_track, position);
+ if( drop_track ) {
+ double cur_pos = mwindow->session->drag_group_position;
+ double new_pos = mwindow->edl->get_cursor_position(cursor_x, pane->number);
+ new_pos -= mwindow->session->drag_position - cur_pos;
+ new_pos = mwindow->edl->align_to_frame(new_pos, 0);
+ double drop_position = new_pos;
+ int ret = test_track_group(drag_group, drop_track, new_pos);
+ if( !ret && new_pos != drop_position ) {
+ drop_position = new_pos;
+ ret = test_track_group(drag_group, drop_track, new_pos);
+ }
+ if( ret >= 0 )
+ mwindow->move_group(drag_group, drop_track, drop_position,
+ ret > 0 ? !shift_down() : shift_down());
+ drag_group->remove_user();
+ mwindow->session->drag_group = 0;
}
- drag_group->remove_user();
- mwindow->session->drag_group = 0;
}
result = 1;
break;
int rerender = 0;
int new_cursor, update_cursor;
- if(mwindow->session->current_operation != NO_OPERATION) return 0;
+ if( mwindow->session->current_operation == GROUP_TOGGLE )
+ mwindow->session->current_operation = NO_OPERATION;
+ else if( mwindow->session->current_operation != NO_OPERATION )
+ return 0;
if(is_event_win()) {
if(do_plugins(get_drag_x(), get_drag_y(),
void TrackCanvas::update_cursor(int flush)
{
- switch(mwindow->edl->session->editing_mode)
- {
- case EDITING_ARROW: set_cursor(ARROW_CURSOR, 0, flush); break;
- case EDITING_IBEAM: set_cursor(IBEAM_CURSOR, 0, flush); break;
- }
+ if( arrow_mode() )
+ set_cursor(ARROW_CURSOR, 0, flush);
+ else if( ibeam_mode() )
+ set_cursor(IBEAM_CURSOR, 0, flush);
}
void TrackCanvas::test_timer()
{
- if(resource_timer->get_difference() > 1000 &&
- !hourglass_enabled)
- {
+ if( resource_timer->get_difference() > 1000 && !hourglass_enabled ) {
start_hourglass();
hourglass_enabled = 1;
}
gui->resource_pixmaps.remove_all_objects();
if(debug) PRINT_TRACE
+ if(mode != IGNORE_THREAD)
+ gui->resource_thread->reset(pane->number, indexes_only);
// Search every edit
for(Track *current = mwindow->edl->tracks->first;
current;
current = NEXT)
{
+ if( current->is_hidden() ) continue;
if(debug) PRINT_TRACE
for(Edit *edit = current->edits->first; edit; edit = edit->next)
{
}
}
+ int64_t track_x, track_y, track_w, track_h;
+ track_dimensions(current,
+ track_x, track_y, track_w, track_h);
+ set_color((~get_resources()->get_bg_color()) & 0xffffff);
+ set_opaque();
+ int x1 = track_x, x2 = x1+track_w;
+ int y1 = track_y+track_h-1;
+ draw_line(x1,y1, x2,y1, background_pixmap);
}
// }
// }
- pixmap_h = mwindow->edl->local_session->zoom_track;
Track *track = edit->edits->track;
+ pixmap_h = track->data_h;
if( track->show_titles() )
pixmap_h += mwindow->theme->get_image("title_bg_data")->get_h();
//printf("get_pixmap_size %d %d %d %d\n", edit_x, edit_w, pixmap_x, pixmap_w);
if( edit->track->show_titles() )
edit_h += mwindow->theme->get_image("title_bg_data")->get_h();
if( edit->track->show_assets() )
- edit_h += resource_h();
+ edit_h += edit->track->data_h;
h = edit_h;
}
for(Track *dest = mwindow->session->track_highlighted;
dest;
dest = dest->next) {
- if(dest->record) {
+ if( dest->is_hidden() ) continue;
+ if(dest->is_armed()) {
// Get source width in pixels
w = -1;
// Use start of highlighted edit
if( plugin->track->show_titles() )
y += mwindow->theme->get_image("title_bg_data")->get_h();
if( plugin->track->show_assets() )
- y += resource_h();
+ y += plugin->track->data_h;
y += plugin->plugin_set->get_number() *
mwindow->theme->get_image("plugin_bg_data")->get_h();
h = mwindow->theme->get_image("plugin_bg_data")->get_h();
}
-int TrackCanvas::resource_h()
-{
- return mwindow->edl->local_session->zoom_track;
-}
void TrackCanvas::draw_highlight_rectangle(int x, int y, int w, int h)
{
if (x + w <= 0)
{
- draw_triangle_left(0, y + h /6, h * 2/3, h * 2/3, BLACK, GREEN, YELLOW, RED, BLUE);
+ draw_triangle_left(0, y + h /6,
+ h * 2/3, h * 2/3, BLACK, GREEN, YELLOW, RED, BLUE);
return;
} else
if (x >= get_w())
{
- draw_triangle_right(get_w() - h * 2/3, y + h /6, h * 2/3, h * 2/3, BLACK, GREEN, YELLOW, RED, BLUE);
+ draw_triangle_right(get_w() - h * 2/3, y + h /6,
+ h * 2/3, h * 2/3, BLACK, GREEN, YELLOW, RED, BLUE);
return;
}
// Fix bug in heroines & cvs version as of 22.8.2005:
// If we grab when zoomed in and zoom out while dragging, when edit gets really narrow strange things start happening
if (w >= 0 && w < 3) {x -= w /2; w = 3;};
- if(x < -10)
- {
- w += x - -10;
- x = -10;
- }
-
- if(y < -10)
- {
- h += y - -10;
- y = -10;
- }
+ if(x < -10) { w += x - -10; x = -10; }
+ if(y < -10) { h += y - -10; y = -10; }
w = MIN(w, get_w() + 20);
h = MIN(h, get_h() + 20);
// Fix bug in heroines & cvs version as of 22.8.2005:
// If we grab when zoomed in and zoom out while dragging, when edit gets really narrow strange things start happening
if (w >= 0 && w < 3) {x -= w /2; w = 3;};
- if(x < -10)
- {
- w += x - -10;
- x = -10;
- }
- if(y < -10)
- {
- h += y - -10;
- y = -10;
- }
+ if(x < -10) { w += x - -10; x = -10; }
+ if(y < -10) { h += y - -10; y = -10; }
w = MIN(w, get_w() + 20);
h = MIN(h, get_h() + 20);
set_color(mwindow->preferences->highlight_inverse);
void TrackCanvas::get_transition_coords(Edit *edit,
int64_t &x, int64_t &y, int64_t &w, int64_t &h)
{
- int transition_w = 30, transition_h = 30;
+ int transition_w = xS(30), transition_h = yS(30);
int has_titles = edit->track->show_titles();
int has_assets = edit->track->show_assets();
double title_bg_h = mwindow->theme->get_image("title_bg_data")->get_h();
- double asset_h = resource_h();
- double ys = has_assets ? asset_h : has_titles ? title_bg_h : 0;
+ int data_h = edit->track->data_h;
+ double ys = has_assets ? data_h : has_titles ? title_bg_h : 0;
double dy = has_titles ?
- ( has_assets ? title_bg_h + asset_h/2 : title_bg_h/2 ) :
- ( has_assets ? asset_h/2 : 0) ;
+ ( has_assets ? title_bg_h + data_h/2 : title_bg_h/2 ) :
+ ( has_assets ? data_h/2 : 0) ;
double title_h = mwindow->theme->title_h;
if( dy < title_h / 2 ) { ys = title_h; dy = ys / 2; }
y += dy;
edit_track = edit_track->previous;
track = track->previous;
}
- int color = track && test_track_group(drag_group, track) ? GREEN : RED;
+ int cx = get_cursor_x();
+ double cur_pos = mwindow->session->drag_group_position;
+ double new_pos = mwindow->edl->get_cursor_position(cx, pane->number);
+ new_pos -= mwindow->session->drag_position - cur_pos;
+ new_pos = mwindow->edl->align_to_frame(new_pos, 0);
+ double drop_position = new_pos;
+ int color = GREEN;
+ int ret = test_track_group(drag_group, track, new_pos);
+ if( ret < 0 )
+ color = ORANGE;
+ else if( !ret ) {
+ if( new_pos != drop_position ) {
+ double pos = new_pos;
+ pos += mwindow->session->drag_position - cur_pos;
+ cx = mwindow->edl->get_position_cursorx(pos, pane->number);
+ ret = test_track_group(drag_group, track, new_pos);
+ }
+ color = ret > 0 ? YELLOW : shift_down() ? RED : BLUE;
+ }
track_dimensions(mwindow->session->track_highlighted, x, y, w, h);
- int dx = get_cursor_x() - mwindow->session->drag_origin_x;
+ int dx = cx - mwindow->session->drag_origin_x;
int dy = y - mwindow->session->drag_origin_y;
draw_selected_edits(mwindow->edl, dx, dy, color, -1);
}
draw_selected_edits(mwindow->edl, 0, 0, GREEN+BLUE, RED);
}
+// x does not reliably draw a really big rectangle
+void TrackCanvas::draw_selected(int x, int y, int w, int h)
+{
+ int x1 = bmax(x, 0), x2 = bmin(x+w, get_w());
+ if( x1 > x2 ) return;
+ int y1 = bmax(y, 0), y2 = bmin(y+h, get_h());
+ if( y1 > y2 ) return;
+ if( x >= 0 && x < get_w() ) draw_line(x,y1, x,y2);
+ if( x+w >= 0 && x+w < get_w() ) draw_line(x+w,y1, x+w,y2);
+ if( y >= 0 && y < get_h() ) draw_line(x1,y, x2,y);
+ if( y+h >= 0 && y+h < get_h() ) draw_line(x1,y+h, x2,y+h);
+}
+
void TrackCanvas::draw_selected_edits(EDL *edl, int dx, int dy, int color0, int color1)
{
+ int dropping = 0;
for( Track *track=edl->tracks->first; track; track=track->next ) {
+ if( track->is_hidden() ) continue;
+ if( !track->is_armed() && color1 < 0 ) {
+ if( dropping )
+ dy -= track->vertical_span(mwindow->theme);
+ continue;
+ }
for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
if( !edit->is_selected ) continue;
+ dropping = 1;
int64_t x, y, w, h;
edit_dimensions(edit, x, y, w, h);
x += dx; y += dy;
set_opaque();
int inner = color1 < 0 ? color0 : !edit->group_id ? color0 :
mwindow->get_group_color(edit->group_id);
- set_color(inner);
- draw_rectangle(x, y, w, h);
int outer = color1 < 0 ? color0 : !edit->group_id ? color1 : inner;
- set_color(outer);
- draw_rectangle(x-1, y-1, w+2, h+2);
+ set_color(track->is_armed() ? inner : outer);
+ draw_selected(x, y, w, h);
+ set_color(track->is_armed() ? outer : inner);
+ draw_selected(x-1, y-1, w+2, h+2);
+ draw_selected(x-2, y-2, w+1, h+1);
}
}
}
track;
track = track->next)
{
+ if( track->is_hidden() ) continue;
if(track->expand_view)
{
for(int i = 0; i < track->plugin_set.total; i++)
toggle_x = MIN(get_w() - right_margin, toggle_x);
// On toggle
- toggle_x -= PluginOn::calculate_w(mwindow) + 10;
+ toggle_x -= PluginOn::calculate_w(mwindow) + xS(10);
if(toggle_x > min_x)
{
if(current_on >= plugin_on_toggles.total)
if(plugin->plugin_type == PLUGIN_STANDALONE)
{
// Show
- toggle_x -= PluginShow::calculate_w(mwindow) + 10;
+ toggle_x -= PluginShow::calculate_w(mwindow) + xS(10);
if(toggle_x > min_x)
{
if(current_show >= plugin_show_toggles.total)
}
current_show++;
}
- toggle_x -= PluginPresetEdit::calculate_w(mwindow) + 10;
+ toggle_x -= PluginPresetEdit::calculate_w(mwindow) + xS(10);
if(toggle_x > min_x)
{
if(current_preset >= preset_edit_buttons.total)
void TrackCanvas::draw_hard_edges()
{
+ if( !mwindow->edl->session->auto_conf->hard_edges )
+ return;
int64_t x, y, w, h;
for(Track *track = mwindow->edl->tracks->first; track; track = track->next) {
+ if( track->is_hidden() ) continue;
for(Edit *edit = track->edits->first; edit; edit = edit->next) {
if( !edit->hard_left && !edit->hard_right ) continue;
edit_dimensions(edit, x, y, w, h);
+ if( !MWindowGUI::visible(x, x + w, 0, get_w()) ||
+ !MWindowGUI::visible(y, y + h, 0, get_h()) ) continue;
set_color(GREEN);
set_opaque();
int y1 = y;
if( track->show_titles() )
y1 += mwindow->theme->get_image("title_bg_data")->get_h();
if( track->show_assets() )
- y1 += resource_h();
+ y1 += track->data_h;
if( y1 == y )
y1 += mwindow->theme->title_h;
if( edit->hard_left ) {
void TrackCanvas::draw_drag_handle()
{
- if(mwindow->session->current_operation == DRAG_EDITHANDLE2 ||
- mwindow->session->current_operation == DRAG_PLUGINHANDLE2)
- {
-//printf("TrackCanvas::draw_drag_handle 1 %ld %ld\n", mwindow->session->drag_sample, mwindow->edl->local_session->view_start);
- int64_t pixel1 = Units::round(mwindow->session->drag_position *
- mwindow->edl->session->sample_rate /
- mwindow->edl->local_session->zoom_sample -
- mwindow->edl->local_session->view_start[pane->number]);
-//printf("TrackCanvas::draw_drag_handle 2 %d %jd\n", pane->number, pixel1);
- set_color(!snapped ? GREEN : (snapped=0, YELLOW));
- set_inverse();
-//printf("TrackCanvas::draw_drag_handle 3\n");
- draw_line(pixel1, 0, pixel1, get_h());
- set_opaque();
-//printf("TrackCanvas::draw_drag_handle 4\n");
+ if( mwindow->session->current_operation != DRAG_EDITHANDLE2 &&
+ mwindow->session->current_operation != DRAG_PLUGINHANDLE2 ) return;
+ int64_t pixel1 = Units::round(mwindow->session->drag_position *
+ mwindow->edl->session->sample_rate /
+ mwindow->edl->local_session->zoom_sample -
+ mwindow->edl->local_session->view_start[pane->number]);
+ set_color(!snapped ? GREEN : (snapped=0, YELLOW));
+ set_inverse();
+ draw_line(pixel1, 0, pixel1, get_h());
+ set_opaque();
+
+ if( mwindow->session->current_operation != DRAG_EDITHANDLE2 ) return;
+ if( !mwindow->session->drag_edit ) return;
+ int group_id = mwindow->session->drag_edit->group_id;
+ if( !group_id ) return;
+ int64_t dx, dy, dw, dh;
+ edit_dimensions(mwindow->session->drag_edit, dx, dy, dw, dh);
+ int drag_handle = mwindow->session->drag_handle;
+ int64_t pixel0 = !drag_handle ? dx : dx + dw;
+ int delta = pixel1 - pixel0;
+ set_color(LTPURPLE);
+ set_line_width(3);
+
+ for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
+ if( track->is_hidden() ) continue;
+ Edit *left = 0, *right = 0;
+ double start = DBL_MAX, end = DBL_MIN;
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( edit->group_id != group_id ) continue;
+ double edit_start = edit->track->from_units(edit->startproject);
+ if( edit_start < start ) { start = edit_start; left = edit; }
+ double edit_end = edit->track->from_units(edit->startproject+edit->length);
+ if( edit_end > end ) { end = edit_end; right = edit; }
+ }
+ Edit *edit = !drag_handle ? left : right;
+ if( !edit ) continue;
+ Indexable *idxbl = edit->asset;
+ if( !idxbl ) idxbl = edit->nested_edl;
+ int can_drag = idxbl ? 1 : 0;
+ if( drag_handle ) {
+ int64_t source_len = !idxbl ? -1 :
+ edit->track->data_type == TRACK_AUDIO ?
+ idxbl->get_audio_samples() :
+ edit->track->data_type == TRACK_VIDEO ?
+ idxbl->get_video_frames() : -1;
+ int64_t speed_start = edit->startproject;
+ int64_t speed_end = speed_start + edit->length;
+ int64_t speed_length = track->speed_length(speed_start, speed_end);
+ if( edit->startsource + speed_length >= source_len )
+ can_drag = 0;
+ }
+ else if( !edit->startsource )
+ can_drag = 0;
+ int64_t x, y, w, h;
+ edit_dimensions(edit, x, y, w, h);
+ if( y+h < 0 || y >= get_h() ) continue;
+ int edge_x = !drag_handle ? x : x + w;
+ int edge_y = y + h/2, xs10 = xS(10), ys10 = yS(10);
+ if( edge_x >= 0 && edge_x < get_w() ) {
+ if( !can_drag ) {
+ draw_line(edge_x-xs10,edge_y-ys10, edge_x+xs10,edge_y+ys10);
+ draw_line(edge_x-xs10,edge_y+ys10, edge_x+xs10,edge_y-ys10);
+ }
+ else if( !drag_handle ) {
+ draw_line(edge_x+xs10,edge_y-ys10, edge_x,edge_y);
+ draw_line(edge_x+xs10,edge_y+ys10, edge_x,edge_y);
+ }
+ else {
+ draw_line(edge_x,edge_y, edge_x-xs10,edge_y-ys10);
+ draw_line(edge_x,edge_y, edge_x-xs10,edge_y+ys10);
+ }
+ }
+ edge_x += delta;
+ if( edge_x >= 0 && edge_x < get_w() ) {
+ draw_line(edge_x, y, edge_x, y+h);
+ }
}
+ set_line_width(1);
}
int64_t x, y, w, h;
for(Track *track = mwindow->edl->tracks->first; track; track = track->next) {
+ if( track->is_hidden() ) continue;
if( !track->show_transitions() ) continue;
for(Edit *edit = track->edits->first; edit; edit = edit->next) {
// track context menu to appear
int result = 0;
EDLSession *session = mwindow->edl->session;
-
-
+ int gang = session->gang_tracks != GANG_NONE || get_double_click() ? 1 : 0;
static BC_Pixmap *auto_pixmaps[AUTOMATION_TOTAL] =
{
pankeyframe_pixmap,
modekeyframe_pixmap,
maskkeyframe_pixmap,
+ 0,
};
for(Track *track = mwindow->edl->tracks->first;
track && !result;
track = track->next) {
+ if( track->is_hidden() ) continue;
Auto *auto_keyframe = 0;
Automation *automation = track->automation;
if( !result && buttonpress && i == AUTOMATION_SPEED )
mwindow->speed_after(-1);
- int current_grouptype = mwindow->edl->local_session->zoombar_showautotype;
- if( result && buttonpress && grouptype != current_grouptype ) {
- mwindow->edl->local_session->zoombar_showautotype = grouptype;
- mwindow->gui->zoombar->update_autozoom();
+ if( result && buttonpress ) {
+ int color = GWindowGUI::auto_colors[i];
+ mwindow->gui->zoombar->update_autozoom(grouptype, color);
}
break; }
if (buttonpress != 3)
{
if(i == AUTOMATION_FADE || i == AUTOMATION_SPEED)
- fill_ganged_autos(get_double_click(), 0, track,
+ fill_ganged_autos(gang, 0, track,
(FloatAuto*)mwindow->session->drag_auto);
mwindow->session->current_operation = pre_auto_operations[i];
update_drag_caption();
new_cursor = UPRIGHT_ARROW_CURSOR;
}
-
return result;
}
int autoidx = dragging && keyframe_hairline != HAIRLINE_ALWAYS ?
mwindow->session->drag_auto->autos->autoidx : -1;
- if( get_buttonpress() == 1 && dragging &&
- keyframe_hairline == HAIRLINE_DRAGGING ) {
+ if( get_buttonpress() == LEFT_BUTTON && dragging &&
+ keyframe_hairline == HAIRLINE_DRAGGING ) {
draw_hairline(mwindow->session->drag_auto, RED, 1);
return;
}
- if( keyframe_hairline == HAIRLINE_ALWAYS || ( get_buttonpress() == 2 &&
+ if( keyframe_hairline == HAIRLINE_ALWAYS || ( get_buttonpress() == MIDDLE_BUTTON &&
keyframe_hairline == HAIRLINE_DRAGGING && dragging ) ) {
int show = dragging || keyframe_hairline == HAIRLINE_ALWAYS ? 1 : 0;
for( Track *track = mwindow->edl->tracks->first; track; track=track->next ) {
+ if( track->is_hidden() ) continue;
Automation *automation = track->automation;
for( int i=0; i<AUTOMATION_TOTAL; ++i ) {
if( !mwindow->edl->session->auto_conf->autos[i] ) continue;
}
}
-void TrackCanvas::draw_auto(Auto *current,
- int x,
- int y,
- int center_pixel,
- int zoom_track)
+void TrackCanvas::draw_auto(Auto *current, int x, int y,
+ int center_pixel, int data_h)
{
int x1, y1, x2, y2;
y1 = center_pixel + y - HANDLE_W / 2;
y2 = center_pixel + y + HANDLE_W / 2;
- if(y1 < center_pixel + -zoom_track / 2) y1 = center_pixel + -zoom_track / 2;
- if(y2 > center_pixel + zoom_track / 2) y2 = center_pixel + zoom_track / 2;
+ if( y1 < center_pixel - data_h/2 ) y1 = center_pixel - data_h/2;
+ if( y2 > center_pixel + data_h/2 ) y2 = center_pixel + data_h/2;
draw_box(x1, y1, x2 - x1, y2 - y1);
}
void TrackCanvas::draw_floatauto(FloatAuto *current,
- int x,
- int y,
- int in_x,
- int in_y,
- int out_x,
- int out_y,
- int center_pixel,
- int zoom_track,
- int color)
+ int x_offset, int center_pixel, int data_h, int color,
+ double unit_start, double zoom_units, double yscale,
+ int autogrouptype)
{
+ double xx, yy;
+ calculate_auto_position(1, &xx, &yy, 0, 0, 0, 0,
+ current, unit_start, zoom_units, yscale, autogrouptype);
+ int x = (int)xx + x_offset;
int x1 = x - HANDLE_W / 2; // Center
int x2 = x + HANDLE_W / 2;
- int y1 = center_pixel + y - HANDLE_H / 2;
- int y2 = center_pixel + y + HANDLE_H / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ int y = (int)yy + center_pixel;
+ int y1 = y - HANDLE_H / 2;
+ int y2 = y + HANDLE_H / 2;
+ int ymin = center_pixel - data_h / 2;
+ int ymax = center_pixel + data_h / 2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
- if(y2 - 1 > y1)
- {
- set_color(BLACK);
- draw_box(x1 + 1, y1 + 1, x2 - x1, y2 - y1);
- set_color(color);
- draw_box(x1, y1, x2 - x1, y2 - y1);
+ if( y2-1 > y1 ) {
+ if( current->curve_mode == FloatAuto::LINEAR ) {
+ draw_box(x1, y1, x2 - x1, y2 - y1);
+ }
+ else {
+ ArrayList<int> polygon_x;
+ ArrayList<int> polygon_y;
+ polygon_x.append((x1 + x2) / 2 + 1);
+ polygon_y.append(y1 + 1);
+ polygon_x.append(x2 + 1);
+ polygon_y.append((y1 + y2) / 2 + 1);
+ polygon_x.append((x1 + x2) / 2 + 1);
+ polygon_y.append(y2 + 1);
+ polygon_x.append(x1 + 1);
+ polygon_y.append((y1 + y2) / 2 + 1);
+ fill_polygon(&polygon_x, &polygon_y);
+ }
}
// show bezier control points (only) if this
// floatauto doesn't adjust it's tangents automatically
if(current->curve_mode != FloatAuto::FREE &&
- current->curve_mode != FloatAuto::TFREE)
+ current->curve_mode != FloatAuto::TFREE &&
+ current->curve_mode != FloatAuto::BUMP)
return;
-
- if(in_x != x)
- draw_floatauto_ctrlpoint(x, y, in_x, in_y, center_pixel, zoom_track, color);
- if(out_x != x)
- draw_floatauto_ctrlpoint(x, y, out_x, out_y, center_pixel, zoom_track, color);
+ double in_xx, in_yy, out_xx, out_yy;
+ calculate_auto_position(1, &xx, &yy, &in_xx, &in_yy, 0, 0,
+ current, unit_start, zoom_units, yscale, autogrouptype);
+ int ix = xx, iy = yy, in_x = in_xx, in_y = in_yy;
+ if( in_x != ix )
+ draw_floatauto_ctrlpoint(ix, iy, in_x, in_y, center_pixel, data_h, color);
+ calculate_auto_position(0, &xx, &yy, 0, 0, &out_xx, &out_yy,
+ current, unit_start, zoom_units, yscale, autogrouptype);
+ int ox = xx, oy = yy, out_x = out_xx, out_y = out_yy;
+ if( out_x != ox )
+ draw_floatauto_ctrlpoint(ox, oy, out_x, out_y, center_pixel, data_h, color);
+ if( current->curve_mode == FloatAuto::BUMP && iy != oy )
+ draw_bline(ix, iy+center_pixel, ox, oy+center_pixel);
}
inline int quantize(float f) { return (int)floor(f + 0.5); }
inline void TrackCanvas::draw_floatauto_ctrlpoint(
- int x, int y, int cp_x, int cp_y, int center_pixel,
- int zoom_track, int color)
+ int x, int y, int cp_x, int cp_y, int center_pixel,
+ int data_h, int color)
// draw the tangent and a handle for given bézier ctrl point
{
- bool handle_visible = (abs(cp_y) <= zoom_track / 2);
+ bool handle_visible = (abs(cp_y) <= data_h/2);
float slope = (float)(cp_y - y)/(cp_x - x);
- CLAMP(cp_y, -zoom_track / 2, zoom_track / 2);
+ CLAMP(cp_y, -data_h/2, data_h/2);
if(slope != 0)
cp_x = x + quantize((cp_y - y) / slope);
int TrackCanvas::test_auto(Auto *current,
- int x, int y, int center_pixel, int zoom_track,
+ int x, int y, int center_pixel, int data_h,
int cursor_x, int cursor_y, int buttonpress)
{
int x1, y1, x2, y2;
x2 = x + HANDLE_W / 2;
y1 = center_pixel + y - HANDLE_H / 2;
y2 = center_pixel + y + HANDLE_H / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ int ymin = center_pixel - data_h/2;
+ int ymax = center_pixel + data_h/2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
-int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x,
- int in_y, int out_x, int out_y, int center_pixel, int zoom_track,
- int cursor_x, int cursor_y, int buttonpress, int autogrouptype)
+int TrackCanvas::test_floatauto(FloatAuto *current, int buttonpress,
+ int center_pixel, int data_h, int cursor_x, int cursor_y,
+ double unit_start, double zoom_units, double yscale,
+ int autogrouptype)
{
int result = 0;
-
- int x1 = x - HANDLE_W / 2;
- int x2 = x + HANDLE_W / 2;
- int y1 = center_pixel + y - HANDLE_W / 2;
- int y2 = center_pixel + y + HANDLE_W / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ double xx, yy, in_xx, in_yy, out_xx, out_yy;
+ calculate_auto_position(1, &xx, &yy, &in_xx, &in_yy, 0, 0,
+ current, unit_start, zoom_units, yscale, autogrouptype);
+ int ix = xx, iy = yy, in_x = in_xx, in_y = in_yy;
+
+ int x1 = ix - HANDLE_W / 2;
+ int x2 = ix + HANDLE_W / 2;
+ int y1 = center_pixel + iy - HANDLE_W / 2;
+ int y2 = center_pixel + iy + HANDLE_W / 2;
+ int ymin = center_pixel - data_h/2;
+ int ymax = center_pixel + data_h/2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
CLAMP(in_y1, ymin, ymax);
CLAMP(in_y2, ymin, ymax);
+ calculate_auto_position(0, &xx, &yy, 0, 0, &out_xx, &out_yy,
+ current, unit_start, zoom_units, yscale, autogrouptype);
+ int ox = xx, oy = yy, out_x = out_xx, out_y = out_yy;
int out_x1 = out_x - HANDLE_W / 2;
int out_x2 = out_x + HANDLE_W / 2;
int out_y1 = center_pixel + out_y - HANDLE_W / 2;
float lever = 0.0; // we use the tangent as a draggable lever. 1.0 is at the ctrl point
// Test in control
- if( in_x != x && current->position > 0 &&
+ if( in_x != ix && current->position > 0 &&
(FloatAuto::FREE == current->curve_mode ||
- FloatAuto::TFREE == current->curve_mode))
+ FloatAuto::TFREE == current->curve_mode ||
+ FloatAuto::BUMP == current->curve_mode))
// act on in control handle only if
// tangent is significant and is editable (not automatically choosen)
{
- lever = test_curve_line(x, y, in_x, in_y, cursor_x, cursor_y-center_pixel);
+ lever = test_curve_line(ix, iy, in_x, in_y, cursor_x, cursor_y-center_pixel);
// either cursor in ctrl-point handle or cursor on tangent line
if( WITHIN(in_x1,in_x2,in_y1,in_y2) || lever > 0.0 ) {
result = 1;
}
// Test out control
- if(out_x != x &&
+ if(out_x != ox &&
(FloatAuto::FREE == current->curve_mode ||
- FloatAuto::TFREE == current->curve_mode))
+ FloatAuto::TFREE == current->curve_mode ||
+ FloatAuto::BUMP == current->curve_mode))
// act on out control only if tangent is significant and is editable
{
- lever = test_curve_line(x, y, out_x, out_y, cursor_x, cursor_y-center_pixel);
+ lever = test_curve_line(ox, oy, out_x, out_y, cursor_x, cursor_y-center_pixel);
if(WITHIN(out_x1,out_x2,out_y1,out_y2) || lever > 0.0 ) {
result = 1;
if(buttonpress && (buttonpress != 3)) {
if(buttonpress && (buttonpress != 3) && result)
{
mwindow->undo->update_undo_before();
+ double position = current->autos->track->from_units(current->position);
+ mwindow->edl->local_session->set_selectionstart(position);
+ mwindow->edl->local_session->set_selectionend(position);
}
return result;
}
+static int is_linear(FloatAuto *prev, FloatAuto *next)
+{
+ if( !prev || !next ) return 0;
+ if( prev->curve_mode == FloatAuto::LINEAR ) return 1;
+ int64_t ipos = prev->get_control_in_position();
+ int64_t opos = prev->get_control_out_position();
+ if( !ipos && !opos ) return 1;
+ if( !ipos || !opos ) return 0;
+ float ival = next->get_control_in_value();
+ float oval = prev->get_control_out_value();
+ float cval = prev->get_value(0), nval = next->get_value(1);
+ if( !ival && !oval && EQUIV(cval, nval) ) return 1;
+ float ig = ival / ipos, og = oval / opos;
+ int64_t cpos = prev->position, npos = next->position;
+ float g = (nval - cval) / (npos - cpos);
+ if( !EQUIV(g, 0) && EQUIV(ig, g) && EQUIV(og, g) ) return 1;
+ return 0;
+}
// Get the float value & y for position x on the canvas
#define X_TO_FLOATLINE(x) \
- int64_t position1 = (int64_t)(unit_start + x * zoom_units); \
- int64_t position2 = (int64_t)(unit_start + x * zoom_units) + 1; \
+ double position = unit_start + x * zoom_units; \
+ int64_t position1 = (int64_t)position, position2 = position1 + 1; \
/* Call by reference fails for some reason here */ \
float value1 = autos->get_value(position1, PLAY_FORWARD, previous1, next1); \
float value2 = autos->get_value(position2, PLAY_FORWARD, previous1, next1); \
- double position = unit_start + x * zoom_units; \
- double value = 0; \
- if(position2 > position1) \
- { \
- value = value1 + \
- (value2 - value1) * \
- (position - position1) / \
- (position2 - position1); \
- } \
- else \
- { \
- value = value1; \
- } \
+ double value = value1 + (value2 - value1) * (position - position1); \
AUTOMATIONCLAMPS(value, autogrouptype); \
int y = center_pixel + \
(int)(((value - automation_min) / automation_range - 0.5) * -yscale);
int x1, int y1, int x2, int y2,
int color, int autogrouptype)
{
+ int ytop = center_pixel - yscale / 2;
+ int ybot = center_pixel + yscale / 2 - 1;
+ y1 += center_pixel; y2 += center_pixel;
+ if( (y1 < ytop && y1 >= ybot) && (y2 < ytop || y2 >= ybot) ) return;
+// check for line draw
+ if( is_linear(previous, next) ) {
+ if( previous && previous->curve_mode == FloatAuto::BUMP ) {
+ double ax, ay;
+ calculate_auto_position(0, &ax, &ay, 0, 0, 0, 0, previous,
+ unit_start, zoom_units, yscale, autogrouptype);
+ x1 = ax; y1 = ay; y1 += center_pixel;
+ }
+ draw_line(x1, y1, x2, y2);
+ return;
+ }
+
// Solve bezier equation for either every pixel or a certain large number of
// points.
// Not using slope intercept
x1 = MAX(0, x1);
- int prev_y = y1 + center_pixel;
-
+ draw_pixel(x1, y1);
+ int prev_y = y1;
// Call by reference fails for some reason here
FloatAuto *previous1 = previous, *next1 = next;
float automation_min = mwindow->edl->local_session->automation_mins[autogrouptype];
float automation_max = mwindow->edl->local_session->automation_maxs[autogrouptype];
float automation_range = automation_max - automation_min;
-
- for(int x = x1; x < x2; x++)
- {
+ if( autogrouptype == AUTOGROUPTYPE_SPEED && automation_range < SPEED_MIN )
+ automation_range = SPEED_MIN;
+ for( int x=x1; x<x2; ++x ) {
// Interpolate value between frames
X_TO_FLOATLINE(x)
- if(/* x > x1 && */
- y >= center_pixel - yscale / 2 &&
- y < center_pixel + yscale / 2 - 1)
- {
-// printf("TrackCanvas::draw_floatline y=%d min=%d max=%d\n",
-// y,
-// (int)(center_pixel - yscale / 2),
-// (int)(center_pixel + yscale / 2 - 1));
-
-//printf("draw_line(%d,%d, %d,%d)\n", x - 1, prev_y , x, y);
- draw_line(x - 1, prev_y , x, y );
+ if( /* x > x1 && */ y >= ytop && y < ybot ) {
+ int x1 = x-1, y1 = prev_y, x2 = x, y2 = y;
+ if( abs(y2-y1) < 2 )
+ draw_pixel(x2, y2);
+ else
+ draw_bline(x1, y1, x2, y2);
}
prev_y = y;
}
}
-
-
-
int TrackCanvas::test_floatline(int center_pixel,
FloatAutos *autos,
double unit_start,
float automation_min = mwindow->edl->local_session->automation_mins[autogrouptype];
float automation_max = mwindow->edl->local_session->automation_maxs[autogrouptype];
float automation_range = automation_max - automation_min;
+ if( autogrouptype == AUTOGROUPTYPE_SPEED && automation_range < SPEED_MIN )
+ automation_range = SPEED_MIN;
FloatAuto *previous1 = 0, *next1 = 0;
X_TO_FLOATLINE(cursor_x);
return result;
}
-
-void TrackCanvas::fill_ganged_autos(int all, float change, Track *skip, FloatAuto *fauto)
+// gang=-1 for keyframepopup update, all tracks where fautos exist
+// gang=0 for trackcanvas drag update, all gang matching tracks, create new fautos if needed
+// gang=1 for trackcanvas drag update, all gang tracks, create new fautos if needed
+void TrackCanvas::fill_ganged_autos(int gang, float change, Track *skip, FloatAuto *fauto)
{
- if( !skip->gang ) return;
+ if( !skip->is_ganged() ) return;
// Handles the special case of modifying a fadeauto
// when there are ganged faders on several tracks
double position = skip->from_units(fauto->position);
int autoidx = fauto->autos->autoidx;
-
+ PatchGUI *patch = gang < 0 ? pane->patchbay->get_patch_of(skip) : 0;
+ int edge = patch ? patch->edge : 0;
+ int span = patch ? patch->span : 0;
for(Track *current = mwindow->edl->tracks->first; current; current = NEXT) {
- if( (all || current->data_type == skip->data_type) &&
- current->gang && current->record && current != skip ) {
+ if( (gang || current->data_type == skip->data_type) &&
+ current->armed_gang(skip) && current->is_armed() &&
+ current != skip ) {
FloatAutos *fade_autos = (FloatAutos*)current->automation->autos[autoidx];
- float auto_min = mwindow->edl->local_session->automation_mins[fade_autos->autogrouptype];
- float auto_max = mwindow->edl->local_session->automation_maxs[fade_autos->autogrouptype];
- int64_t current_position = current->to_units(position, 1);
FloatAuto *keyframe = (FloatAuto*)fade_autos->get_auto_at_position(position);
+ int64_t current_position = current->to_units(position, 1);
if( keyframe ) {
// keyframe exists, just change it
- float value = keyframe->get_value();
- float new_value = value + change;
- CLAMP(new_value, auto_min, auto_max);
- keyframe->adjust_to_new_coordinates(current_position, new_value);
+ keyframe->bump_update(current_position, change, edge, span);
}
- else {
+ else if( gang >= 0 && ( get_double_click() ||
+ mwindow->edl->session->auto_keyframes ) ) {
// create keyframe on neighbouring track at the point in time given by fauto
FloatAuto *previous = 0, *next = 0;
float value = fade_autos->get_value(current_position, PLAY_FORWARD, previous, next);
float new_value = value + change;
- CLAMP(new_value, auto_min, auto_max);
+ float auto_min = mwindow->edl->local_session->automation_mins[fade_autos->autogrouptype];
+ float auto_max = mwindow->edl->local_session->automation_maxs[fade_autos->autogrouptype];
+ bclamp(new_value, auto_min, auto_max);
keyframe = (FloatAuto*)fade_autos->insert_auto(current_position);
- keyframe->set_value(new_value);
+ keyframe->set_value(new_value, edge);
}
+ else
+ continue;
mwindow->session->drag_auto_gang->append((Auto *)keyframe);
}
}
for (int i = 0; i < mwindow->session->drag_auto_gang->total; i++) {
FloatAuto *keyframe = (FloatAuto *)mwindow->session->drag_auto_gang->values[i];
int64_t keyframe_position = keyframe->autos->track->to_units(position, 1);
- float new_value = keyframe->get_value() + change;
- CLAMP(new_value,
- mwindow->edl->local_session->automation_mins[keyframe->autos->autogrouptype],
- mwindow->edl->local_session->automation_maxs[keyframe->autos->autogrouptype]);
- keyframe->adjust_to_new_coordinates(keyframe_position, new_value);
+ keyframe->bump_update(keyframe_position, change, 0, 0);
+ keyframe->set_control_in_value(fauto->get_control_in_value());
+ keyframe->set_control_out_value(fauto->get_control_out_value());
}
}
int has_titles = track->show_titles();
int has_assets = track->show_assets();
double title_bg_h = mwindow->theme->get_image("title_bg_data")->get_h();
- double asset_h = resource_h();
double title_h = mwindow->theme->title_h;
- double ys = has_assets ? asset_h : has_titles ? title_bg_h : 0;
+ double data_h = track->data_h;
+ double ys = has_assets ? data_h : has_titles ? title_bg_h : 0;
double dy = has_titles ?
- ( has_assets ? title_bg_h + asset_h/2 : title_bg_h/2) :
- ( has_assets ? asset_h/2 : 0) ;
+ ( has_assets ? title_bg_h + data_h/2 : title_bg_h/2) :
+ ( has_assets ? data_h/2 : 0) ;
if( dy < title_h/2 ) { ys = title_h; dy = ys / 2; }
yscale = ys;
center_pixel = y + dy;
}
-void TrackCanvas::calculate_auto_position(double *x, double *y,
+void TrackCanvas::calculate_auto_position(int edge, double *x, double *y,
double *in_x, double *in_y, double *out_x, double *out_y,
Auto *current, double unit_start, double zoom_units, double yscale,
int autogrouptype)
float automation_min = mwindow->edl->local_session->automation_mins[autogrouptype];
float automation_max = mwindow->edl->local_session->automation_maxs[autogrouptype];
float automation_range = automation_max - automation_min;
+ if( autogrouptype == AUTOGROUPTYPE_SPEED && automation_range < SPEED_MIN )
+ automation_range = SPEED_MIN;
FloatAuto *ptr = (FloatAuto*)current;
*x = (double)(ptr->position - unit_start) / zoom_units;
- *y = ((ptr->get_value() - automation_min) / automation_range - 0.5) * -yscale;
+ *y = ((ptr->get_value(edge) - automation_min) / automation_range - 0.5) * -yscale;
if(in_x) {
// *in_x = EQUIV(ptr->control_in_value, 0.0) ? *x : *x - mwindow->theme->control_pixels;
}
if(in_y) {
- *in_y = (((ptr->get_value() + ptr->get_control_in_value()) -
+ *in_y = (((ptr->get_value(edge) + ptr->get_control_in_value()) -
automation_min) / automation_range - 0.5) * -yscale;
}
}
if(out_y) {
- *out_y = (((ptr->get_value() + ptr->get_control_out_value()) -
+ *out_y = (((ptr->get_value(edge) + ptr->get_control_out_value()) -
automation_min) / automation_range - 0.5) * -yscale;
}
}
double view_start, unit_start;
double view_end, unit_end, yscale;
double zoom_sample, zoom_units;
- double in_x2, in_y2, out_x2, out_y2;
double slope;
//int skip = 0;
double ax = 0, ay = 0, ax2 = 0, ay2 = 0;
if( first_auto ) {
- calculate_auto_position(&ax, &ay, 0, 0, 0, 0,
+ calculate_auto_position(0, &ax, &ay, 0, 0, 0, 0,
first_auto, unit_start, zoom_units, yscale, autogrouptype);
}
if( current )
draw_auto = 1;
if(current) {
- calculate_auto_position(&ax2, &ay2, &in_x2, &in_y2, &out_x2, &out_y2,
+ calculate_auto_position(1, &ax2, &ay2, 0, 0, 0, 0,
current, unit_start, zoom_units, yscale, autogrouptype);
}
else {
// Draw or test handle
if( current && !result && current != autos->default_auto ) {
- if( !draw && track->record ) {
- result = test_floatauto((FloatAuto*)current, (int)ax2, (int)ay2,
- (int)in_x2, (int)in_y2, (int)out_x2, (int)out_y2,
+ if( !draw && track->is_armed() ) {
+ result = test_floatauto((FloatAuto*)current, buttonpress,
(int)center_pixel, (int)yscale, cursor_x, cursor_y,
- buttonpress, autogrouptype);
+ unit_start, zoom_units, yscale, autogrouptype);
if( result )
auto_instance = current;
}
if( draw && draw_auto ) {
- draw_floatauto((FloatAuto*)current, (int)ax2 + x_offset, (int)ay2,
- (int)in_x2 + x_offset, (int)in_y2,
- (int)out_x2 + x_offset, (int)out_y2,
- (int)center_pixel + y_offset, (int)yscale, color);
+ draw_floatauto((FloatAuto*)current, x_offset,
+ (int)center_pixel + y_offset, (int)yscale, color,
+ unit_start, zoom_units, yscale, autogrouptype);
}
}
// Draw or test joining line
- if( !draw && !result && track->record /* && buttonpress != 3 */ ) {
+ if( !draw && !result && track->is_armed() /* && buttonpress != 3 */ ) {
result = test_floatline(center_pixel,
(FloatAutos*)autos, unit_start, zoom_units, yscale,
// Exclude auto coverage from the end of the line. The auto overlaps
if( current ) {
previous = current;
+ calculate_auto_position(0, &ax2, &ay2, 0, 0, 0, 0, previous,
+ unit_start, zoom_units, yscale, autogrouptype);
current = NEXT;
}
-
ax = ax2; ay = ay2;
} while( current && current->position <= unit_end && !result );
if( ax < get_w() && !result ) {
ax2 = get_w(); ay2 = ay;
- if(!draw && track->record /* && buttonpress != 3 */ ) {
+ if(!draw && track->is_armed() /* && buttonpress != 3 */ ) {
result = test_floatline(center_pixel,
(FloatAutos*)autos, unit_start, zoom_units, yscale,
(int)ax, (int)ax2, cursor_x, cursor_y,
{
if(!draw)
{
- if(track->record)
+ if(track->is_armed())
{
result = test_auto(current,
(int)ax2,
{
if(!result)
{
- if(track->record /* && buttonpress != 3 */)
+ if(track->is_armed() /* && buttonpress != 3 */)
{
result = test_toggleline(autos,
center_pixel,
ay2 = ay;
if(!draw)
{
- if(track->record /* && buttonpress != 3 */)
+ if(track->is_armed() /* && buttonpress != 3 */)
{
result = test_toggleline(autos,
center_pixel,
if( track->show_titles() )
center_pixel += mwindow->theme->get_image("title_bg_data")->get_h();
if( track->show_assets() )
- center_pixel += resource_h();
+ center_pixel += track->data_h;
center_pixel += (i + 0.5) * mwindow->theme->get_image("plugin_bg_data")->get_h();
for(Plugin *plugin = (Plugin*)plugin_set->first;
calculate_viewport(track, view_start, unit_start, view_end, unit_end,
yscale, center_pixel, zoom_sample, zoom_units);
+ if( auto_keyframe->position < unit_start ||
+ auto_keyframe->position >= unit_end )
+ return 0;
double ax = 0, ay = 0;
- calculate_auto_position(&ax, &ay, 0, 0, 0, 0,
+ calculate_auto_position(0, &ax, &ay, 0, 0, 0, 0,
auto_keyframe, unit_start, zoom_units, yscale, autogrouptype);
set_color(color);
draw_line(ax, 0, ax, get_h());
+ char text[BCSTRLEN];
if( show ) {
- char text[BCSTRLEN];
if( auto_keyframe->is_floatauto() ) {
FloatAuto *float_auto = (FloatAuto *)auto_keyframe;
sprintf(text, "%0.2f", float_auto->get_value());
}
- else {
+ else if( auto_keyframe->is_intauto() ) {
IntAuto *int_auto = (IntAuto *)auto_keyframe;
sprintf(text, "%d", int_auto->value);
}
+ else
+ show = 0;
+ }
+ if( show ) {
int font = MEDIUMFONT;
- int tw = get_text_width(font, text) + TOOLTIP_MARGIN * 2;
- int th = get_text_height(font, text) + TOOLTIP_MARGIN * 2;
+ int tw = get_text_width(font, text) + xS(TOOLTIP_MARGIN) * 2;
+ int th = get_text_height(font, text) + yS(TOOLTIP_MARGIN) * 2;
set_color(get_resources()->tooltip_bg_color);
ax += HANDLE_W/2;
ay += center_pixel + HANDLE_W/2;
set_color(BLACK);
draw_rectangle(ax, ay, tw, th);
set_font(font);
- ax += TOOLTIP_MARGIN;
- ay += TOOLTIP_MARGIN + get_text_ascent(font);
+ ax += xS(TOOLTIP_MARGIN);
+ ay += yS(TOOLTIP_MARGIN) + get_text_ascent(font);
draw_text(ax, ay, text);
}
return 0;
int new_cursor, update_cursor, rerender;
// Move background pixmap to foreground pixmap
- draw_pixmap(background_pixmap,
- 0,
- 0,
- get_w(),
- get_h(),
- 0,
- 0);
+ draw_pixmap(background_pixmap, 0, 0, get_w(), get_h(), 0, 0);
// In/Out points
draw_inout_points();
edl->create_objects();
edl->copy_all(mwindow->edl);
MainSession *session = mwindow->session;
- int edit_mode = mwindow->edl->session->edit_handle_mode[session->drag_button];
+ int handle_mode = mwindow->edl->session->edit_handle_mode[session->drag_button];
edl->modify_edithandles(session->drag_start,
- session->drag_position,
- session->drag_handle,
- edit_mode,
+ session->drag_position, session->drag_handle, handle_mode,
edl->session->labels_follow_edits,
edl->session->plugins_follow_edits,
- edl->session->autos_follow_edits);
- double position = edit_mode != MOVE_NO_EDITS &&
- ( session->drag_handle || edit_mode == MOVE_ONE_EDIT ) ?
+ edl->session->autos_follow_edits,
+ !session->drag_edit ? 0 : session->drag_edit->group_id);
+
+ double position = -1;
+ int show_edge = !session->drag_handle ? 1 : 2;
+ switch( handle_mode ) {
+ case MOVE_RIPPLE:
+ case MOVE_EDGE:
+ position = session->drag_handle ?
session->drag_position : session->drag_start;
+ show_edge = 3 - show_edge;
+ break;
+ case MOVE_ROLL:
+ case MOVE_SLIDE:
+ position = session->drag_position;
+ break;
+ case MOVE_SLIP:
+ position = session->drag_start;
+ show_edge = 3 - show_edge;
+ break;
+ }
+
+ if( position < 0 ) position = 0;
Track *track = session->drag_handle_track();
int64_t pos = track->to_units(position, 0);
- render_handle_frame(edl, pos, shift_down() ? 0 :
- session->drag_handle ? 1 : 2);
+ render_handle_frame(edl, pos, shift_down() ? 0 : show_edge);
edl->remove_user();
}
}
CICache *video_cache = new CICache(preferences);
render_engine->set_vcache(video_cache);
render_engine->arm_command(&command);
- int64_t left = pos-1;
- if( left < 0 ) left = 0;
VRender *vrender = render_engine->vrender;
result = vrender &&
!vrender->process_buffer(&vlt, left, 0) &&
!vrender->process_buffer(&vrt, pos , 0) ? 0 : 1;
delete render_engine;
- delete video_cache;
+ video_cache->remove_user();
mwindow->cwindow->gui->lock_window("TrackCanvas::render_handle_frame 0");
Canvas *canvas = mwindow->cwindow->gui->canvas;
- canvas->lock_canvas("TrackCanvas::render_handle_frame 1");
- int w = canvas->w, h = canvas->h, w2 = w/2, h2 = h/2;
- int lx = 0, ly = h2/2, rx = w2, ry = h2/2;
+ float ox1, oy1, ox2, oy2, cx1, cy1, cx2, cy2;
+ canvas->get_transfers(edl, ox1, oy1, ox2, oy2, cx1, cy1, cx2, cy2);
+ float cw = canvas->w/2, ch = canvas->h/2;
+ float cdx = (cx2 - cx1)/2, cdy = (cy2 - cy1)/2;
+ int cx = cx1/2, cy = cy1/2 + ch/2;
+ int ow = ox2 - ox2, oh = oy2 - oy1;
BC_WindowBase *window = canvas->get_canvas();
window->set_color(BLACK);
window->clear_box(0,0, window->get_w(),window->get_h());
- window->draw_vframe(&vlt, lx,ly, w2,h2, 0,0,vlt.get_w(),vlt.get_h());
- window->draw_vframe(&vrt, rx,ry, w2,h2, 0,0,vrt.get_w(),vrt.get_h());
+ window->draw_vframe(&vlt, cx,cy, cdx,cdy, ox1,oy1, ow,oh); cx += cw;
+ window->draw_vframe(&vrt, cx,cy, cdx,cdy, ox1,oy1, ow,oh);
window->flash(1);
- canvas->unlock_canvas();
mwindow->cwindow->gui->unlock_window();
break; }
case 1:
Track *track = mwindow->session->drag_handle_track();
double position = track->from_units(mode == 1 ? left : pos);
if( position < 0 ) position = 0;
- edl->local_session->set_selectionstart(position);
- edl->local_session->set_selectionend(position);
PlaybackEngine *playback_engine = mwindow->cwindow->playback_engine;
if( playback_engine->is_playing_back )
playback_engine->stop_playback(1);
+ edl->local_session->set_selectionstart(position);
+ edl->local_session->set_selectionend(position);
mwindow->cwindow->playback_engine->refresh_frame(CHANGE_EDL, edl, 0);
break; }
}
*percentage = 0;
*position = 0;
- if(!current->autos->track->record) return 1;
+ if(!current->autos->track->is_armed()) return 1;
double view_start;
double unit_start;
double view_end;
#define UPDATE_DRAG_HEAD(do_clamp) \
int result = 0, center_pixel; \
- if(!current->autos->track->record) return 0; \
+ if(!current->autos->track->is_armed()) return 0; \
double view_start, unit_start, view_end, unit_end; \
double yscale, zoom_sample, zoom_units; \
\
// not really editing the node, rather start editing the curve
// tangent is editable and drag movement is significant
if( (FloatAuto::FREE == current->curve_mode ||
- FloatAuto::TFREE==current->curve_mode) &&
+ FloatAuto::TFREE==current->curve_mode ||
+ FloatAuto::BUMP==current->curve_mode) &&
(fabs(x) > HANDLE_W / 2 || fabs(y) > HANDLE_W / 2))
mwindow->session->drag_handle = x < 0 ? 1 : 2;
}
// Snap to nearby values
old_value = current->get_value();
if(shift_down()) {
- double value1, value2, distance1, distance2;
-
+ double distance1=-1, distance2=-1;
if(current->previous) {
int autogrouptype = current->previous->autos->autogrouptype;
value = percentage_to_value(percentage, 0, 0, autogrouptype);
- value1 = ((FloatAuto*)current->previous)->get_value();
+ double value1 = ((FloatAuto*)current->previous)->get_value(0);
distance1 = fabs(value - value1);
- current->set_value(value1);
+ current->set_value(value1, 1);
}
if(current->next) {
int autogrouptype = current->next->autos->autogrouptype;
value = percentage_to_value(percentage, 0, 0, autogrouptype);
- value2 = ((FloatAuto*)current->next)->get_value();
+ double value2 = ((FloatAuto*)current->next)->get_value(1);
distance2 = fabs(value - value2);
if(!current->previous || distance2 < distance1) {
- current->set_value(value2);
+ current->set_value(value2, 0);
}
}
if(!current->previous && !current->next) {
- current->set_value( ((FloatAutos*)current->autos)->default_);
+ current->set_value(((FloatAutos*)current->autos)->default_, 0);
}
value = current->get_value();
}
float change = value - old_value;
current->adjust_to_new_coordinates(position, value);
update_ganged_autos(change, current->autos->track, current);
- show_message(current, 1,", %.2f", current->get_value());
+ int color = GWindowGUI::auto_colors[current->autos->autoidx];
+ show_message(current, color, ", %.2f", current->get_value());
}
break;
value * levered_position(position - current->position,
current->get_control_in_position()));
update_ganged_autos(0, current->autos->track, current);
- show_message(current, 1,", %.2f", current->get_control_in_value());
+ int color = GWindowGUI::auto_colors[current->autos->autoidx];
+ show_message(current, color, ", %.2f", current->get_control_in_value());
}
break; }
value * levered_position(position - current->position,
current->get_control_out_position()));
update_ganged_autos(0, current->autos->track, current);
- show_message(current, 1,", %.2f", current->get_control_out_value());
+ int color = GWindowGUI::auto_colors[current->autos->autoidx];
+ show_message(current, color, ", %.2f", current->get_control_out_value());
}
break; }
}
result = 1;
current->value = value;
current->position = position;
- show_message(current, 0,", %d", current->value);
+ show_message(current, -1, ", %d", current->value);
}
return result;
{
result = 1;
current->position = position;
- show_message(current, 0,"");
+ show_message(current, -1, "");
double position_f = current->autos->track->from_units(current->position);
double center_f = (mwindow->edl->local_session->get_selectionstart(1) +
mwindow->session->track_highlighted = track;
result = 1;
current->position = position;
- show_message(current, 0,"");
+ show_message(current, -1, "");
double position_f = current->autos->track->from_units(current->position);
double center_f = (mwindow->edl->local_session->get_selectionstart(1) +
int update_scroll = 0;
int update_overlay = 0;
int update_cursor = 0;
- int new_cursor = 0;
int rerender = 0;
double position = 0.;
//printf("TrackCanvas::cursor_update %d\n", __LINE__);
// Default cursor
- switch(mwindow->edl->session->editing_mode)
- {
- case EDITING_ARROW: new_cursor = ARROW_CURSOR; break;
- case EDITING_IBEAM: new_cursor = IBEAM_CURSOR; break;
- }
+ int new_cursor =
+ arrow_mode() ? ARROW_CURSOR :
+ ibeam_mode() ? IBEAM_CURSOR : 0;
switch(mwindow->session->current_operation)
{
result = 1;
break; }
+ case GROUP_TOGGLE: {
+ Edit *edit = mwindow->session->drag_edit;
+ if( edit ) {
+ if( shift_down() && edit->is_selected ) {
+ if( edit->group_id > 0 ) {
+ mwindow->edl->tracks->clear_selected_edits();
+ mwindow->edl->tracks->del_group(edit->group_id);
+ }
+ else {
+ int id = mwindow->session->group_number++;
+ mwindow->edl->tracks->new_group(id);
+ }
+ redraw = 0;
+ }
+ else {
+ if( mwindow->preferences->ctrl_toggle && !ctrl_down() )
+ mwindow->edl->tracks->clear_selected_edits();
+ edit->set_selected(-1);
+ }
+ }
+ mwindow->session->current_operation = NO_OPERATION;
+ update_overlay = 1;
+ result = 1;
+ drag_scroll = 0;
+ break; }
+
default:
- if(mwindow->session->current_operation) {
+ if( mwindow->session->current_operation ) {
// if(mwindow->session->current_operation == SELECT_REGION) {
// mwindow->undo->update_undo_after(_("select"), LOAD_SESSION, 0, 0);
// }
mwindow->session->current_operation = NO_OPERATION;
drag_scroll = 0;
-// Traps button release events
-// result = 1;
+ //result = 0;
+ break;
}
break;
}
}
+ if( mwindow->edl->local_session->zoombar_showautocolor >= 0 )
+ mwindow->gui->zoombar->update_autozoom(-1);
+
if (result)
cursor_update(0);
int result = 0;
for( Track *track=mwindow->edl->tracks->first; track && !result; track=track->next) {
+ if( track->is_hidden() ) continue;
for( Edit *edit=track->edits->first; edit && !result; edit=edit->next ) {
int64_t edit_x, edit_y, edit_w, edit_h;
edit_dimensions(edit, edit_x, edit_y, edit_w, edit_h);
}
}
+ if( result > 0 ) {
+ int group_id = edit_result->group_id;
+ if( group_id > 0 ) {
+ Track *track = edit_result->track;
+ Edit *left = 0, *right = 0;
+ double start = DBL_MAX, end = DBL_MIN;
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( edit->group_id != group_id ) continue;
+ double edit_start = edit->track->from_units(edit->startproject);
+ if( edit_start < start ) { start = edit_start; left = edit; }
+ double edit_end = edit->track->from_units(edit->startproject+edit->length);
+ if( edit_end > end ) { end = edit_end; right = edit; }
+ }
+ Edit *edit = !handle_result ? left : right;
+ if( edit != edit_result )
+ result = 0;
+ }
+ }
+
update_cursor = 1;
if( result > 0 ) {
double position = 0;
update_overlay = 1;
}
}
- else if( result < 0 ) {
+ else if( result < 0 && !edit_result->silence() ) {
mwindow->undo->update_undo_before();
if( !shift_down() ) {
if( handle_result == 0 )
if( handle_result == 1 ) edit_edge += edit_result->length;
double edge_position = edit_result->track->from_units(edit_edge);
for( Track *track=mwindow->edl->tracks->first; track!=0; track=track->next ) {
+ if( track->is_hidden() ) continue;
int64_t track_position = track->to_units(edge_position, 1);
Edit *left_edit = track->edits->editof(track_position, PLAY_FORWARD, 0);
if( left_edit ) {
for(Track *track = mwindow->edl->tracks->first;
track && !result;
track = track->next) {
+ if( track->is_hidden() ) continue;
for(int i = 0; i < track->plugin_set.total && !result; i++) {
PluginSet *plugin_set = track->plugin_set.values[i];
for(Plugin *plugin = (Plugin*)plugin_set->first;
return result;
}
+int TrackCanvas::arrow_mode()
+{
+ return mwindow->edl->session->editing_mode == EDITING_ARROW ? 1 : 0;
+}
+int TrackCanvas::ibeam_mode()
+{
+ return mwindow->edl->session->editing_mode == EDITING_IBEAM ? 1 : 0;
+}
+
int TrackCanvas::do_edits(int cursor_x, int cursor_y, int button_press, int drag_start,
int &redraw, int &rerender, int &new_cursor, int &update_cursor)
{
int result = 0;
for(Track *track = mwindow->edl->tracks->first; track && !result; track = track->next) {
+ if( track->is_hidden() ) continue;
for(Edit *edit = track->edits->first; edit && !result; edit = edit->next) {
int64_t edit_x, edit_y, edit_w, edit_h;
edit_dimensions(edit, edit_x, edit_y, edit_w, edit_h);
// Cursor inside a track
// Cursor inside an edit
- if(cursor_x >= edit_x && cursor_x < edit_x + edit_w &&
- cursor_y >= edit_y && cursor_y < edit_y + edit_h) {
-// Select duration of edit
- if(button_press) {
+ if( cursor_x >= edit_x && cursor_x < edit_x + edit_w &&
+ cursor_y >= edit_y && cursor_y < edit_y + edit_h ) {
+ if( button_press && get_buttonpress() == LEFT_BUTTON ) {
if( get_double_click() ) {
- if( shift_down() ) {
- if( edit->group_id > 0 ) {
- mwindow->edl->tracks->clear_selected_edits();
- mwindow->edl->tracks->del_group(edit->group_id);
- }
- else {
- int id = mwindow->session->group_number++;
- mwindow->edl->tracks->new_group(id);
- }
- mwindow->session->current_operation = NO_OPERATION;
- result = 1;
- }
- else if( !drag_start ) {
- double start = edit->track->from_units(edit->startproject);
- start = mwindow->edl->align_to_frame(start, 0);
- mwindow->edl->local_session->set_selectionstart(start);
- double end = edit->track->from_units(edit->startproject+edit->length);
- end = mwindow->edl->align_to_frame(end, 0);
- mwindow->edl->local_session->set_selectionend(end);
- result = 1;
- }
+ mwindow->edl->tracks->clear_selected_edits();
+ edit->select_affected_edits(1, -1);
+ double start = edit->track->from_units(edit->startproject);
+ start = mwindow->edl->align_to_frame(start, 0);
+ mwindow->edl->local_session->set_selectionstart(start);
+ double end = edit->track->from_units(edit->startproject+edit->length);
+ end = mwindow->edl->align_to_frame(end, 0);
+ mwindow->edl->local_session->set_selectionend(end);
+ result = 1; // Select edit duration or select_region
}
- else if( ctrl_down() && get_buttonpress() == 1 &&
- mwindow->edl->session->editing_mode == EDITING_ARROW ) {
- int v = !edit->is_selected ? 1 : 0;
- if( !edit->group_id )
- edit->is_selected = v;
- else
- mwindow->edl->tracks->set_group_selected(edit->group_id, v);
+ else if( arrow_mode() || (ibeam_mode() && ctrl_down()) ) {
+ mwindow->session->drag_edit = edit;
+ mwindow->session->current_operation = GROUP_TOGGLE;
result = 1;
}
if( result ) {
- redraw = 1;
rerender = 1;
update_cursor = -1;
}
}
- else if( drag_start && track->record ) {
- if( mwindow->edl->session->editing_mode == EDITING_ARROW ) {
-// Need to create drag window
- mwindow->session->drag_edit = edit;
- mwindow->session->drag_origin_x = cursor_x;
- mwindow->session->drag_origin_y = cursor_y;
- // Where the drag started, so we know relative position inside the edit later
- mwindow->session->drag_position =
- mwindow->edl->get_cursor_position(cursor_x, pane->number);
+ else if( drag_start && track->is_armed() ) {
+ mwindow->session->drag_edit = edit;
+ mwindow->session->drag_origin_x = cursor_x;
+ mwindow->session->drag_origin_y = cursor_y;
+// Where the drag started, so we know relative position inside the edit later
+ mwindow->session->drag_position =
+ mwindow->edl->get_cursor_position(cursor_x, pane->number);
+ drag_start = 0; // if unselected "fast" drag
+ if( !edit->silence() && !edit->is_selected ) {
+ mwindow->edl->tracks->clear_selected_edits();
+ if( ibeam_mode() ) {
+ double start = edit->track->from_units(edit->startproject);
+ mwindow->edl->local_session->set_selectionstart(start);
+ mwindow->edl->local_session->set_selectionend(start);
+ edit->set_selected(1);
+ }
+ else
+ edit->select_affected_edits(1, -1);
+ drag_start = 1;
+ }
// Construct list of all affected edits
- if( !shift_down() ) {
+ if( drag_start || ibeam_mode() ) {
+ mwindow->edl->tracks->get_selected_edits(mwindow->session->drag_edits);
+ if( mwindow->session->drag_edits->size() > 0 ) {
mwindow->session->current_operation = DRAG_EDIT;
- mwindow->edl->tracks->clear_selected_edits();
- if( !ctrl_down() ) {
- mwindow->edl->tracks->select_affected_edits(
- edit->track->from_units(edit->startproject),
- edit->track);
- }
- else
- edit->is_selected = 1;
- mwindow->edl->tracks->get_selected_edits(mwindow->session->drag_edits);
+// Need to create drag window
int cx, cy; get_abs_cursor(cx, cy);
gui->drag_popup = new BC_DragWindow(gui,
mwindow->theme->get_image("clip_icon"), cx, cy);
-
+ result = 1;
}
- else if( edit->is_selected ) {
- if( mwindow->session->drag_group )
- mwindow->session->drag_group->remove_user();
- double start_position = 0;
- mwindow->session->drag_group =
- mwindow->selected_edits_to_clip(0, &start_position,
- &mwindow->session->drag_group_first_track);
- if( mwindow->session->drag_group ) {
- mwindow->session->current_operation = DRAG_GROUP;
- mwindow->session->drag_group_position =
- mwindow->session->drag_position - start_position;
- mwindow->session->drag_group_edit = edit;
- mwindow->session->drag_origin_y = edit_y;
- }
+ else {
+ rerender = start_selection(mwindow->session->drag_position);
+ mwindow->session->current_operation = SELECT_REGION;
+ update_cursor = 1;
+ }
+ }
+ else if( edit->is_selected && arrow_mode() ) {
+ if( mwindow->session->drag_group )
+ mwindow->session->drag_group->remove_user();
+ double start_position = 0;
+ mwindow->session->drag_group =
+ mwindow->edl->selected_edits_to_clip(0, &start_position,
+ &mwindow->session->drag_group_first_track);
+ if( mwindow->session->drag_group ) {
+ mwindow->session->current_operation = DRAG_GROUP;
+ mwindow->session->drag_group_position = start_position;
+ mwindow->session->drag_group_edit = edit;
+ mwindow->session->drag_origin_y = edit_y;
+ result = 1;
}
- result = 1;
}
}
}
return result;
}
-
-int TrackCanvas::test_track_group(EDL *group, Track *first_track)
+// returns -1=doesnt fit, 1=fits, 0=fits but overwrites
+int TrackCanvas::test_track_group(EDL *group, Track *first_track, double &pos)
{
+ int intersects = 0;
Track *src = group->tracks->first;
for( Track *track=first_track; track && src; track=track->next ) {
- if( !track->record ) continue;
- if( src->data_type != track->data_type ) return 0;
+ if( !track->is_armed() ) return -1;
+ if( src->data_type != track->data_type ) return -1;
+ for( Edit *src_edit=src->edits->first; src_edit; src_edit=src_edit->next ) {
+ if( src_edit->silence() ) continue;
+ if( !intersects && edit_intersects(track, src_edit, pos) )
+ intersects = 1;
+ }
src = src->next;
}
- return !src ? 1 : 0;
+ return src ? -1 : !intersects ? 1 : 0;
+}
+
+int TrackCanvas::edit_intersects(Track *track, Edit *src_edit, double &pos)
+{
+ if( pos < 0 ) { pos = 0; return 1; }
+ int pane_no = pane->number;
+ int cur_pix = track->edl->get_position_cursorx(pos, pane_no);
+ int64_t src_start = src_edit->startproject;
+ int64_t src_end = src_start + src_edit->length;
+ double new_start = src_edit->track->from_units(src_start) + pos;
+ double new_end = src_edit->track->from_units(src_end) + pos;
+ int64_t trk_start = track->to_units(new_start, 1);
+ int64_t trk_end = track->to_units(new_end, 1);
+ for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
+ if( edit->is_selected || edit->silence() ) continue;
+ int64_t edit_start = edit->startproject;
+ if( edit_start >= trk_end ) continue;
+ int64_t edit_end = edit_start + edit->length;
+ if( trk_start >= edit_end ) continue;
+
+ int64_t lt_dist = labs(trk_end - edit_start);
+ int64_t rt_dist = labs(edit_end - trk_start);
+ int64_t position;
+ if( lt_dist < rt_dist ) {
+ position = edit_start;
+ lt_dist = abs(trk_start - edit_start);
+ rt_dist = abs(trk_end - edit_start);
+ if( lt_dist > rt_dist )
+ position -= src_end;
+ }
+ else {
+ position = edit_end;
+ lt_dist = abs(trk_start - edit_end);
+ rt_dist = abs(trk_end - edit_end);
+ if( lt_dist > rt_dist )
+ position -= src_end;
+ }
+ double new_pos = edit->track->from_units(position);
+ int new_pix = track->edl->get_position_cursorx(new_pos, pane_no);
+ if( abs(new_pix-cur_pix) < HANDLE_W )
+ pos = new_pos;
+ return 1;
+ }
+ return 0;
}
int TrackCanvas::test_resources(int cursor_x, int cursor_y)
if(plugin) {
// Start plugin popup
if(button_press) {
- if(get_buttonpress() == 3) {
+ if(get_buttonpress() == RIGHT_BUTTON ) {
gui->plugin_menu->update(plugin);
gui->plugin_menu->activate_menu();
result = 1;
}
else
// Move plugin
- if(drag_start && plugin->track->record) {
- if(mwindow->edl->session->editing_mode == EDITING_ARROW) {
- if(plugin->track->data_type == TRACK_AUDIO)
+ if( drag_start && plugin->track->is_armed() && !plugin->silence() ) {
+ if( mwindow->edl->session->editing_mode == EDITING_ARROW ) {
+ if( plugin->track->data_type == TRACK_AUDIO )
mwindow->session->current_operation = DRAG_AEFFECT_COPY;
- else if(plugin->track->data_type == TRACK_VIDEO)
+ else if( plugin->track->data_type == TRACK_VIDEO )
mwindow->session->current_operation = DRAG_VEFFECT_COPY;
mwindow->session->drag_plugin = plugin;
for( Track *track = mwindow->edl->tracks->first; track && !result; track = track->next ) {
+ if( track->is_hidden() ) continue;
if( !track->show_transitions() ) continue;
for( Edit *edit = track->edits->first; edit; edit = edit->next ) {
if(!button_press) {
new_cursor = UPRIGHT_ARROW_CURSOR;
}
- else if(get_buttonpress() == 3) {
+ else if(get_buttonpress() == RIGHT_BUTTON ) {
gui->transition_menu->update(transition);
gui->transition_menu->activate_menu();
}
gui->stop_transport("TrackCanvas::button_press_event");
}
- int update_overlay = 0, update_cursor = 0, rerender = 0;
+ int update_overlay = 0, update_cursor = 0, rerender = 0, update_message = 0;
if(get_buttonpress() == WHEEL_UP) {
if(shift_down())
mwindow->move_right(get_w() / 5);
}
else {
- switch(mwindow->edl->session->editing_mode) {
+ if( arrow_mode() ) do {
// Test handles and resource boundaries and highlight a track
- case EDITING_ARROW: {
if( do_transitions(cursor_x, cursor_y,
1, new_cursor, update_cursor) ) break;
if( do_keyframes(cursor_x, cursor_y,
0, get_buttonpress(), new_cursor,
update_cursor, rerender) ) break;
+ update_message = 1;
// Test edit boundaries
if( do_edit_handles(cursor_x, cursor_y,
1, rerender, update_overlay, new_cursor,
if( do_tracks(cursor_x, cursor_y, 1) ) break;
result = 0;
- break; }
-
+ } while(0);
+ else if( ibeam_mode() ) do {
// Test handles only and select a region
- case EDITING_IBEAM: {
double position = mwindow->edl->get_cursor_position(cursor_x, pane->number);
//printf("TrackCanvas::button_press_event %d\n", position);
update_overlay = 1;
break;
}
+ update_message = 1;
// Test edit boundaries
if( do_edit_handles(cursor_x, cursor_y,
1, rerender, update_overlay, new_cursor, update_cursor) ) break;
rerender = start_selection(position);
mwindow->session->current_operation = SELECT_REGION;
update_cursor = 1;
- break; }
- }
+ } while(0);
}
if( rerender ) {
gui->update_patchbay();
}
- if( update_overlay ) {
+ if( update_message )
+ gui->default_message();
+
+ if( update_overlay )
gui->draw_overlays(1);
- }
+
if( update_cursor < 0 ) {
// double_click edit
gui->swindow->update_selection();
}
-void TrackCanvas::show_message(Auto *current, int show_curve_type, const char *fmt, ...)
+void TrackCanvas::show_message(Auto *current, int box_color, const char *fmt, ...)
{
char string[BCTEXTLEN];
char *cp = string, *ep = cp + sizeof(string)-1;
- if( show_curve_type ) {
+ if( box_color >= 0 ) {
cp += snprintf(string, ep-cp, "%-8s ",
FloatAuto::curve_name(((FloatAuto*)current)->curve_mode));
}
va_list ap;
va_start(ap, fmt);
vsnprintf(cp, ep-cp, fmt, ap);
- va_end(ap);
- gui->show_message(string);
+ va_end(ap);
+ gui->show_message(string, -1, box_color);
}
// Patchbay* TrackCanvas::get_patchbay()