X-Git-Url: http://git.cinelerra-gg.org/git/?p=goodguy%2Fhistory.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Ftrackcanvas.C;h=2edb89bea19dd64f2d3f42e918e36059739b3975;hp=5d5b64fe1908dfd8c28208459c82bb06745ff91d;hb=7e5a0760f40ff787cc3d93cb7768a901ebe52809;hpb=6fd57106820e676e368399d16b925bdc78d34621

diff --git a/cinelerra-5.1/cinelerra/trackcanvas.C b/cinelerra-5.1/cinelerra/trackcanvas.C
index 5d5b64fe..2edb89be 100644
--- a/cinelerra-5.1/cinelerra/trackcanvas.C
+++ b/cinelerra-5.1/cinelerra/trackcanvas.C
@@ -26,7 +26,7 @@
 #include "bcsignals.h"
 #include "bctimer.h"
 #include "clip.h"
-#include "colors.h"
+#include "bccolors.h"
 #include "cplayback.h"
 #include "cursors.h"
 #include "cwindowgui.h"
@@ -38,6 +38,7 @@
 #include "edlsession.h"
 #include "floatauto.h"
 #include "floatautos.h"
+#include "gwindowgui.h"
 #include "indexstate.h"
 #include "intauto.h"
 #include "intautos.h"
@@ -45,6 +46,7 @@
 #include "keyframepopup.h"
 #include "keyframes.h"
 #include "keys.h"
+#include "labels.h"
 #include "localsession.h"
 #include "mainclock.h"
 #include "maincursor.h"
@@ -108,6 +110,7 @@ TrackCanvas::TrackCanvas(MWindow *mwindow,
 	render_timer = new Timer;
 	hourglass_enabled = 0;
 	timebar_position = -1;
+	snapped = 0;
 }
 
 TrackCanvas::~TrackCanvas()
@@ -185,7 +188,7 @@ int TrackCanvas::drag_motion(Track **over_track,
 	int cursor_y = get_relative_cursor_y();
 
 	if( get_cursor_over_window() &&
-		cursor_x >= 0 && cursor_y >= 0 && 
+		cursor_x >= 0 && cursor_y >= 0 &&
 		cursor_x < get_w() && cursor_y < get_h() )
 	{
 //printf("TrackCanvas::drag_motion %d %d\n", __LINE__, pane->number);
@@ -216,7 +219,7 @@ int TrackCanvas::drag_motion(Track **over_track,
 						//  will be deleted by Edits::optimize if not used
 						double length = mwindow->edl->session->default_transition_length;
 						int64_t start = edit->startproject+edit->length;
-						int64_t units = track->to_units(length, 1); 
+						int64_t units = track->to_units(length, 1);
 						track->edits->create_silence(start, start+units);
 						continue;
 					}
@@ -328,16 +331,28 @@ int TrackCanvas::drag_stop(int *redraw)
 				if( hi_plugin_set && hi_plugin_set->track == drag_plugin->track ) {
 //printf("TrackCanvas::drag_stop 6\n");
 					drop_position = drop_plugin_position(hi_plugin_set, drag_plugin);
-					if( drop_position >= 0 )
-						mwindow->move_effect(drag_plugin, hi_plugin_set, drop_position);
+					if( drop_position < 0 ) {
+						result = 1;
+						break;		// Do not do anything
+					}
+
+					Track *track = mwindow->session->track_highlighted;
+					drop_position = track->frame_align(drop_position, 0);
+					mwindow->move_effect(drag_plugin, hi_plugin_set, drop_position);
 					result = 1;
 				}
 				else if( hi_track ) {
 // Put it in a new plugin set determined by an edit boundary, or at the start of the track
 					Edit *hi_edit = mwindow->session->edit_highlighted;
 					drop_position = hi_edit ? hi_edit->startproject : 0;
-					if( drop_position >= 0 )
-						mwindow->move_effect(drag_plugin, hi_track, drop_position);
+					if( drop_position < 0 ) {
+						result = 1;
+						break;		// Do not do anything
+					}
+
+					Track *track = mwindow->session->track_highlighted;
+					drop_position = track->frame_align(drop_position, 0);
+					mwindow->move_effect(drag_plugin, hi_track, drop_position);
 					result = 1;
 				}
 			}
@@ -379,7 +394,7 @@ int TrackCanvas::drag_stop(int *redraw)
  					length = mwindow->session->track_highlighted->from_units(
  						mwindow->session->edit_highlighted->length);
  				}
-
+				start = mwindow->edl->align_to_frame(start, 0);
 				mwindow->insert_effects_canvas(start, length);
 				*redraw = 1;
 			}
