X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Ftrackcanvas.C;h=098090a693c4d419f0ebfbf17b26ebd76fef2981;hp=dda88761e8547bfc9633e3573a84d938d8ac1689;hb=13a039ef755e81e65c9479b4b615fd89bfe3e038;hpb=48a6854a1ca58aa291ffc6fe3a48807492dfbef7 diff --git a/cinelerra-5.1/cinelerra/trackcanvas.C b/cinelerra-5.1/cinelerra/trackcanvas.C index dda88761..098090a6 100644 --- a/cinelerra-5.1/cinelerra/trackcanvas.C +++ b/cinelerra-5.1/cinelerra/trackcanvas.C @@ -781,7 +781,7 @@ void TrackCanvas::draw_resources(int mode, if(debug) PRINT_TRACE if(mode != IGNORE_THREAD) - gui->resource_thread->reset(pane->number); + gui->resource_thread->reset(pane->number, indexes_only); // Search every edit for(Track *current = mwindow->edl->tracks->first; @@ -1658,6 +1658,9 @@ void TrackCanvas::draw_highlighting() } break; + case DRAG_SPEED: + draw_speed_highlight(); + break; } if( draw_box ) @@ -1666,6 +1669,33 @@ void TrackCanvas::draw_highlighting() draw_selected_edits(mwindow->edl, 0, 0, GREEN+BLUE, RED); } +void TrackCanvas::draw_speed_highlight() +{ + FloatAuto *drag_speed = (FloatAuto*)mwindow->session->drag_auto; + if( !drag_speed ) return; + draw_speed_track(drag_speed->autos->track); + ArrayList &speed_gang = *mwindow->session->drag_auto_gang; + for( int i=0, sz=speed_gang.size(); iautos->track; + if( track->is_hidden() ) continue; + draw_speed_track(track); + } +} + +void TrackCanvas::draw_speed_track(Track *track) +{ + for( Edit *edit=track->edits->first; edit; edit=edit->next ) { + int64_t x, y, w, h; + edit_dimensions(edit, x, y, w, h); + if( !MWindowGUI::visible(x, x + w, 0, get_w()) ) continue; + if( !MWindowGUI::visible(y, y + h, 0, get_h()) ) continue; + int color = 0xc00cc0; + set_color(color); + set_opaque(); + draw_selected(x, y, w, h); + } +} + // x does not reliably draw a really big rectangle void TrackCanvas::draw_selected(int x, int y, int w, int h) { @@ -1937,7 +1967,8 @@ void TrackCanvas::draw_inout_points() void TrackCanvas::draw_drag_handle() { if( mwindow->session->current_operation != DRAG_EDITHANDLE2 && - mwindow->session->current_operation != DRAG_PLUGINHANDLE2 ) return; + mwindow->session->current_operation != DRAG_PLUGINHANDLE2 && + mwindow->session->current_operation != DRAG_TRANSNHANDLE2 ) return; int64_t pixel1 = Units::round(mwindow->session->drag_position * mwindow->edl->session->sample_rate / mwindow->edl->local_session->zoom_sample - @@ -1981,7 +2012,10 @@ void TrackCanvas::draw_drag_handle() idxbl->get_audio_samples() : edit->track->data_type == TRACK_VIDEO ? idxbl->get_video_frames() : -1; - if( edit->startsource + edit->length >= source_len ) + 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 ) @@ -2017,6 +2051,7 @@ void TrackCanvas::draw_drag_handle() void TrackCanvas::draw_transitions() { int64_t x, y, w, h; + if( !mwindow->edl->session->auto_conf->transitions ) return; for(Track *track = mwindow->edl->tracks->first; track; track = track->next) { if( track->is_hidden() ) continue; @@ -2237,7 +2272,7 @@ int TrackCanvas::do_keyframes(int cursor_x, auto_keyframe, grouptype); if( !result && buttonpress && i == AUTOMATION_SPEED ) - mwindow->speed_after(-1); + mwindow->speed_after(-1, 0); if( result && buttonpress ) { int color = GWindowGUI::auto_colors[i]; mwindow->gui->zoombar->update_autozoom(grouptype, color); @@ -2457,14 +2492,20 @@ void TrackCanvas::draw_cropped_line(int x1, } -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 data_h, int color) +void TrackCanvas::draw_floatauto(FloatAuto *current, + 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 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); @@ -2492,13 +2533,22 @@ void TrackCanvas::draw_floatauto(FloatAuto *current, int x, int 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, data_h, color); - if(out_x != x) - draw_floatauto_ctrlpoint(x, y, out_x, out_y, center_pixel, data_h, 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); } @@ -2639,16 +2689,21 @@ float TrackCanvas::value_to_percentage(float auto_value, int autogrouptype) -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 data_h, - 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; + 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); @@ -2661,6 +2716,9 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x, 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; @@ -2718,13 +2776,14 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x, 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; @@ -2740,12 +2799,13 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x, } // 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)) { @@ -2773,6 +2833,9 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x, 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; @@ -2780,43 +2843,31 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x, static int is_linear(FloatAuto *prev, FloatAuto *next) { - if( !prev || !next ) return 1; + 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 = prev->get_control_in_value(); + float ival = next->get_control_in_value(); float oval = prev->get_control_out_value(); - float cval = prev->get_value(), nval = next->get_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(ig, g) && EQUIV(og, g) ) return 1; + 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); @@ -2834,6 +2885,12 @@ void TrackCanvas::draw_floatline(int 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; } @@ -2927,41 +2984,43 @@ int TrackCanvas::test_floatline(int center_pixel, 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->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->armed_gang(skip) && current->is_armed() && - current != skip ) { + if( current == skip || !current->is_armed() ) continue; + if( !gang && current->data_type != skip->data_type ) continue; + if( skip->armed_gang(current) || get_double_click() ) { 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 if( all >= 0 ) { + else if( gang >= 0 ) { // 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); } - if( !keyframe ) continue; + else + continue; mwindow->session->drag_auto_gang->append((Auto *)keyframe); } } @@ -2974,11 +3033,9 @@ void TrackCanvas::update_ganged_autos(float change, Track *skip, FloatAuto *faut 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()); } } @@ -3130,7 +3187,7 @@ float TrackCanvas::percentage_to_value(float percentage, } -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) @@ -3142,7 +3199,7 @@ void TrackCanvas::calculate_auto_position(double *x, double *y, 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; @@ -3150,7 +3207,7 @@ void TrackCanvas::calculate_auto_position(double *x, double *y, } 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; } @@ -3160,7 +3217,7 @@ void TrackCanvas::calculate_auto_position(double *x, double *y, } 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; } } @@ -3175,7 +3232,6 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu 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; @@ -3198,7 +3254,7 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu 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 ) @@ -3213,7 +3269,7 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu 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 { @@ -3238,18 +3294,16 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu // Draw or test handle if( current && !result && current != autos->default_auto ) { if( !draw && track->is_armed() ) { - result = test_floatauto((FloatAuto*)current, (int)ax2, (int)ay2, - (int)in_x2, (int)in_y2, (int)out_x2, (int)out_y2, + 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); } } @@ -3269,9 +3323,10 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu 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 ); @@ -3684,7 +3739,7 @@ int TrackCanvas::draw_hairline(Auto *auto_keyframe, int color, int show) 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); @@ -3793,14 +3848,8 @@ void TrackCanvas::update_drag_handle() double new_position; int cursor_x = get_cursor_x(); - new_position = - (double)(cursor_x + - mwindow->edl->local_session->view_start[pane->number]) * - mwindow->edl->local_session->zoom_sample / - mwindow->edl->session->sample_rate; - - new_position = - mwindow->edl->align_to_frame(new_position, 0); + new_position = mwindow->edl->get_cursor_position(cursor_x, pane->number); + new_position = mwindow->edl->align_to_frame(new_position, 0); if( ctrl_down() && alt_down() ) { #define snapper(v) do { \ @@ -3902,7 +3951,7 @@ int TrackCanvas::render_handle_frame(EDL *edl, int64_t pos, int mode) !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; float ox1, oy1, ox2, oy2, cx1, cy1, cx2, cy2; @@ -4023,7 +4072,8 @@ int TrackCanvas::update_drag_floatauto(int cursor_x, int cursor_y) // 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; } @@ -4033,28 +4083,27 @@ int TrackCanvas::update_drag_floatauto(int cursor_x, int cursor_y) // Snap to nearby values old_value = current->get_value(); if(shift_down()) { - double value1, value2, distance1=-1, distance2=-1; - + 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(); } @@ -4268,42 +4317,46 @@ int TrackCanvas::cursor_update(int in_motion) { case DRAG_EDITHANDLE1: // Outside threshold. Upgrade status - if(active) - { - if(labs(get_cursor_x() - mwindow->session->drag_origin_x) > HANDLE_W) - { - mwindow->session->current_operation = DRAG_EDITHANDLE2; - update_overlay = 1; - } + if( !active ) break; + if( labs(get_cursor_x() - mwindow->session->drag_origin_x) > HANDLE_W ) { + mwindow->session->current_operation = DRAG_EDITHANDLE2; + update_overlay = 1; } break; - case DRAG_EDITHANDLE2: - if(active) - { - update_drag_handle(); - update_overlay = 1; - } + if( !active ) break; + update_drag_handle(); + update_overlay = 1; break; case DRAG_PLUGINHANDLE1: - if(active) - { - if(labs(get_cursor_x() - mwindow->session->drag_origin_x) > HANDLE_W) - { - mwindow->session->current_operation = DRAG_PLUGINHANDLE2; - update_overlay = 1; - } + if( !active ) break; + if( labs(get_cursor_x() - mwindow->session->drag_origin_x) > HANDLE_W ) { + mwindow->session->current_operation = DRAG_PLUGINHANDLE2; + update_overlay = 1; } break; - case DRAG_PLUGINHANDLE2: - if(active) - { - update_drag_handle(); + if( !active ) break; + update_drag_handle(); + update_overlay = 1; + break; + + case DRAG_TRANSNHANDLE1: + if( !active ) break; + if( labs(get_cursor_x() - mwindow->session->drag_origin_x) > HANDLE_W ) { + mwindow->session->current_operation = DRAG_TRANSNHANDLE2; update_overlay = 1; } break; + case DRAG_TRANSNHANDLE2: { + if( !active ) break; + position = mwindow->edl->get_cursor_position(get_cursor_x(), pane->number); + position = mwindow->edl->align_to_frame(position, 1); + drag_transition_handle(position); + rerender = 1; + update_overlay = 1; + break; } // Rubber band curves case DRAG_FADE: @@ -4319,7 +4372,7 @@ int TrackCanvas::cursor_update(int in_motion) if(active) rerender = update_overlay = update_drag_floatauto(get_cursor_x(), get_cursor_y()); if( rerender && mwindow->session->current_operation == DRAG_SPEED ) - mwindow->speed_after(!in_motion ? 1 : 0); + mwindow->speed_after(!in_motion ? 1 : 0, 0); break; case DRAG_PLAY: @@ -4426,6 +4479,8 @@ int TrackCanvas::cursor_update(int in_motion) 0, new_cursor, update_cursor)) break; if(do_keyframes(get_cursor_x(), get_cursor_y(), 0, 0, new_cursor, update_cursor, rerender)) break; + if(do_transition_handles(get_cursor_x(), get_cursor_y(), + 0, rerender, update_overlay, new_cursor, update_cursor)) break; if(do_edit_handles(get_cursor_x(), get_cursor_y(), 0, rerender, update_overlay, new_cursor, update_cursor)) break; // Plugin boundaries @@ -4625,9 +4680,23 @@ int TrackCanvas::button_release_event() result = 1; break; + case DRAG_TRANSNHANDLE2: + mwindow->session->current_operation = NO_OPERATION; + drag_scroll = 0; + result = 1; + + end_transnhandle_selection(); + break; + + case DRAG_TRANSNHANDLE1: + mwindow->session->current_operation = NO_OPERATION; + drag_scroll = 0; + result = 1; + break; + case DRAG_SPEED: redraw = FORCE_REDRAW; - load_flags |= LOAD_EDITS; + load_flags |= LOAD_EDITS | LOAD_TIMEBAR; case DRAG_FADE: // delete the drag_auto_gang first and remove out of order keys clear_ganged_autos(); @@ -4947,6 +5016,95 @@ int TrackCanvas::do_plugin_handles(int cursor_x, return result; } +int TrackCanvas::do_transition_handles(int cursor_x, int cursor_y, int button_press, + int &rerender, int &update_overlay, int &new_cursor, int &update_cursor) +{ + Transition *trans_result = 0; + int result = 0; + + Track *track = mwindow->edl->tracks->first; + for( ; track && !result; track=track->next) { + if( track->is_hidden() ) continue; + Edit *edit = track->edits->first; + for( ; edit && !result; edit=edit->next ) { + Transition *trans = edit->transition; + if( !trans ) continue; + int64_t x, y, w, h; + edit_dimensions(edit, x, y, w, h); + int strip_x = x, edit_y = y; + get_transition_coords(edit, x, y, w, h); + VFrame *strip = mwindow->theme->get_image("plugin_bg_data"); + int strip_y = y - strip->get_h(); + if( track->show_assets() && track->show_titles() ) + edit_y += mwindow->theme->get_image("title_bg_data")->get_h(); + if( strip_y < edit_y ) strip_y = edit_y; + int strip_w = Units::round(edit->track->from_units(edit->transition->length) * + mwindow->edl->session->sample_rate / mwindow->edl->local_session->zoom_sample); + int x1 = strip_x + strip_w - HANDLE_W/2, x2 = x1 + HANDLE_W; + int y1 = strip_y + strip->get_h()/2 - HANDLE_H/2, y2 = y1 + HANDLE_W; + if( cursor_x >= x1 && cursor_x < x2 && + cursor_y >= y1 && cursor_y < y2 ) { + trans_result = trans; + result = 1; + } + } + } + + if( result ) { + if( button_press ) { + mwindow->session->drag_transition = trans_result; + mwindow->session->drag_handle = 1; + mwindow->session->drag_button = get_buttonpress() - 1; + int64_t trans_end = trans_result->edit->startproject + trans_result->length; + double position = trans_result->edit->track->from_units(trans_end); + mwindow->session->drag_position = position; + mwindow->session->drag_start = position; + mwindow->session->current_operation = DRAG_TRANSNHANDLE1; + mwindow->session->drag_origin_x = get_cursor_x(); + mwindow->session->drag_origin_y = get_cursor_y(); + update_cursor = 1; + } + new_cursor = RIGHT_CURSOR; + update_overlay = 1; + } + + return result; +} + +int TrackCanvas::drag_transition_handle(double position) +{ + Transition *transition = mwindow->session->drag_transition; + if( !transition ) return 1; + mwindow->session->drag_position = position; + mwindow->edl->local_session->set_selectionstart(position); + mwindow->edl->local_session->set_selectionend(position); + char string[BCSTRLEN]; + int64_t length = transition->length; + Track *track = transition->edit->track; + int64_t start_pos = track->to_units(mwindow->session->drag_start, 0); + int64_t end_pos = track->to_units(mwindow->session->drag_position, 0); + length += end_pos - start_pos; + if( length < 0 ) length = 0; + double time = track->from_units(length); + Units::totext(string, time, + mwindow->edl->session->time_format, + mwindow->edl->session->sample_rate, + mwindow->edl->session->frame_rate, + mwindow->edl->session->frames_per_foot); + mwindow->gui->show_message(string); + if( mwindow->gui->transition_menu->length_thread->running() ) { + TransitionLengthDialog *dialog = (TransitionLengthDialog *) + mwindow->gui->transition_menu->length_thread->get_gui(); + if( dialog ) { + dialog->lock_window("TrackCanvas::drag_transition_handle"); + dialog->update_text(time); + dialog->thread->new_length = time; + dialog->unlock_window(); + } + } + return 0; +} + int TrackCanvas::do_tracks(int cursor_x, int cursor_y, int button_press) { @@ -5368,6 +5526,10 @@ int TrackCanvas::button_press_event() 0, get_buttonpress(), new_cursor, update_cursor, rerender) ) break; update_message = 1; + + if( do_transition_handles(cursor_x, cursor_y, + 1, rerender, update_overlay, new_cursor, + update_cursor) ) break; // Test edit boundaries if( do_edit_handles(cursor_x, cursor_y, 1, rerender, update_overlay, new_cursor, @@ -5404,6 +5566,8 @@ int TrackCanvas::button_press_event() break; } update_message = 1; + if( do_transition_handles(cursor_x, cursor_y, + 1, rerender, update_overlay, new_cursor, update_cursor) ) break; // Test edit boundaries if( do_edit_handles(cursor_x, cursor_y, 1, rerender, update_overlay, new_cursor, update_cursor) ) break; @@ -5500,11 +5664,19 @@ int TrackCanvas::start_selection(double position) void TrackCanvas::end_edithandle_selection() { mwindow->modify_edithandles(); + mwindow->session->drag_edit = 0; } void TrackCanvas::end_pluginhandle_selection() { mwindow->modify_pluginhandles(); + mwindow->session->drag_plugin = 0; +} + +void TrackCanvas::end_transnhandle_selection() +{ + mwindow->modify_transnhandles(); + mwindow->session->drag_transition = 0; }