@@ -391,8 +406,7 @@ int TrackCanvas::drag_stop(int *redraw)
 			if(mwindow->session->track_highlighted) {
 				double asset_duration = 0;
 				int64_t asset_length_units = 0;
-				int64_t position = 0;
-					
+
 				if(mwindow->session->current_operation == DRAG_ASSET &&
 					mwindow->session->drag_assets->total) {
 					Indexable *indexable = mwindow->session->drag_assets->values[0];
@@ -404,8 +418,8 @@ int TrackCanvas::drag_stop(int *redraw)
 						if (video_length < 0) {
 							if(mwindow->edl->session->si_useduration)
 								video_length = mwindow->edl->session->si_duration;
-							else	
-								video_length = 1.0 / mwindow->edl->session->frame_rate ; 
+							else
+								video_length = 1.0 / mwindow->edl->session->frame_rate ;
 						}
 						asset_duration = video_length / indexable->get_frame_rate();
 					}
@@ -427,25 +441,26 @@ int TrackCanvas::drag_stop(int *redraw)
 				else {
 					printf("DRAG_ASSET error: Asset dropped, but both drag_clips and drag_assets total is zero\n");
 				}
-			
+
 				asset_length_units = mwindow->session->track_highlighted->to_units(asset_duration, 1);
-				position = drop_edit_position (&insertion, NULL, asset_length_units);
-				if( position == -1 ) {
+				int64_t drop_position = drop_edit_position (&insertion, NULL, asset_length_units);
+				if( drop_position < 0 ) {
 					result = 1;
 					break;		// Do not do anything
 				}
-				
-				double position_f = mwindow->session->track_highlighted->from_units(position);
+
 				Track *track = mwindow->session->track_highlighted;
+				double track_position = track->from_units(drop_position);
+				track_position = mwindow->edl->align_to_frame(track_position, 0);
 
 //				if (!insertion) {
 //					// FIXME, we should create an mwindow/EDL method that overwrites, without clearing the keyframes and autos
 //					// Unfortunately, this is _a lot_ of work to do right
 //					printf("Problematic insertion\n");
-//					mwindow->edl->tracks->clear(position_f, 
-//						position_f + asset_duration, 0);
+//					mwindow->edl->tracks->clear(track_position,
+//						track_position + asset_duration, 0);
 //				}
-				mwindow->paste_assets(position_f, track, !insertion);
+				mwindow->paste_assets(track_position, track, !insertion);
 				result = 1;    // need to be one no matter what, since we have track highlited so we have to cleanup....
 			}
 			break;
@@ -455,19 +470,18 @@ int TrackCanvas::drag_stop(int *redraw)
 			if(mwindow->session->track_highlighted) {
 				if( mwindow->session->track_highlighted->data_type ==
 					mwindow->session->drag_edit->track->data_type) {
-					int64_t position = 0;
-					position = drop_edit_position(&insertion,
+					int64_t drop_position = drop_edit_position(&insertion,
 							mwindow->session->drag_edit,
 							mwindow->session->drag_edit->length);
-					if (position == -1) {
+					if( drop_position < 0 ) {
 						result = 1;
 						break;		// Do not do anything
 					}
-					
-					double position_f = mwindow->session->track_highlighted->from_units(position);
 					Track *track = 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, position_f, !insertion);
+							track, track_position, !insertion);
 				}
 
 				result = 1;
@@ -508,68 +522,67 @@ int64_t TrackCanvas::drop_edit_position(int *is_insertion, Edit *moved_edit, int
 	Track *track = mwindow->session->track_highlighted;
 	int cursor_x = get_relative_cursor_x();
 	double zoom_scale = (double)mwindow->edl->session->sample_rate / mwindow->edl->local_session->zoom_sample;
-	double drop_time = (cursor_x + mwindow->edl->local_session->view_start[pane->number]) / zoom_scale;
-	// we use cursor position for affinity calculations
-	int64_t cursor_position = track->to_units(drop_time, 0);
-	if( cursor_position <= 0 ) {
+	double cur_pos = (cursor_x + mwindow->edl->local_session->view_start[pane->number]) / zoom_scale;
+	double position = mwindow->edl->align_to_frame(cur_pos, 1);
+	if( position <= 0 ) {
 		*is_insertion = 1;
 		return 0;
 	}
-	if( moved_edit )  // relative cursor position depends upon drop point
- 		drop_time -= mwindow->session->drag_position - moved_edit->track->from_units(moved_edit->startproject);
-	int64_t drop_position = track->to_units(drop_time, 1);
+	double cursor_position = position;
+	int64_t drop_position = track->to_units(cursor_position, 1);
+	if( moved_edit ) { // relative cursor position depends upon drop point
+		double moved_edit_start = moved_edit->track->from_units(moved_edit->startproject);
+		position -= mwindow->session->drag_position - moved_edit_start;
+	}
+	int64_t edit_position = track->to_units(position, 1);
+	int64_t grab_position = edit_position;
 	if( !moved_edit )  // for clips and assets acts as they were grabbed in the middle
-		drop_position -= moved_edit_length / 2;
+		grab_position -= moved_edit_length / 2;
 	Edit *last_edit = track->edits->last;
-	if( !last_edit || drop_position > last_edit->startproject+last_edit->length ) {
+	if( !last_edit || edit_position >= (last_edit->startproject+last_edit->length) ) {
 		*is_insertion = 0;
-		return drop_position;
+		return grab_position;
 	}
 
-	int64_t drop_x0 = 0, drop_x1 = 0;  // drop zone boundries
-	for( Edit *edit = track->edits->first; edit; ) {
-		int64_t edit_x0 = edit->startproject, edit_x1 = edit_x0 + edit->length;
-		if( Units::round(labs(edit_x0-cursor_position)*zoom_scale) < HANDLE_W ) {
+	int64_t drop_start = 0, drop_end = 0;  // drop zone boundries
+	Edit *next_edit = track->edits->first;
+	while( next_edit ) {
+		Edit *edit = next_edit;  next_edit = (Edit *)edit->next;
+		int64_t edit_start = edit->startproject;
+		int64_t edit_end = edit_start + edit->length;
+		double edit_start_pos = edit->track->from_units(edit_start);
+		if( (fabs(edit_start_pos-cursor_position)*zoom_scale) < HANDLE_W ) {
 			*is_insertion = 1; // cursor is close to the beginning of an edit -> insertion
-			return edit->startproject;
+			return edit_start;
 		}
-		if( Units::round(labs(edit_x1-cursor_position)*zoom_scale) < HANDLE_W ) {
+		double edit_end_pos = edit->track->from_units(edit_end);
+		if( (fabs(edit_end_pos-cursor_position)*zoom_scale) < HANDLE_W ) {
 			*is_insertion = 1; // cursor is close to the end of an edit -> insertion
-			return edit->startproject + edit->length;
+			return edit_end;
 		}
 		if( edit != moved_edit && !edit->silence() )
-			drop_x0 = edit_x1; // reset drop zone
-		if( (edit=edit->next) != 0 ) {
-			if( edit == moved_edit || edit->silence() ) continue;
-			drop_x1 = edit_x1;
+			drop_start = edit_end; // reset drop zone
+		if( next_edit ) {
+			if( next_edit == moved_edit || next_edit->silence() ) continue;
+			drop_end = edit_end;
 		}
 		else
-			drop_x1 = INT64_MAX;
-//printf("drop cursor=%jd, x0=%jd, x1=%jd\n", cursor_position, drop_x0, drop_x1);
-		if( drop_position >= drop_x0 && drop_position+moved_edit_length < drop_x1 ) {
+			drop_end = INT64_MAX;
+		if( edit_position >= drop_start &&
+		    edit_position+moved_edit_length < drop_end ) {
 			*is_insertion = 0; // fits in the zone
-//printf("into %jd\n", drop_position);
-			return drop_position;
+			return edit_position;
 		}
-		if( cursor_position < drop_x1 ) { // drop in the zone
-			if( (drop_x1-drop_x0) >= moved_edit_length ) {
+		if( drop_position < drop_end ) { // drop in the zone
+			if( (drop_end - drop_start) >= moved_edit_length ) {
 				*is_insertion = 0; // fits in the zone, but over the edge
-				int64_t dx0 = llabs(cursor_position-drop_x0);
-				int64_t dx1 = llabs(cursor_position-drop_x1);
-//printf("onto %jd\n", dx0 < dx1 ? drop_x0 : drop_x1 - moved_edit_length);
-				return dx0 < dx1 ? drop_x0 : drop_x1 - moved_edit_length;
-			}
-			int edit_center = (edit_x0+edit_x1) / 2;
-			if( cursor_position < edit_center ) {
-				*is_insertion = 1;
-//printf("snap left %jd\n", drop_x0);
-				return drop_x0;	// snap left
-			}
-			else {
-				*is_insertion = 1;
-//printf("snap right %jd\n", drop_x1);
-				return drop_x1;	// snap right
+				int64_t dx0 = llabs(drop_position - drop_start);
+				int64_t dx1 = llabs(drop_position - drop_end);
+				return dx0 < dx1 ? drop_start : drop_end - moved_edit_length;
 			}
+			*is_insertion = 1;
+			int64_t edit_center = (edit_start + edit_end) / 2;
+			return position < edit_center ? drop_start : drop_end;
 		}
 	}
 
@@ -581,39 +594,47 @@ int64_t TrackCanvas::drop_plugin_position(PluginSet *plugin_set, Plugin *moved_p
 {
 	// get the canvas/track position
 	Track *track = plugin_set->track;
+	double moved_plugin_length = moved_plugin->track->from_units(moved_plugin->length);
+	int64_t track_plugin_length = track->to_units(moved_plugin_length, 0);
 	int cursor_x = get_relative_cursor_x();
 	double zoom_scale = (double)mwindow->edl->session->sample_rate / mwindow->edl->local_session->zoom_sample;
-	double drop_time = (cursor_x + mwindow->edl->local_session->view_start[pane->number]) / zoom_scale;
-	// we use cursor position for affinity calculations
-	int64_t cursor_position = track->to_units(drop_time, 0);
-	if( cursor_position <= 0 ) return 0;
-	drop_time -= mwindow->session->drag_position - moved_plugin->track->from_units(moved_plugin->startproject);
-	int64_t drop_position = track->to_units(drop_time, 1);
+	double cur_pos = (cursor_x + mwindow->edl->local_session->view_start[pane->number]) / zoom_scale;
+	double position = mwindow->edl->align_to_frame(cur_pos, 1);
+	if( position <= 0 ) return 0;
+	int64_t drop_position = track->to_units(position, 1);
 	Plugin *last_plugin = (Plugin *)plugin_set->last;
-	if( !last_plugin || drop_position > last_plugin->startproject+last_plugin->length ) {
-		return drop_position;
-	}
-
-	int64_t drop_x0 = 0, drop_x1 = 0;  // drop zone boundries
-	for( Plugin *plugin = (Plugin *)plugin_set->first; plugin; ) {
-		int64_t plugin_x0 = plugin->startproject, plugin_x1 = plugin_x0 + plugin->length;
+	if( !last_plugin ) return drop_position;
+	double plugin_set_end = last_plugin->track->from_units(last_plugin->startproject+last_plugin->length);
+	if( position >= plugin_set_end ) return drop_position;
+	double moved_plugin_start = moved_plugin->track->from_units(moved_plugin->startproject);
+	position -= mwindow->session->drag_position - moved_plugin_start;
+	int64_t plugin_position = track->to_units(position, 1);
+
+	int64_t drop_start = 0, drop_end = 0;  // drop zone boundries
+	Plugin *next_plugin = (Plugin *)plugin_set->first;
+	while( next_plugin ) {
+		Plugin *plugin = next_plugin;  next_plugin = (Plugin *)plugin->next;
+		int64_t plugin_start = plugin->startproject;
+		int64_t plugin_end = plugin_start + plugin->length;
+		double plugin_end_pos = plugin->track->from_units(plugin_end);
+		int64_t track_plugin_end = track->to_units(plugin_end_pos, 0);
 		if( plugin != moved_plugin && !plugin->silence() )
-			drop_x0 = plugin_x1;
-		if( (plugin=(Plugin *)plugin->next) != 0 ) {
-			if( plugin == moved_plugin || plugin->silence() ) continue;
-			drop_x1 = plugin_x1;
+			drop_start = track_plugin_end;
+		if( next_plugin ) {
+			if( next_plugin == moved_plugin || next_plugin->silence() ) continue;
+			drop_end = track_plugin_end;
 		}
 		else
-			drop_x1 = INT64_MAX;
-		if( drop_position >= drop_x0 && // fits in the zone
-		    drop_position+moved_plugin->length < drop_x1 ) {
-			return drop_position;
+			drop_end = INT64_MAX;
+		if( plugin_position >= drop_start && // fits in the zone
+		    plugin_position+track_plugin_length < drop_end ) {
+			return plugin_position;
 		}
-		if( cursor_position < drop_x1 ) { // drop in the zone
-			if( (drop_x1-drop_x0) >= moved_plugin->length ) {
-				int64_t dx0 = llabs(cursor_position-drop_x0);
-				int64_t dx1 = llabs(cursor_position-drop_x1);
-				return dx0 < dx1 ? drop_x0 : drop_x1 - moved_plugin->length;
+		if( drop_position < drop_end ) { // drop in the zone
+			if( (drop_end - drop_start) >= track_plugin_length ) {
+				int64_t dx0 = llabs(drop_position - drop_start);
+				int64_t dx1 = llabs(drop_position - drop_end);
+				return dx0 < dx1 ? drop_start : drop_end - track_plugin_length;
 			}
 		}
 	}
@@ -621,19 +642,18 @@ int64_t TrackCanvas::drop_plugin_position(PluginSet *plugin_set, Plugin *moved_p
 	return -1;
 }
 
-
 void TrackCanvas::draw(int mode, int hide_cursor)
 {
 	const int debug = 0;
 
 
 // Swap pixmap layers
- 	if(get_w() != background_pixmap->get_w() ||
- 		get_h() != background_pixmap->get_h())
- 	{
- 		delete background_pixmap;
- 		background_pixmap = new BC_Pixmap(this, get_w(), get_h());
- 	}
+	if(get_w() != background_pixmap->get_w() ||
+		get_h() != background_pixmap->get_h())
+	{
+		delete background_pixmap;
+		background_pixmap = new BC_Pixmap(this, get_w(), get_h());
+	}
 
 // Cursor disappears after resize when this is called.
 // Cursor doesn't redraw after editing when this isn't called.
@@ -671,17 +691,11 @@ void TrackCanvas::test_timer()
 
 void TrackCanvas::draw_indexes(Indexable *indexable)
 {
+	IndexState *index_state = indexable->index_state;
 // Don't redraw raw samples
-	IndexState *index_state = 0;
-	index_state = indexable->index_state;
-
-
 	if(index_state->index_zoom > mwindow->edl->local_session->zoom_sample)
 		return;
-
-
 	draw_resources(0, 1, indexable);
-
 	draw_overlays();
 	flash(0);
 }
@@ -1022,7 +1036,7 @@ void TrackCanvas::draw_paste_destination()
 
 		int has_audio = 0, has_video = 0;
 		double paste_audio_length = 0, paste_video_length = 0;
-                double paste_audio_position = -1, paste_video_position = -1;
+		double paste_audio_position = -1, paste_video_position = -1;
 
 		if( indexable ) {
 			has_audio = indexable->have_audio();
@@ -1097,9 +1111,9 @@ void TrackCanvas::draw_paste_destination()
 				}
 
 // Get the x coordinate
-				x = Units::to_int64(position * 
+				x = Units::to_int64(position *
 					mwindow->edl->session->sample_rate /
-					mwindow->edl->local_session->zoom_sample) - 
+					mwindow->edl->local_session->zoom_sample) -
 					mwindow->edl->local_session->view_start[pane->number];
 
 				double paste_position = -1.;
@@ -1133,6 +1147,7 @@ void TrackCanvas::draw_paste_destination()
 								from_units(drop_edit_position(&insertion,
 									mwindow->session->drag_edit,
 									mwindow->session->drag_edit->length));
+							current_aedit++;
 						}
 					}
 					if( paste_position >= 0 ) {
@@ -1175,6 +1190,7 @@ void TrackCanvas::draw_paste_destination()
 								from_units(drop_edit_position(&insertion,
 									mwindow->session->drag_edit,
 									mwindow->session->drag_edit->length));
+							current_vedit++;
 						}
 					}
 					if( paste_position >= 0 ) {
@@ -1196,10 +1212,6 @@ void TrackCanvas::draw_paste_destination()
 					int h = dest->vertical_span(mwindow->theme);
 
 //printf("TrackCanvas::draw_paste_destination 2 %d %d %d %d\n", x, y, w, h);
-					if (insertion)
-						draw_highlight_insertion(x, y, w, h);
-					else
-						draw_highlight_rectangle(x, y, w, h);
 					if(x < -BC_INFINITY) {
 						w -= -BC_INFINITY - x;
 						x += -BC_INFINITY - x;
@@ -1208,7 +1220,10 @@ void TrackCanvas::draw_paste_destination()
 // if(pane->number == TOP_RIGHT_PANE)
 // printf("TrackCanvas::draw_paste_destination %d %d %d %d %d\n",
 // __LINE__, x, y, w, h);
-					draw_highlight_rectangle(x, y, w, h);
+					if (insertion)
+						draw_highlight_insertion(x, y, w, h);
+					else
+						draw_highlight_rectangle(x, y, w, h);
 				}
 			}
 		}
@@ -1276,7 +1291,7 @@ void TrackCanvas::draw_highlight_rectangle(int x, int y, int w, int h)
 	h = MIN(h, get_h() + 20);
 	if(w > 0 && h > 0)
 	{
-		set_color(WHITE);
+		set_color(mwindow->preferences->highlight_inverse);
 		set_inverse();
 		//draw_rectangle(x, y, w, h);
 		draw_rectangle(x + 1, y + 1, w - 2, h - 2);
@@ -1338,7 +1353,7 @@ void TrackCanvas::draw_highlight_insertion(int x, int y, int w, int h)
 	}
 	w = MIN(w, get_w() + 20);
 	h = MIN(h, get_h() + 20);
-	set_color(WHITE);
+	set_color(mwindow->preferences->highlight_inverse);
 	set_inverse();
 	draw_rectangle(x, y, w, h);
 	draw_rectangle(x + 1, y + 1, w - 2, h - 2);
@@ -1593,7 +1608,7 @@ void TrackCanvas::draw_plugins()
 	char string[BCTEXTLEN];
 	int current_on = 0;
 	int current_show = 0;
-
+	int current_preset = 0;
 
 //	if(!mwindow->edl->session->show_assets) goto done;
 
@@ -1601,6 +1616,8 @@ void TrackCanvas::draw_plugins()
 		plugin_on_toggles.values[i]->in_use = 0;
 	for(int i = 0; i < plugin_show_toggles.total; i++)
 		plugin_show_toggles.values[i]->in_use = 0;
+	for(int i = 0; i < preset_edit_buttons.total; i++)
+		plugin_show_toggles.values[i]->in_use = 0;
 
 
 	for(Track *track = mwindow->edl->tracks->first;
@@ -1708,9 +1725,21 @@ void TrackCanvas::draw_plugins()
 								}
 								current_show++;
 							}
-
-
-
+							toggle_x -= PluginPresetEdit::calculate_w(mwindow) + 10;
+							if(toggle_x > min_x)
+							{
+								if(current_preset >= preset_edit_buttons.total)
+								{
+									PluginPresetEdit *preset_edit = new PluginPresetEdit(mwindow, toggle_x, toggle_y, plugin);
+									add_subwindow(preset_edit);
+									preset_edit_buttons.append(preset_edit);
+								}
+								else
+								{
+									preset_edit_buttons.values[current_preset]->update(toggle_x, toggle_y, plugin);
+								}
+								current_preset++;
+							}
 						}
 					}
 				}
@@ -1720,6 +1749,10 @@ void TrackCanvas::draw_plugins()
 
 // Remove unused toggles
 
+	while(current_preset < preset_edit_buttons.total)
+	{
+		preset_edit_buttons.remove_object_number(current_preset);
+	}
 	while(current_show < plugin_show_toggles.total)
 	{
 		plugin_show_toggles.remove_object_number(current_show);
@@ -1729,7 +1762,6 @@ void TrackCanvas::draw_plugins()
 	{
 		plugin_on_toggles.remove_object_number(current_on);
 	}
-
 }
 
 void TrackCanvas::refresh_plugintoggles()
@@ -1744,6 +1776,41 @@ void TrackCanvas::refresh_plugintoggles()
 		PluginShow *show = plugin_show_toggles.values[i];
 		show->reposition_window(show->get_x(), show->get_y());
 	}
+	for(int i = 0; i < preset_edit_buttons.total; i++)
+	{
+		PluginPresetEdit *preset_edit = preset_edit_buttons.values[i];
+		preset_edit->reposition_window(preset_edit->get_x(), preset_edit->get_y());
+	}
+}
+
+void TrackCanvas::draw_hard_edges()
+{
+	int64_t x, y, w, h;
+
+//	if(!mwindow->edl->session->show_assets) return;
+
+	for(Track *track = mwindow->edl->tracks->first; track; track = track->next) {
+		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);
+			set_color(GREEN);
+			set_opaque();    int y1 = y+h-1;
+			if( edit->hard_left ) {
+				ArrayList<int> xpt, ypt;
+				xpt.append(x);              ypt.append(y1);
+				xpt.append(x+HANDLE_W);     ypt.append(y1);
+				xpt.append(x);              ypt.append(y1-HANDLE_H);
+				fill_polygon(&xpt, &ypt);
+			}
+			if( edit->hard_right ) {
+				ArrayList<int> xpt, ypt;   int x1 = x+w-1;
+				xpt.append(x1);            ypt.append(y1);
+				xpt.append(x1-HANDLE_W);   ypt.append(y1);
+				xpt.append(x1);            ypt.append(y1-HANDLE_H);
+				fill_polygon(&xpt, &ypt);
+			}
+		}
+	}
 }
 
 void TrackCanvas::draw_inout_points()
@@ -1762,7 +1829,7 @@ void TrackCanvas::draw_drag_handle()
 			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(GREEN);
+		set_color(!snapped ? GREEN : (snapped=0, YELLOW));
 		set_inverse();
 //printf("TrackCanvas::draw_drag_handle 3\n");
 		draw_line(pixel1, 0, pixel1, get_h());
@@ -1851,41 +1918,36 @@ void TrackCanvas::draw_loop_points()
 //printf("TrackCanvas::draw_loop_points 7\n");
 }
 
-void TrackCanvas::draw_brender_start()
+void TrackCanvas::draw_brender_range()
 {
-	if(mwindow->preferences->use_brender)
+	if( !mwindow->preferences->use_brender || !mwindow->brender_active ) return;
+	if( mwindow->edl->session->brender_start >= mwindow->edl->session->brender_end ) return;
+	if( mwindow->edl->session->brender_end > 0 )
 	{
-		int64_t x = Units::round(mwindow->edl->session->brender_start *
+		int64_t x1 = Units::round(mwindow->edl->session->brender_start *
+			mwindow->edl->session->sample_rate /
+			mwindow->edl->local_session->zoom_sample -
+			mwindow->edl->local_session->view_start[pane->number]);
+		if(MWindowGUI::visible(x1, x1 + 1, 0, get_w()))
+		{
+			set_color(RED);
+			draw_line(x1, 0, x1, get_h());
+		}
+		int64_t x2 = Units::round(mwindow->edl->session->brender_end *
 			mwindow->edl->session->sample_rate /
 			mwindow->edl->local_session->zoom_sample -
 			mwindow->edl->local_session->view_start[pane->number]);
 
-		if(MWindowGUI::visible(x, x + 1, 0, get_w()))
+		if(MWindowGUI::visible(x2, x2 + 1, 0, get_w()))
 		{
 			set_color(RED);
-			draw_line(x, 0, x, get_h());
+			draw_line(x2, 0, x2, get_h());
 		}
 	}
 }
 
-static int auto_colors[AUTOMATION_TOTAL] =
-{
-	BLUE,
-	RED,
-	GREEN,
-	BLUE,
-	RED,
-	GREEN,
-	BLUE,
-	WHITE,
-	0,
-	0,
-	0,
-	WHITE
-};
-
 // The operations which correspond to each automation type
-static int auto_operations[AUTOMATION_TOTAL] =
+int TrackCanvas::auto_operations[AUTOMATION_TOTAL] =
 {
 	DRAG_MUTE,
 	DRAG_CAMERA_X,
@@ -1949,7 +2011,7 @@ int TrackCanvas::do_keyframes(int cursor_x,
 	for(Track *track = mwindow->edl->tracks->first;
 		track && !result;
 		track = track->next) {
-        	Auto *auto_keyframe = 0;
+		Auto *auto_keyframe = 0;
 		Automation *automation = track->automation;
 
 
@@ -1983,27 +2045,38 @@ int TrackCanvas::do_keyframes(int cursor_x,
 					case Autos::AUTOMATION_TYPE_FLOAT: {
 						Automation automation(0, track);
 						int grouptype = automation.autogrouptype(i, track);
+						if( buttonpress && i == AUTOMATION_SPEED ) {
+							mwindow->speed_before();
+						}
+
 						if(draw) // Do dropshadow
 							result = do_float_autos(track, autos,
-								cursor_x, cursor_y, draw, 
+								cursor_x, cursor_y, draw,
 								buttonpress, 1, 1, MDGREY,
 								auto_keyframe, grouptype);
-
 						result = do_float_autos(track, autos,
-							cursor_x, cursor_y, draw, 
-							buttonpress, 0, 0, auto_colors[i],
+							cursor_x, cursor_y, draw, buttonpress,
+							0, 0, GWindowGUI::auto_colors[i],
 							auto_keyframe, grouptype);
+
+						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();
+						}
 						break; }
 
 					case Autos::AUTOMATION_TYPE_INT: {
 						if(draw) // Do dropshadow
 							result = do_int_autos(track, autos,
-								cursor_x, cursor_y, draw, 
+								cursor_x, cursor_y, draw,
 								buttonpress, 1, 1, MDGREY,
 								auto_keyframe);
 						result = do_int_autos(track, autos,
-							cursor_x, cursor_y, draw, 
-							buttonpress, 0, 0, auto_colors[i],
+							cursor_x, cursor_y, draw, buttonpress,
+							0, 0, GWindowGUI::auto_colors[i],
 							auto_keyframe);
 						break; }
 					}
@@ -2128,7 +2201,7 @@ void TrackCanvas::draw_keyframe_reticle()
 				if( !autos ) continue;
 				for( Auto *auto_keyframe=autos->first; auto_keyframe;
 				     auto_keyframe = auto_keyframe->next ) {
-					draw_hairline(auto_keyframe, GREEN);
+					draw_hairline(auto_keyframe, BLUE);
 				}
 			}
 
@@ -2206,14 +2279,14 @@ 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, 
+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)
 {
@@ -2234,7 +2307,7 @@ void TrackCanvas::draw_floatauto(FloatAuto *current,
 		draw_box(x1, y1, x2 - x1, y2 - y1);
 	}
 
-// show bezier control points (only) if this 
+// 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)
@@ -2262,22 +2335,22 @@ inline void TrackCanvas::draw_floatauto_ctrlpoint(
 
 	y    += center_pixel;
 	cp_y += center_pixel;
-	
+
 	// drawing the tangent as a dashed line...
 	int const dash = HANDLE_W;
 	int const gap  = HANDLE_W / 2;
 	float sx = 3 * (cp_x - x) / 4.;
 	float ex = 0;
-	
+
 	// q is the x displacement for a unit line of slope
 	float q = (sx > 0 ? 1 : -1) / sqrt(1 + slope * slope);
-	
+
 	float dist = 1/q * sx;
 	if( dist > dash )
 		ex = sx - q * dash;
-	
+
 	set_color(color);
-	do {	
+	do {
 		float sy = slope * sx, ey = slope * ex;
 		draw_line(quantize(sx + x), quantize(sy + y), quantize(ex + x), quantize(ey + y));
 		sx = ex - q * gap;
@@ -2360,10 +2433,10 @@ inline float test_curve_line( int x0, int y0, int ctrl_x, int ctrl_y,
 }
 
 
-inline 
+inline
 float levered_position(float position, float ref_pos)
 {
-	if( 1e-6 > fabs(ref_pos) || isnan(ref_pos)) 
+	if( 1e-6 > fabs(ref_pos) || isnan(ref_pos))
 		return 0.0;
 	return ref_pos / position;
 }
@@ -2385,7 +2458,7 @@ 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 zoom_track, 
+	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 result = 0;
@@ -2436,7 +2509,7 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x,
 		if( WITHIN(x1,x2,y1,y2))
 		{	// cursor hits node
 			result = 1;
-			
+
 			if(buttonpress && (buttonpress != 3))
 			{
 				INIT_DRAG(current->position, value_to_percentage(current->get_value(), autogrouptype))
@@ -2453,13 +2526,13 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x,
 				// could be ctrl-click or ctrl-drag
 				// click would cycle through tangent modes
 				((FloatAuto*)current)->toggle_curve_mode();
-				
+
 				// drag will start dragging the tangent, if applicable
 				INIT_DRAG(current->position, value_to_percentage(current->get_value(), autogrouptype))
 				mwindow->session->drag_handle = 0;
 			}
 		}
-			
+
 		float lever = 0.0; // we use the tangent as a draggable lever. 1.0 is at the ctrl point
 
 // Test in control
@@ -2508,15 +2581,15 @@ int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x,
 #undef WITHIN
 #undef INIT_DRAG
 
-// if(buttonpress) 
-// printf("TrackCanvas::test_floatauto 2 drag_handle=%d ctrl_down=%d cursor_x=%d cursor_y=%d x1=%d x2=%d y1=%d y2=%d\n", 
+// if(buttonpress)
+// printf("TrackCanvas::test_floatauto 2 drag_handle=%d ctrl_down=%d cursor_x=%d cursor_y=%d x1=%d x2=%d y1=%d y2=%d\n",
 // mwindow->session->drag_handle,
 // ctrl_down(),
 // cursor_x,
 // cursor_y,
 // x1, x2, y1, y2);
 	if(buttonpress && (buttonpress != 3) && result)
-       	{
+	{
 		mwindow->undo->update_undo_before();
 	}
 
@@ -2633,7 +2706,10 @@ int TrackCanvas::test_floatline(int center_pixel,
 		{
 			Auto *current;
 			mwindow->undo->update_undo_before();
-			current = mwindow->session->drag_auto = autos->insert_auto(position1);
+			double position = autos->track->from_units(position1);
+			position = mwindow->edl->align_to_frame(position, 0);
+			int64_t new_position = autos->track->to_units(position,0);
+			current = mwindow->session->drag_auto = autos->insert_auto(new_position);
 			((FloatAuto*)current)->set_value(value);
 			mwindow->session->drag_start_percentage = value_to_percentage(value, autogrouptype);
 			mwindow->session->drag_start_position = current->position;
@@ -2994,7 +3070,7 @@ int TrackCanvas::do_float_autos(Track *track, Autos *autos, int cursor_x, int cu
 				(int)ax, (int)ax2, cursor_x, cursor_y,
 				buttonpress, autogrouptype);
 		}
-		if( draw ) 
+		if( draw )
 			draw_floatline(center_pixel,
 				(FloatAuto*)previous, (FloatAuto*)current,
 				(FloatAutos*)autos, unit_start, zoom_units, yscale,
@@ -3419,10 +3495,11 @@ void TrackCanvas::draw_overlays()
 
 // Plugins
 	draw_plugins();
+	draw_hard_edges();
 
 // Loop points
 	draw_loop_points();
-	draw_brender_start();
+	draw_brender_range();
 
 // Highlighted areas
 	draw_highlighting();
@@ -3473,15 +3550,46 @@ int TrackCanvas::deactivate()
 void TrackCanvas::update_drag_handle()
 {
 	double new_position;
+	int cursor_x = get_cursor_x();
 
 	new_position =
-		(double)(get_cursor_x() +
+		(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);
 
+	if( ctrl_down() && alt_down() ) {
+#define snapper(v) do { \
+	double pos = (v); \
+	if( pos < 0 ) break; \
+	double dist = fabs(new_position - pos); \
+	if( dist >= snap_min ) break; \
+	snap_position = pos;  snap_min = dist; \
+} while(0)
+		double snap_position = new_position;
+		double snap_min = DBL_MAX;
+		if( mwindow->edl->local_session->inpoint_valid() )
+			snapper(mwindow->edl->local_session->get_inpoint());
+		if( mwindow->edl->local_session->outpoint_valid() )
+			snapper(mwindow->edl->local_session->get_outpoint());
+		snapper(mwindow->edl->prev_edit(new_position));
+		snapper(mwindow->edl->next_edit(new_position));
+		Label *prev_label = mwindow->edl->labels->prev_label(new_position);
+		if( prev_label ) snapper(prev_label->position);
+		Label *next_label = mwindow->edl->labels->next_label(new_position);
+		if( next_label ) snapper(next_label->position);
+		int snap_x = snap_position * mwindow->edl->session->sample_rate /
+			mwindow->edl->local_session->zoom_sample -
+			mwindow->edl->local_session->view_start[pane->number];
+		if( abs(snap_x - cursor_x) < HANDLE_W ) {
+			snapped = 1;
+			new_position = snap_position;
+		}
+#undef snapper
+	}
 
 	if(new_position != mwindow->session->drag_position)
 	{
@@ -3585,7 +3693,7 @@ 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) &&
 		    (fabs(x) > HANDLE_W / 2 || fabs(y) > HANDLE_W / 2))
 			mwindow->session->drag_handle = x < 0 ? 1 : 2;
 	}
@@ -3631,7 +3739,7 @@ int TrackCanvas::update_drag_floatauto(int cursor_x, int cursor_y)
 
 		if(value != old_value || position != current->position) {
 			result = 1;
-			float change = value - old_value;		
+			float change = value - old_value;
 			current->adjust_to_new_coordinates(position, value);
 			synchronize_autos(change, current->autos->track, current, 0);
 			show_message(current, 1,", %.2f", current->get_value());
@@ -3708,7 +3816,7 @@ int TrackCanvas::update_drag_auto(int cursor_x, int cursor_y)
 
 		double position_f = current->autos->track->from_units(current->position);
 		double center_f = (mwindow->edl->local_session->get_selectionstart(1) +
-			mwindow->edl->local_session->get_selectionend(1)) / 
+			mwindow->edl->local_session->get_selectionend(1)) /
 			2;
 		if(!shift_down())
 		{
@@ -3740,7 +3848,7 @@ int TrackCanvas::update_drag_pluginauto(int cursor_x, int cursor_y)
 		//PluginAutos *pluginautos = (PluginAutos *)current->autos;
 		PluginSet *pluginset;
 		Plugin *plugin = 0;
-// figure out the correct pluginset & correct plugin 
+// figure out the correct pluginset & correct plugin
 		int found = 0;
 		for(int i = 0; i < track->plugin_set.total; i++)
 		{
@@ -3752,16 +3860,16 @@ int TrackCanvas::update_drag_pluginauto(int cursor_x, int cursor_y)
 					currentkeyframe;
 					currentkeyframe = (KeyFrame *) currentkeyframe->next)
 				{
-					if (currentkeyframe == current) 
+					if (currentkeyframe == current)
 					{
 						found = 1;
 						break;
 					}
- 
+
 				}
-				if (found) break;			
+				if (found) break;
 			}
-			if (found) break;			
+			if (found) break;
 		}
 
 		mwindow->session->plugin_highlighted = plugin;
@@ -3772,7 +3880,7 @@ int TrackCanvas::update_drag_pluginauto(int cursor_x, int cursor_y)
 
 		double position_f = current->autos->track->from_units(current->position);
 		double center_f = (mwindow->edl->local_session->get_selectionstart(1) +
-			mwindow->edl->local_session->get_selectionend(1)) / 
+			mwindow->edl->local_session->get_selectionend(1)) /
 			2;
 		if(!shift_down())
 		{
@@ -3797,14 +3905,14 @@ void TrackCanvas::update_drag_caption()
 	switch(mwindow->session->current_operation)
 	{
 		case DRAG_FADE:
-			
+
 			break;
 	}
 }
 
 
 
-int TrackCanvas::cursor_motion_event()
+int TrackCanvas::cursor_update(int in_motion)
 {
 	int result = 0;
 	int cursor_x = 0;
@@ -3817,7 +3925,7 @@ int TrackCanvas::cursor_motion_event()
 	int new_cursor = 0;
 	int rerender = 0;
 	double position = 0.;
-//printf("TrackCanvas::cursor_motion_event %d\n", __LINE__);
+//printf("TrackCanvas::cursor_update %d\n", __LINE__);
 
 // Default cursor
 	switch(mwindow->edl->session->editing_mode)
@@ -3880,6 +3988,8 @@ int TrackCanvas::cursor_motion_event()
 		case DRAG_PROJECTOR_Z:
 			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);
 			break;
 
 		case DRAG_PLAY:
@@ -3929,22 +4039,26 @@ int TrackCanvas::cursor_motion_event()
 				position = mwindow->edl->align_to_frame(position, 0);
 				position = MAX(position, 0);
 
+				double start = mwindow->edl->local_session->get_selectionstart(1);
+				double end = mwindow->edl->local_session->get_selectionend(1);
 				if(position < selection_midpoint) {
 					mwindow->edl->local_session->set_selectionend(selection_midpoint);
 					mwindow->edl->local_session->set_selectionstart(position);
-	// Que the CWindow
-					gui->unlock_window();
-					mwindow->cwindow->update(1, 0, 0, 0, 1);
-					gui->lock_window("TrackCanvas::cursor_motion_event 1");
-	// Update the faders
-					mwindow->update_plugin_guis();
-					gui->update_patchbay();
 				}
 				else {
 					mwindow->edl->local_session->set_selectionstart(selection_midpoint);
 					mwindow->edl->local_session->set_selectionend(position);
-	// Don't que the CWindow
 				}
+	// Que the CWindow
+				gui->unlock_window();
+				int dir =
+					start != mwindow->edl->local_session->get_selectionstart(1) ? 1 :
+					end != mwindow->edl->local_session->get_selectionend(1) ? -1 : 0;
+				mwindow->cwindow->update(dir, 0, 0, 0, 1);
+				gui->lock_window("TrackCanvas::cursor_update 1");
+	// Update the faders
+				mwindow->update_plugin_guis();
+				gui->update_patchbay();
 
 				timebar_position = mwindow->edl->local_session->get_selectionend(1);
 
@@ -3976,7 +4090,7 @@ int TrackCanvas::cursor_motion_event()
 				for(int i = 0; i < TOTAL_PANES; i++)
 					if(gui->pane[i]) gui->pane[i]->canvas->timebar_position = position;
 
-//printf("TrackCanvas::cursor_motion_event %d %d %p %p\n", __LINE__, pane->number, pane, pane->timebar);
+//printf("TrackCanvas::cursor_update %d %d %p %p\n", __LINE__, pane->number, pane, pane->timebar);
 				gui->update_timebar(0);
 // Update cursor
 				if(do_transitions(get_cursor_x(), get_cursor_y(),
@@ -3994,13 +4108,13 @@ int TrackCanvas::cursor_motion_event()
 			break;
 	}
 
-//printf("TrackCanvas::cursor_motion_event 1\n");
+//printf("TrackCanvas::cursor_update 1\n");
 	if(update_cursor && new_cursor != get_cursor())
 	{
 		set_cursor(new_cursor, 0, 1);
 	}
 
-//printf("TrackCanvas::cursor_motion_event 1 %d\n", rerender);
+//printf("TrackCanvas::cursor_update 1 %d\n", rerender);
 	if(rerender && render_timer->get_difference() > 0.25 ) {
 		render_timer->update();
 		mwindow->restart_brender();
@@ -4008,7 +4122,7 @@ int TrackCanvas::cursor_motion_event()
 		mwindow->update_plugin_guis();
 		gui->unlock_window();
 		mwindow->cwindow->update(1, 0, 0, 0, 1);
-		gui->lock_window("TrackCanvas::cursor_motion_event 2");
+		gui->lock_window("TrackCanvas::cursor_update 2");
 	}
 	if(rerender) {
 // Update faders
@@ -4039,10 +4153,15 @@ int TrackCanvas::cursor_motion_event()
 		gui->draw_overlays(1);
 	}
 
-//printf("TrackCanvas::cursor_motion_event %d\n", __LINE__);
+//printf("TrackCanvas::cursor_update %d\n", __LINE__);
 	return result;
 }
 
+int TrackCanvas::cursor_motion_event()
+{
+	return cursor_update(1);
+}
+
 void TrackCanvas::start_dragscroll()
 {
 	if(!drag_scroll) {
@@ -4142,7 +4261,8 @@ int TrackCanvas::repeat_event(int64_t duration)
 
 int TrackCanvas::button_release_event()
 {
-	int redraw = 0, update_overlay = 0, result = 0;
+	int redraw = -1, update_overlay = 0;
+	int result = 0, load_flags = 0;
 
 // printf("TrackCanvas::button_release_event %d\n",
 // mwindow->session->current_operation);
@@ -4176,8 +4296,10 @@ int TrackCanvas::button_release_event()
 			result = 1;
 			break;
 
-		case DRAG_FADE:
 		case DRAG_SPEED:
+			redraw = FORCE_REDRAW;
+			load_flags |= LOAD_EDITS;
+		case DRAG_FADE:
 // delete the drag_auto_gang first and remove out of order keys
 			synchronize_autos(0, 0, 0, -1);
 		case DRAG_CZOOM:
@@ -4194,6 +4316,7 @@ int TrackCanvas::button_release_event()
 		case DRAG_PROJECTOR_Y:
 		case DRAG_PROJECTOR_Z:
 		case DRAG_PLUGINKEY:
+			load_flags |= LOAD_AUTOMATION;
 			mwindow->session->current_operation = NO_OPERATION;
 			mwindow->session->drag_handle = 0;
 // Remove any out-of-order keyframe
@@ -4204,8 +4327,7 @@ int TrackCanvas::button_release_event()
 				update_overlay = 1;
 			}
 
-
-			mwindow->undo->update_undo_after(_("keyframe"), LOAD_AUTOMATION);
+			mwindow->undo->update_undo_after(_("keyframe"), load_flags);
 			result = 1;
 			break;
 
@@ -4232,13 +4354,14 @@ int TrackCanvas::button_release_event()
 	}
 
 	if (result)
-		cursor_motion_event();
+		cursor_update(0);
 
 	if(update_overlay) {
 		gui->draw_overlays(1);
 	}
-	if(redraw) {
-		gui->draw_canvas(NORMAL_DRAW, 0);
+	if(redraw >= 0) {
+		gui->draw_canvas(redraw, 0);
+		gui->flash_canvas(1);
 	}
 	return result;
 }
@@ -4247,53 +4370,58 @@ int TrackCanvas::do_edit_handles(int cursor_x, int cursor_y, int button_press,
 	int &rerender, int &update_overlay, int &new_cursor, int &update_cursor)
 {
 	Edit *edit_result = 0;
-	int handle_result = 0;
+	int handle_result = -1;
 	int result = 0;
 
-	if(!mwindow->edl->session->show_assets) return 0;
+	if( !mwindow->edl->session->show_assets ) return 0;
 
-	for(Track *track = mwindow->edl->tracks->first;
-		track && !result;
-		track = track->next) {
-		for(Edit *edit = track->edits->first;
-			edit && !result;
-			edit = edit->next) {
+	for( Track *track=mwindow->edl->tracks->first; track && !result; track=track->next) {
+		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(cursor_x >= edit_x && cursor_x <= edit_x + edit_w &&
-				cursor_y >= edit_y && cursor_y < edit_y + edit_h) {
-				if(cursor_x < edit_x + HANDLE_W) {
+			if( cursor_x >= edit_x && cursor_x <= edit_x + edit_w &&
+				cursor_y >= edit_y && cursor_y < edit_y + edit_h ) {
+				if( cursor_x < edit_x + HANDLE_W ) {
 					edit_result = edit;
 					handle_result = 0;
-					result = 1;
+					if( cursor_y >= edit_y+edit_h - HANDLE_W ) {
+						new_cursor = DOWNLEFT_RESIZE;
+						if( button_press == LEFT_BUTTON )
+							result = -1;
+					}
+					else
+						result = 1;
 				}
-				else if(cursor_x >= edit_x + edit_w - HANDLE_W) {
+				else if( cursor_x >= edit_x + edit_w - HANDLE_W ) {
 					edit_result = edit;
 					handle_result = 1;
-					result = 1;
-				}
-				else {
-					result = 0;
+					if( cursor_y >= edit_y+edit_h - HANDLE_W ) {
+						new_cursor = DOWNRIGHT_RESIZE;
+						if( button_press == LEFT_BUTTON )
+							result = -1;
+					}
+					else
+						result = 1;
 				}
 			}
 		}
 	}
 
 	update_cursor = 1;
-	if(result) {
+	if( result > 0 ) {
 		double position = 0;
-		if(handle_result == 0) {
+		if( handle_result == 0 ) {
 			position = edit_result->track->from_units(edit_result->startproject);
 			new_cursor = LEFT_CURSOR;
 		}
-		else if(handle_result == 1) {
+		else if( handle_result == 1 ) {
 			position = edit_result->track->from_units(edit_result->startproject + edit_result->length);
 			new_cursor = RIGHT_CURSOR;
 		}
 
 // Reposition cursor
-		if(button_press) {
+		if( button_press ) {
 			mwindow->session->drag_edit = edit_result;
 			mwindow->session->drag_handle = handle_result;
 			mwindow->session->drag_button = get_buttonpress() - 1;
@@ -4307,6 +4435,49 @@ int TrackCanvas::do_edit_handles(int cursor_x, int cursor_y, int button_press,
 			update_overlay = 1;
 		}
 	}
+	else if( result <  0) {
+		mwindow->undo->update_undo_before();
+		if( !shift_down() ) {
+			if( handle_result == 0 )
+				edit_result->hard_left = !edit_result->hard_left;
+			else if( handle_result == 1 )
+				edit_result->hard_right = !edit_result->hard_right;
+		}
+		else {
+			int status = handle_result == 0 ? edit_result->hard_left :
+				     handle_result == 1 ? edit_result->hard_right : 0;
+			int new_status = !status;
+			int64_t edit_edge = edit_result->startproject;
+			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 ) {
+				int64_t track_position = track->to_units(edge_position, 1);
+				Edit *left_edit = track->edits->editof(track_position, PLAY_FORWARD, 0);
+				if( left_edit ) {
+					int64_t left_edge = left_edit->startproject;
+					double left_position = track->from_units(left_edge);
+					if( EQUIV(edge_position, left_position) ) {
+						left_edit->hard_left = new_status;
+						if( left_edit->previous )
+							left_edit->previous->hard_right = new_status;
+					}
+				}
+				Edit *right_edit = track->edits->editof(track_position, PLAY_REVERSE, 0);
+				if( right_edit ) {
+					int64_t right_edge = right_edit->startproject + right_edit->length;
+					double right_position = track->from_units(right_edge);
+					if( EQUIV(edge_position, right_position) ) {
+						right_edit->hard_right = new_status;
+						if( right_edit->next )
+							right_edit->next->hard_left = new_status;
+					}
+				}
+			}
+		}
+		rerender = update_overlay = 1;
+		mwindow->undo->update_undo_after(_("hard_edge"), LOAD_EDITS);
+		result = 1;
+	}
 
 	return result;
 }
@@ -4399,9 +4570,11 @@ int TrackCanvas::do_tracks(int cursor_x, int cursor_y, int button_press)
 		int64_t track_x, track_y, track_w, track_h;
 		track_dimensions(track, track_x, track_y, track_w, track_h);
 
-		if(button_press && get_buttonpress() == 3 &&
-			cursor_y >= track_y && cursor_y < track_y + track_h) {
-			gui->edit_menu->update(track, 0);
+		if( button_press && get_buttonpress() == RIGHT_BUTTON &&
+		    cursor_y >= track_y && cursor_y < track_y + track_h) {
+			double pos = mwindow->edl->get_cursor_position(cursor_x, pane->number);
+			int64_t position = track->to_units(pos, 0);
+			gui->edit_menu->update(track, track->edits->editof(position, PLAY_FORWARD, 0));
 			gui->edit_menu->activate_menu();
 			result = 1;
 		}
@@ -4475,10 +4648,10 @@ int TrackCanvas::do_edits(int cursor_x, int cursor_y, int button_press, int drag
 							mwindow->edl->local_session->zoom_sample /
 							mwindow->edl->session->sample_rate;
 
+						int cx, cy;
+						get_abs_cursor(cx, cy);
 						gui->drag_popup = new BC_DragWindow(gui,
-							mwindow->theme->get_image("clip_icon") /*,
-							get_abs_cursor_x(0) - mwindow->theme->get_image("clip_icon")->get_w() / 2,
-							get_abs_cursor_y(0) - mwindow->theme->get_image("clip_icon")->get_h() / 2 */);
+							mwindow->theme->get_image("clip_icon"), cx, cy);
 
 						result = 1;
 					}
@@ -4587,19 +4760,18 @@ int TrackCanvas::do_plugins(int cursor_x, int cursor_y, int drag_start,
 							frame = mwindow->theme->get_image("veffect_icon");
 						}
 					}
-
-					gui->drag_popup = new BC_DragWindow(gui, frame /*,
-						get_abs_cursor_x(0) - frame->get_w() / 2,
-						get_abs_cursor_y(0) - frame->get_h() / 2 */);
+					int cx, cy;
+					get_abs_cursor(cx, cy);
+					gui->drag_popup = new BC_DragWindow(gui, frame, cx, cy);
 						break; }
 
 				case PLUGIN_SHAREDPLUGIN:
-				case PLUGIN_SHAREDMODULE:
-					gui->drag_popup = new BC_DragWindow(gui,
-						mwindow->theme->get_image("clip_icon") /*,
-						get_abs_cursor_x(0) - mwindow->theme->get_image("clip_icon")->get_w() / 2,
-						get_abs_cursor_y(0) - mwindow->theme->get_image("clip_icon")->get_h() / 2 */);
-					break;
+				case PLUGIN_SHAREDMODULE: {
+					VFrame *frame = mwindow->theme->get_image("clip_icon");
+					int cx, cy;
+					get_abs_cursor(cx, cy);
+					gui->drag_popup = new BC_DragWindow(gui, frame, cx, cy);
+					break; }
 				}
 
 				result = 1;
@@ -4665,12 +4837,7 @@ int TrackCanvas::button_press_event()
 	mwindow->session->trim_edits = 0;
 
 	if(is_event_win() && cursor_inside()) {
-//		double position = (double)cursor_x *
-//			mwindow->edl->local_session->zoom_sample /
-//			mwindow->edl->session->sample_rate +
-//			(double)mwindow->edl->local_session->view_start[pane->number] *
-//			mwindow->edl->local_session->zoom_sample /
-//			mwindow->edl->session->sample_rate;
+//		double position = mwindow->edl->get_cursor_position(cursor_x, pane->number);
 
 		result = 1;
 		if(!active) {
@@ -4678,9 +4845,7 @@ int TrackCanvas::button_press_event()
 		}
 
 		if( get_buttonpress() == LEFT_BUTTON ) {
-			gui->unlock_window();
-			gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
-			gui->lock_window("TrackCanvas::button_press_event");
+			gui->stop_transport("TrackCanvas::button_press_event");
 		}
 
 		int update_overlay = 0, update_cursor = 0, rerender = 0;
@@ -4752,12 +4917,7 @@ int TrackCanvas::button_press_event()
 
 // Test handles only and select a region
 			case EDITING_IBEAM: {
-				double position = (double)cursor_x *
-					mwindow->edl->local_session->zoom_sample /
-					mwindow->edl->session->sample_rate +
-					(double)mwindow->edl->local_session->view_start[pane->number] *
-					mwindow->edl->local_session->zoom_sample /
-					mwindow->edl->session->sample_rate;
+				double position = mwindow->edl->get_cursor_position(cursor_x, pane->number);
 //printf("TrackCanvas::button_press_event %d\n", position);
 
 				if( do_transitions(cursor_x, cursor_y,
@@ -4814,19 +4974,20 @@ int TrackCanvas::button_press_event()
 			gui->flash_canvas(1);
 		}
 	}
+
 	return result;
 }
 
 int TrackCanvas::start_selection(double position)
 {
 	int rerender = 0;
-	position = mwindow->edl->align_to_frame(position, 0);
+	position = mwindow->edl->align_to_frame(position, 1);
 
 
 // Extend a border
 	if(shift_down())
 	{
-		double midpoint = (mwindow->edl->local_session->get_selectionstart(1) + 
+		double midpoint = (mwindow->edl->local_session->get_selectionstart(1) +
 			mwindow->edl->local_session->get_selectionend(1)) / 2;
 
 		if(position < midpoint)
@@ -4853,7 +5014,7 @@ int TrackCanvas::start_selection(double position)
 // Que the CWindow
 		rerender = 1;
 	}
-	
+
 	return rerender;
 }
 
@@ -4870,8 +5031,8 @@ void TrackCanvas::end_pluginhandle_selection()
 
 double TrackCanvas::time_visible()
 {
-	return (double)get_w() * 
-		mwindow->edl->local_session->zoom_sample / 
+	return (double)get_w() *
+		mwindow->edl->local_session->zoom_sample /
 		mwindow->edl->session->sample_rate;
 }
 
@@ -4885,7 +5046,7 @@ void TrackCanvas::show_message(Auto *current, int show_curve_type, const char *f
 			FloatAuto::curve_name(((FloatAuto*)current)->curve_mode));
 	}
 	char string2[BCTEXTLEN];
-	Units::totext(string2, 
+	Units::totext(string2,
 		current->autos->track->from_units(current->position),
 		mwindow->edl->session->time_format,
 		mwindow->edl->session->sample_rate,
@@ -4913,7 +5074,7 @@ void TrackCanvas::show_message(Auto *current, int show_curve_type, const char *f
 // 		else
 // 			return gui->pane[BOTTOM_LEFT_PANE]->patchbay;
 // 	}
-// 
+//
 // 	return 0;
 // }