X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fcwindowtool.C;h=d7a4ec6cf95de294bcf14c5d36b15ef8752f8d9c;hp=1b874d35beb07838e7f7f1626c9c353b1a080a62;hb=ddfda6a8cc59bda4dc734973c1c5fecaa31ea487;hpb=fb661e853152fd63537629a20f493a4cdcd4f019

diff --git a/cinelerra-5.1/cinelerra/cwindowtool.C b/cinelerra-5.1/cinelerra/cwindowtool.C
index 1b874d35..d7a4ec6c 100644
--- a/cinelerra-5.1/cinelerra/cwindowtool.C
+++ b/cinelerra-5.1/cinelerra/cwindowtool.C
@@ -37,6 +37,7 @@
 #include "filexml.h"
 #include "floatauto.h"
 #include "floatautos.h"
+#include "gwindowgui.h"
 #include "keys.h"
 #include "language.h"
 #include "localsession.h"
@@ -52,6 +53,7 @@
 #include "tracks.h"
 #include "trackcanvas.h"
 #include "transportque.h"
+#include "zoombar.h"
 
 
 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
@@ -133,6 +135,7 @@ void CWindowTool::start_tool(int operation)
 				mwindow->edl->session->tool_window = 1;
 				gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
 			}
+			mwindow->edl->session->tool_window = new_gui ? 1 : 0;
 			update_show_window();
 
 // Signal thread to run next tool GUI
@@ -262,24 +265,15 @@ void CWindowTool::update_values()
 
 
 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
-	CWindowTool *thread,
-	const char *title,
-	int w,
-	int h)
+	CWindowTool *thread, const char *title, int w, int h)
  : BC_Window(title,
- 	mwindow->session->ctool_x,
-	mwindow->session->ctool_y,
-	w,
-	h,
-	w,
-	h,
-	0,
-	0,
-	1)
+		mwindow->session->ctool_x, mwindow->session->ctool_y,
+		w, h, w, h, 0, 0, 1)
 {
 	this->mwindow = mwindow;
 	this->thread = thread;
 	current_operation = 0;
+	span = 1;  edge = 0;
 }
 
 CWindowToolGUI::~CWindowToolGUI()
@@ -334,6 +328,23 @@ int CWindowToolGUI::translation_event()
 	return 0;
 }
 
+void CWindowToolGUI::update_auto(Track *track, int idx, CWindowCoord *vp)
+{
+	FloatAuto *float_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
+			track->automation->autos[idx], 1);
+	if( !float_auto ) return;
+	float v = float_auto->get_value(edge);
+	float t = atof(vp->get_text());
+	if( v == t ) return;
+	float_auto->bump_value(t, edge, span);
+	if( idx == AUTOMATION_PROJECTOR_Z || idx == AUTOMATION_CAMERA_Z ) {
+		mwindow->gui->lock_window("CWindowToolGUI::update_auto");
+		mwindow->gui->draw_overlays(1);
+		mwindow->gui->unlock_window();
+	}
+	update();
+	update_preview();
+}
 
 void CWindowToolGUI::update_preview(int changed_edl)
 {
@@ -352,40 +363,176 @@ void CWindowToolGUI::draw_preview(int changed_edl)
 }
 
 
-CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
- : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 100, 3)
+CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int type)
+ : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, xS(70), 3)
 {
 	this->gui = gui;
-	set_log_floatincrement(log_increment);
+	this->type = type;
+	slider = 0;
+	range = 0;
 }
 
-CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
- : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 100, 3)
+CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value, int type)
+ : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, xS(70))
 {
 	this->gui = gui;
+	this->type = type;
+	slider = 0;
+	range = 0;
+}
+
+void CWindowCoord::create_objects()
+{
+	BC_TumbleTextBox::create_objects();
+	if( type >= 0 ) {
+		float v = atof(get_text());
+		int xs10 = xS(10);
+		int x1 = get_x() + BC_TumbleTextBox::get_w() + xs10, y1 = get_y();
+		gui->add_subwindow(min_tumbler = new CWindowToolAutoRangeTumbler(this, x1, y1,
+				0, _("Range min")));
+		x1 += min_tumbler->get_w() + xs10;
+		int group = Automation::autogrouptype(type, 0);
+		float min = gui->mwindow->edl->local_session->automation_mins[group];
+		float max = gui->mwindow->edl->local_session->automation_maxs[group];
+		gui->add_subwindow(slider = new CWindowCoordSlider(this,
+				x1, y1, xS(150), min, max, v));
+		x1 += slider->get_w() + xS(10);
+		gui->add_subwindow(max_tumbler = new CWindowToolAutoRangeTumbler(this, x1, y1,
+				1, _("Range max")));
+		x1 += max_tumbler->get_w() + xS(10);
+		gui->add_subwindow(range_reset = new CWindowToolAutoRangeReset(this, x1, y1));
+		x1 += range_reset->get_w() + xS(10);
+		gui->add_subwindow(range_text = new CWindowToolAutoRangeTextBox(this, x1, y1));
+		range_text->update_range();
+		x1 += range_text->get_w() + xS(10);
+		gui->add_subwindow(range = new CWindowCoordRangeTumbler(this, x1, y1));
+	}
+}
+
+void CWindowCoord::update_gui(float value)
+{
+	BC_TumbleTextBox::update(value);
+	if( slider ) {
+		int group = Automation::autogrouptype(type, 0);
+		LocalSession *local_session = gui->mwindow->edl->local_session;
+		slider->update(slider->get_pointer_motion_range(), value,
+			local_session->automation_mins[group],
+			local_session->automation_maxs[group]);
+		int x1 = range->get_x() + range->get_w() + xS(5);
+		int y1 = range->get_y() + yS(5), d = xS(16);
+		gui->set_color(GWindowGUI::auto_colors[type]);
+		gui->draw_disc(x1, y1, d, d);
+	}
 }
+
 int CWindowCoord::handle_event()
 {
+	if( slider )
+		slider->update(atof(get_text()));
 	gui->event_caller = this;
 	gui->handle_event();
 	return 1;
 }
 
+CWindowCoordSlider::CWindowCoordSlider(CWindowCoord *coord,
+		int x, int y, int w, float mn, float mx, float value)
+ : BC_FSlider(x, y, 0, w, w, mn, mx, value)
+{
+	this->coord = coord;
+	set_precision(0.01);
+}
+
+CWindowCoordSlider::~CWindowCoordSlider()
+{
+}
+
+int CWindowCoordSlider::handle_event()
+{
+	float value = get_value();
+	coord->update(value);
+	coord->gui->event_caller = coord;
+	coord->gui->handle_event();
+	return 1;
+}
+
+CWindowCoordRangeTumbler::CWindowCoordRangeTumbler(CWindowCoord *coord, int x, int y)
+ : BC_Tumbler(x, y)
+{
+	this->coord = coord;
+}
+CWindowCoordRangeTumbler::~CWindowCoordRangeTumbler()
+{
+}
+
+int CWindowCoordRangeTumbler::update(float scale)
+{
+	CWindowCoordSlider *slider = coord->slider;
+	MWindow *mwindow = coord->gui->mwindow;
+	LocalSession *local_session = mwindow->edl->local_session;
+	int group = Automation::autogrouptype(coord->type, 0);
+	float min = local_session->automation_mins[group];
+	float max = local_session->automation_maxs[group];
+	if( min >= max ) {
+		switch( group ) {
+		case AUTOGROUPTYPE_ZOOM: min = 0.005;  max = 5.0;   break;
+		case AUTOGROUPTYPE_X:    min = -1000;  max = 1000;  break;
+		case AUTOGROUPTYPE_Y:    min = -1000;  max = 1000;  break;
+		}
+	}
+	switch( group ) {
+	case AUTOGROUPTYPE_ZOOM: { // exp
+		float lmin = log(min), lmax = log(max);
+		float lr = (lmax - lmin) * scale;
+		if( (min = exp(lmin - lr)) < ZOOM_MIN ) min = ZOOM_MIN;
+		if( (max = exp(lmax + lr)) > ZOOM_MAX ) max = ZOOM_MAX;
+		break; }
+	case AUTOGROUPTYPE_X:
+	case AUTOGROUPTYPE_Y: { // linear
+		float dr = (max - min) * scale;
+		if( (min -= dr) < XY_MIN ) min = XY_MIN;
+		if( (max += dr) > XY_MAX ) max =  XY_MAX;
+		break; }
+	}
+	slider->update(slider->get_pointer_motion_range(),
+			slider->get_value(), min, max);
+	unlock_window();
+	MWindowGUI *mgui = mwindow->gui;
+	mgui->lock_window("CWindowCoordRangeTumbler::update");
+	local_session->zoombar_showautotype = group;
+	local_session->automation_mins[group] = min;
+	local_session->automation_maxs[group] = max;
+	mgui->zoombar->update_autozoom();
+	mgui->draw_overlays(0);
+	mgui->update_patchbay();
+	mgui->flash_canvas(1);
+	mgui->unlock_window();
+	lock_window("CWindowCoordRangeTumbler::update");
+	return coord->range_text->update_range();
+}
 
-CWindowCropOK::CWindowCropOK(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
- : BC_GenericButton(x, y, _("Do it"))
+int CWindowCoordRangeTumbler::handle_up_event()
+{
+	return update(0.125);
+}
+int CWindowCoordRangeTumbler::handle_down_event()
+{
+	return update(-0.1);
+}
+
+CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
+ : BC_GenericButton(x, y, _("Apply"))
 {
 	this->mwindow = mwindow;
-	this->gui = gui;
+	this->crop_gui = crop_gui;
 }
-int CWindowCropOK::handle_event()
+int CWindowCropApply::handle_event()
 {
-	mwindow->crop_video();
+	mwindow->crop_video(crop_gui->crop_mode->mode);
 	return 1;
 }
 
 
-int CWindowCropOK::keypress_event()
+int CWindowCropApply::keypress_event()
 {
 	if(get_keypress() == 0xd)
 	{
@@ -395,18 +542,57 @@ int CWindowCropOK::keypress_event()
 	return 0;
 }
 
+const char *CWindowCropOpMode::crop_ops[] = {
+	N_("Reformat"),
+	N_("Resize"),
+	N_("Shrink"),
+};
+
+CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
+			int mode, int x, int y)
+ : BC_PopupMenu(x, y, xS(140), _(crop_ops[mode]), 1)
+{
+	this->mwindow = mwindow;
+	this->crop_gui = crop_gui;
+	this->mode = mode;
+}
+CWindowCropOpMode::~CWindowCropOpMode()
+{
+}
+
+void CWindowCropOpMode::create_objects()
+{
+	for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
+		add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
+	handle_event();
+}
+
+int CWindowCropOpMode::handle_event()
+{
+	set_text(_(crop_ops[mode]));
+	return 1;
+}
 
+CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
+ : BC_MenuItem(text)
+{
+	this->popup = popup;
+	this->id = id;
+}
+
+int CWindowCropOpItem::handle_event()
+{
+	popup->set_text(get_text());
+	popup->mode = id;
+	return popup->handle_event();
+}
 
 
 
 
 
 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow,
- 	thread,
-	_(PROGRAM_NAME ": Crop"),
-	330,
-	100)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Crop"), xS(330), yS(100))
 {
 }
 
@@ -417,34 +603,38 @@ CWindowCropGUI::~CWindowCropGUI()
 
 void CWindowCropGUI::create_objects()
 {
-	int x = 10, y = 10;
+	int xs5 = xS(5), xs10 = xS(10);
+	int ys5 = yS(5), ys10 = yS(10);
+	int x = xs10, y = ys10;
 	BC_Title *title;
 
 	lock_window("CWindowCropGUI::create_objects");
 	int column1 = 0;
 	int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
-		BC_Title::calculate_h(this, "X")) + 5;
+		BC_Title::calculate_h(this, "X")) + ys5;
 	add_subwindow(title = new BC_Title(x, y, "X1:"));
 	column1 = MAX(column1, title->get_w());
 	y += pad;
 	add_subwindow(title = new BC_Title(x, y, _("W:")));
 	column1 = MAX(column1, title->get_w());
 	y += pad;
-	add_subwindow(new CWindowCropOK(mwindow, thread->tool_gui, x, y));
+	add_subwindow(new CWindowCropApply(mwindow, this, x, y));
 
-	x += column1 + 5;
-	y = 10;
+	x += column1 + xs5;
+	y = ys10;
 	x1 = new CWindowCoord(thread->tool_gui, x, y,
 		mwindow->edl->session->crop_x1);
 	x1->create_objects();
+	x1->set_boundaries((int64_t)0, (int64_t)65536);
 	y += pad;
 	width = new CWindowCoord(thread->tool_gui, x, y,
 		mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
 	width->create_objects();
+	width->set_boundaries((int64_t)1, (int64_t)65536);
 
 
-	x += x1->get_w() + 10;
-	y = 10;
+	x += x1->get_w() + xs10;
+	y = ys10;
 	int column2 = 0;
 	add_subwindow(title = new BC_Title(x, y, "Y1:"));
 	column2 = MAX(column2, title->get_w());
@@ -453,15 +643,24 @@ void CWindowCropGUI::create_objects()
 	column2 = MAX(column2, title->get_w());
 	y += pad;
 
-	y = 10;
-	x += column2 + 5;
+	y = ys10;
+	x += column2 + xs5;
 	y1 = new CWindowCoord(thread->tool_gui, x, y,
 		mwindow->edl->session->crop_y1);
 	y1->create_objects();
+	y1->set_boundaries((int64_t)0, (int64_t)65536);
 	y += pad;
+
 	height = new CWindowCoord(thread->tool_gui, x, y,
 		mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
 	height->create_objects();
+	height->set_boundaries((int64_t)1, (int64_t)65536);
+	y += pad;
+
+	add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
+				CROP_REFORMAT, x, y));
+	crop_mode->create_objects();
+
 	unlock_window();
 }
 
@@ -484,10 +683,10 @@ void CWindowCropGUI::handle_event()
 			mwindow->edl->session->crop_y1;
 		mwindow->edl->session->crop_y1 = atol(y1->get_text());
 	}
- 	mwindow->edl->session->crop_x2 = atol(width->get_text()) +
- 		mwindow->edl->session->crop_x1;
- 	mwindow->edl->session->crop_y2 = atol(height->get_text()) +
- 		mwindow->edl->session->crop_y1;
+	mwindow->edl->session->crop_x2 = atol(width->get_text()) +
+		mwindow->edl->session->crop_x1;
+	mwindow->edl->session->crop_y2 = atol(height->get_text()) +
+		mwindow->edl->session->crop_y1;
 	update();
 	mwindow->cwindow->gui->canvas->redraw(1);
 }
@@ -504,7 +703,7 @@ void CWindowCropGUI::update()
 
 
 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), 220, 290)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), xS(220), yS(290))
 {
 }
 
@@ -514,10 +713,11 @@ CWindowEyedropGUI::~CWindowEyedropGUI()
 
 void CWindowEyedropGUI::create_objects()
 {
+	int xs10 = xS(10), ys10 = yS(10);
 	int margin = mwindow->theme->widget_border;
-	int x = 10 + margin;
-	int y = 10 + margin;
-	int x2 = 70, x3 = x2 + 60;
+	int x = xs10 + margin;
+	int y = ys10 + margin;
+	int x2 = xS(70), x3 = x2 + xS(60);
 	lock_window("CWindowEyedropGUI::create_objects");
 	BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
 	add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
@@ -556,7 +756,7 @@ void CWindowEyedropGUI::create_objects()
 	add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
 
 	y = title6->get_y() + this->v->get_h() + 2*margin;
-	add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
+	add_subwindow(sample = new BC_SubWindow(x, y, xS(50), yS(50)));
 	y += sample->get_h() + margin;
 	add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
 	update();
@@ -592,8 +792,8 @@ void CWindowEyedropGUI::update()
 	float y, u, v;
 	YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
 	this->y->update(y);
-	this->u->update(u);  u += 0.5;
-	this->v->update(v);  v += 0.5;
+	this->u->update(u += 0.5);
+	this->v->update(v += 0.5);
 
 	int yx = 255*y + 0.5;  bclamp(yx,0,255);
 	int ux = 255*u + 0.5;  bclamp(ux,0,255);
@@ -648,30 +848,27 @@ struct _CVD {
 	const char* tooltip;
 };
 
-const _CVD Camera_Crv_Smooth =
-	{	FloatAuto::SMOOTH,
-		true,
-		"tan_smooth",
-		N_("\"smooth\" Curve on current Camera Keyframes")
-	};
-const _CVD Camera_Crv_Linear =
-	{	FloatAuto::LINEAR,
-		true,
-		"tan_linear",
-		N_("\"linear\" Curve on current Camera Keyframes")
-	};
-const _CVD Projector_Crv_Smooth =
-	{	FloatAuto::SMOOTH,
-		false,
-		"tan_smooth",
-		N_("\"smooth\" Curve on current Projector Keyframes")
-	};
-const _CVD Projector_Crv_Linear =
-	{	FloatAuto::LINEAR,
-		false,
-		"tan_linear",
-		N_("\"linear\" Curve on current Projector Keyframes")
-	};
+const _CVD Camera_Crv_Smooth = { FloatAuto::SMOOTH, true, "tan_smooth",
+		N_("\"smooth\" Curve on current Camera Keyframes") };
+const _CVD Camera_Crv_Linear = { FloatAuto::LINEAR, true, "tan_linear",
+		N_("\"linear\" Curve on current Camera Keyframes") };
+const _CVD Camera_Crv_Tangent = { FloatAuto::TFREE, true, "tan_tangent",
+		N_("\"tangent\" Curve on current Camera Keyframes") };
+const _CVD Camera_Crv_Free  = { FloatAuto::FREE, true, "tan_free",
+		N_("\"free\" Curve on current Camera Keyframes") };
+const _CVD Camera_Crv_Bump = { FloatAuto::BUMP, true, "tan_bump",
+		N_("\"bump\" Curve on current Camera Keyframes") };
+
+const _CVD Projector_Crv_Smooth = { FloatAuto::SMOOTH, false, "tan_smooth",
+		N_("\"smooth\" Curve on current Projector Keyframes") };
+const _CVD Projector_Crv_Linear = { FloatAuto::LINEAR, false, "tan_linear",
+		N_("\"linear\" Curve on current Projector Keyframes") };
+const _CVD Projector_Crv_Tangent = { FloatAuto::TFREE, false, "tan_tangent",
+		N_("\"tangent\" Curve on current Projector Keyframes") };
+const _CVD Projector_Crv_Free  = { FloatAuto::FREE, false, "tan_free",
+		N_("\"free\" Curve on current Projector Keyframes") };
+const _CVD Projector_Crv_Bump = { FloatAuto::BUMP, false, "tan_bump",
+		N_("\"bump\" Curve on current Projector Keyframes") };
 
 // Implementation Class für Keyframe Curve Mode buttons
 //
@@ -684,17 +881,19 @@ const _CVD Projector_Crv_Linear =
 class CWindowCurveToggle : public BC_Toggle
 {
 public:
-	CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
+	CWindowCurveToggle(const _CVD &mode,
+			MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
 	void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
 	int handle_event();
 private:
-	_CVD cfg;
+	const _CVD &cfg;
 	MWindow *mwindow;
 	CWindowToolGUI *gui;
 };
 
 
-CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
+CWindowCurveToggle::CWindowCurveToggle(const _CVD &mode,
+			MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
  : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
    cfg(mode)
 {
@@ -734,7 +933,7 @@ int CWindowCurveToggle::handle_event()
 }
 
 
-CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow, 
+CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
 	CWindowEyedropGUI *gui, int x, int y)
  : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
 {
@@ -752,11 +951,7 @@ int CWindowEyedropCheckBox::handle_event()
 
 
 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow,
- 	thread,
-	_(PROGRAM_NAME ": Camera"),
-	170,
-	170)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Camera"), xS(580), yS(200))
 {
 }
 CWindowCameraGUI::~CWindowCameraGUI()
@@ -765,61 +960,86 @@ CWindowCameraGUI::~CWindowCameraGUI()
 
 void CWindowCameraGUI::create_objects()
 {
-	int x = 10, y = 10, x1;
+	int xs5 = xS(5), xs10 = xS(10), xs15 = xS(15), xs25 = xS(25);
+	int ys10 = yS(10), ys30 = yS(30);
+	int x = xs10, y = ys10;
 	Track *track = mwindow->cwindow->calculate_affected_track();
 	FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
 	BC_Title *title;
 	BC_Button *button;
+	span = 1;  edge = 0;
 
 	lock_window("CWindowCameraGUI::create_objects");
 	if( track ) {
 		mwindow->cwindow->calculate_affected_autos(track,
 			&x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
 	}
+	int x1 = x;
+	add_subwindow(bar1 = new BC_TitleBar(x1, y, xS(340), xs10, xs10, _("Position")));
+	x1 += bar1->get_w() + xS(35);
+	add_subwindow(bar2 = new BC_TitleBar(x1, y, get_w()-x1-xs10, xs10, xs10, _("Range")));
+	y += bar1->get_h() + ys10;
 
 	add_subwindow(title = new BC_Title(x, y, "X:"));
-	x += title->get_w();
-	this->x = new CWindowCoord(this, x, y,
-		x_auto ? x_auto->get_value() : (float)0);
+	x1 = x + title->get_w() + xS(3);
+	float xvalue = x_auto ? x_auto->get_value() : 0;
+	this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_CAMERA_X);
 	this->x->create_objects();
-
-
-	y += 30;
-	x = 10;
-	add_subwindow(title = new BC_Title(x, y, "Y:"));
-	x += title->get_w();
-	this->y = new CWindowCoord(this, x, y,
-		y_auto ? y_auto->get_value() : (float)0);
+	this->x->range->set_tooltip(_("expand X range"));
+	y += ys30;
+	add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
+	float yvalue = y_auto ? y_auto->get_value() : 0;
+	this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_CAMERA_Y);
 	this->y->create_objects();
-	y += 30;
-	x = 10;
-	add_subwindow(title = new BC_Title(x, y, "Z:"));
-	x += title->get_w();
-	this->z = new CWindowCoord(this, x, y,
-		z_auto ? z_auto->get_value() : (float)1);
+	this->y->range->set_tooltip(_("expand Y range"));
+	y += ys30;
+	add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
+	float zvalue = z_auto ? z_auto->get_value() : 1;
+	this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_CAMERA_Z);
 	this->z->create_objects();
 	this->z->set_increment(0.01);
-
-	y += 30;
-	x1 = 10;
+	this->z->range->set_tooltip(_("expand Zoom range"));
+	y += ys30 + ys10;
+
+	x1 = x;
+	add_subwindow(bar3 = new BC_TitleBar(x1, y, xS(180)-x1, xs5, xs5, _("Justify")));
+	x1 += bar3->get_w() + xS(35);
+	add_subwindow(bar4 = new BC_TitleBar(x1, y, xS(375)-x1, xs5, xs5, _("Curve type")));
+	x1 += bar4->get_w() + xS(25);
+	add_subwindow(bar5 = new BC_TitleBar(x1, y, get_w()-xS(60)-x1, xs5, xs5, _("Keyframe")));
+	y += bar3->get_h() + ys10;
+
+	x1 = x;
 	add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
-
-	y += button->get_h();
-	x1 = 10;
+	x1 += button->get_w() + xs25;
 	add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
-// additional Buttons to control the curve mode of the "current" keyframe
-	x1 += button->get_w() + 15;
-	add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
-	x1 += button->get_w();
-	add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
+	x1 += button->get_w() + xS(35);
+	add_subwindow(t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
+	x1 += t_smooth->get_w() + xs10;
+	add_subwindow(t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
+	x1 += t_linear->get_w() + xs10;
+	add_subwindow(t_tangent = new CWindowCurveToggle(Camera_Crv_Tangent, mwindow, this, x1, y));
+	x1 += t_tangent->get_w() + xs10;
+	add_subwindow(t_free = new CWindowCurveToggle(Camera_Crv_Free, mwindow, this, x1, y));
+	x1 += t_free->get_w() + xs10;
+	add_subwindow(t_bump = new CWindowCurveToggle(Camera_Crv_Bump, mwindow, this, x1, y));
+	x1 += button->get_w() + xs25;
+	y += yS(5);
+	add_subwindow(add_keyframe = new CWindowCameraAddKeyframe(mwindow, this, x1, y));
+	x1 += add_keyframe->get_w() + xs15;
+	add_subwindow(auto_edge = new CWindowCurveAutoEdge(mwindow, this, x1, y));
+	x1 += auto_edge->get_w() + xs10;
+	add_subwindow(auto_span = new CWindowCurveAutoSpan(mwindow, this, x1, y));
+	x1 += auto_span->get_w() + xS(50);
+	add_subwindow(reset = new CWindowCameraReset(mwindow, this, x1, y));
 
 // fill in current auto keyframe values, set toggle states.
 	this->update();
@@ -828,65 +1048,16 @@ void CWindowCameraGUI::create_objects()
 
 void CWindowCameraGUI::handle_event()
 {
-	FloatAuto *x_auto = 0;
-	FloatAuto *y_auto = 0;
-	FloatAuto *z_auto = 0;
 	Track *track = mwindow->cwindow->calculate_affected_track();
-	if(track)
-	{
-		mwindow->undo->update_undo_before(_("camera"), this);
-		if(event_caller == x)
-		{
-			x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_CAMERA_X],
-				1);
-			if(x_auto)
-			{
-				x_auto->set_value(atof(x->get_text()));
-				update();
-				update_preview();
-			}
-		}
-		else
-		if(event_caller == y)
-		{
-			y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_CAMERA_Y],
-				1);
-			if(y_auto)
-			{
-				y_auto->set_value(atof(y->get_text()));
-				update();
-				update_preview();
-			}
-		}
-		else
-		if(event_caller == z)
-		{
-			z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_CAMERA_Z],
-				1);
-			if(z_auto)
-			{
-				float zoom = atof(z->get_text());
-				if(zoom > 100.) zoom = 100.;
-				else
-				if(zoom < 0.01) zoom = 0.01;
-	// Doesn't allow user to enter from scratch
-	// 		if(zoom != atof(z->get_text()))
-	// 			z->update(zoom);
-
-				z_auto->set_value(zoom);
-				mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
-				mwindow->gui->draw_overlays(1);
-				mwindow->gui->unlock_window();
-				update();
-				update_preview();
-			}
-		}
-
-		mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
-	}
+	if( !track ) return;
+	mwindow->undo->update_undo_before(_("camera"), this);
+	if( event_caller == x )
+		update_auto(track, AUTOMATION_CAMERA_X, x);
+	else if( event_caller == y )
+		update_auto(track, AUTOMATION_CAMERA_Y, y);
+	else if( event_caller == z )
+		update_auto(track, AUTOMATION_CAMERA_Z, z);
+	mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
 }
 
 void CWindowCameraGUI::update()
@@ -895,31 +1066,199 @@ void CWindowCameraGUI::update()
 	FloatAuto *y_auto = 0;
 	FloatAuto *z_auto = 0;
 	Track *track = mwindow->cwindow->calculate_affected_track();
+	int bg_color = get_resources()->text_background;
+	int hi_color = bg_color ^ 0x444444;
 	if( track ) {
 		mwindow->cwindow->calculate_affected_autos(track,
 			&x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
 	}
 
-	if(x_auto)
-		x->update(x_auto->get_value());
-	if(y_auto)
-		y->update(y_auto->get_value());
-	if(z_auto) {
-		float value = z_auto->get_value();
-		z->update(value);
+	if( x_auto ) {
+		int color = (edge || span) && x_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		x->get_textbox()->set_back_color(color);
+		float xvalue = x_auto->get_value(edge);
+		x->update_gui(xvalue);
+	}
+	if( y_auto ) {
+		int color = (edge || span) && y_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		y->get_textbox()->set_back_color(color);
+		float yvalue = y_auto->get_value(edge);
+		y->update_gui(yvalue);
+	}
+	if( z_auto ) {
+		int color = (edge || span) && z_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		z->get_textbox()->set_back_color(color);
+		float zvalue = z_auto->get_value(edge);
+		z->update_gui(zvalue);
 		thread->gui->lock_window("CWindowCameraGUI::update");
-		thread->gui->composite_panel->cpanel_zoom->update(value);
+		thread->gui->composite_panel->cpanel_zoom->update(zvalue);
 		thread->gui->unlock_window();
 	}
 
-	if( x_auto && y_auto && z_auto )
-	{
+	if( x_auto && y_auto && z_auto ) {
 		t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
 		t_linear->check_toggle_state(x_auto, y_auto, z_auto);
+		t_tangent->check_toggle_state(x_auto, y_auto, z_auto);
+		t_free->check_toggle_state(x_auto, y_auto, z_auto);
+		t_bump->check_toggle_state(x_auto, y_auto, z_auto);
 	}
+	x->range_text->update_range();
+	y->range_text->update_range();
+	z->range_text->update_range();
+}
+
+CWindowToolAutoRangeTumbler::CWindowToolAutoRangeTumbler(CWindowCoord *coord, int x, int y,
+		int use_max, const char *tip)
+ : BC_Tumbler(x, y, coord->gui->mwindow->theme->get_image_set("auto_range"),
+		TUMBLER_HORZ)
+{
+	this->coord = coord;
+	this->use_max = use_max;
+	set_tooltip(tip);
+}
+
+int CWindowToolAutoRangeTumbler::handle_up_event()
+{
+	coord->gui->mwindow->update_autorange(coord->type, 1, use_max);
+	coord->range_text->update_range();
+	return 1;
 }
 
+int CWindowToolAutoRangeTumbler::handle_down_event()
+{
+	coord->gui->mwindow->update_autorange(coord->type, 0, use_max);
+	coord->range_text->update_range();
+	return 1;
+}
+
+CWindowToolAutoRangeReset::CWindowToolAutoRangeReset(CWindowCoord *coord, int x, int y)
+ : BC_Button(x, y, coord->gui->mwindow->theme->get_image_set("reset_button"))
+{
+	this->coord = coord;
+	set_tooltip(_("Reset"));
+}
+
+int CWindowToolAutoRangeReset::handle_event()
+{
+	float v = 0;
+	int group = Automation::autogrouptype(coord->type, 0);
+	MWindow *mwindow = coord->gui->mwindow;
+	LocalSession *local_session = mwindow->edl->local_session;
+	float min = local_session->automation_mins[group];
+	float max = local_session->automation_maxs[group];
+	switch( group ) {
+	case AUTOGROUPTYPE_ZOOM: // exp
+		min = 0.005;  max= 5.000;  v = 1;
+		break;
+	case AUTOGROUPTYPE_X:
+		max = mwindow->edl->session->output_w;
+		min = -max;
+		break;
+	case AUTOGROUPTYPE_Y:
+		max = mwindow->edl->session->output_h;
+		min = -max;
+		break;
+	}
+	local_session->automation_mins[group] = min;
+	local_session->automation_maxs[group] = max;
+	coord->range_text->update_range();
+	unlock_window();
+	MWindowGUI *mgui = mwindow->gui;
+	mgui->lock_window("CWindowToolAutoRangeReset::update");
+	int color = GWindowGUI::auto_colors[coord->type];
+	mgui->zoombar->update_autozoom(group, color);
+	mgui->draw_overlays(0);
+	mgui->update_patchbay();
+	mgui->flash_canvas(1);
+	mgui->unlock_window();
+	mwindow->save_backup();
+	lock_window("CWindowToolAutoRangeReset::update");
+	CWindowCoordSlider *slider = coord->slider;
+	slider->update(slider->get_pointer_motion_range(), v, min, max);
+	return slider->handle_event();
+}
+
+CWindowToolAutoRangeTextBox::CWindowToolAutoRangeTextBox(CWindowCoord *coord, int x, int y)
+ : BC_TextBox(x, y, xS(130), 1, "0.000 to 0.000")
+{
+        this->coord = coord;
+        set_tooltip(_("Automation range"));
+}
+
+int CWindowToolAutoRangeTextBox::button_press_event()
+{
+        if (!is_event_win()) return 0;
+	int use_max = get_cursor_x() < get_w()/2 ? 0 : 1;
+        switch( get_buttonpress() ) {
+	case WHEEL_UP:
+		coord->gui->mwindow->update_autorange(coord->type, 1, use_max);
+		break;
+	case WHEEL_DOWN:
+		coord->gui->mwindow->update_autorange(coord->type, 0, use_max);
+		break;
+	default:
+		return BC_TextBox::button_press_event();
+        }
+	return coord->range_text->update_range();
+}
+
+int CWindowToolAutoRangeTextBox::handle_event()
+{
+        float imin, imax;
+        if( sscanf(this->get_text(),"%f to%f",&imin, &imax) == 2 ) {
+		MWindow *mwindow = coord->gui->mwindow;
+		int group = Automation::autogrouptype(coord->type, 0);
+		LocalSession *local_session = mwindow->edl->local_session;
+		float min = imin, max = imax;
+		switch( group ) {
+		case AUTOGROUPTYPE_ZOOM:
+			if( min < ZOOM_MIN ) min = ZOOM_MIN;
+			if( max > ZOOM_MAX ) max = ZOOM_MAX;
+			break;
+		case AUTOGROUPTYPE_X:
+		case AUTOGROUPTYPE_Y:
+			if( min < XY_MIN ) min = XY_MIN;
+			if( max > XY_MAX ) max = XY_MAX;
+			break;
+		}
+                if( max > min ) {
+			local_session->automation_mins[group] = min;
+			local_session->automation_maxs[group] = max;
+			if( min != imin || max != imax ) update_range();
+			mwindow->gui->lock_window("CWindowToolAutoRangeTextBox::handle_event");
+			int color = GWindowGUI::auto_colors[coord->type];
+			mwindow->gui->zoombar->update_autozoom(group, color);
+			mwindow->gui->draw_overlays(0);
+			mwindow->gui->update_patchbay();
+			mwindow->gui->flash_canvas(1);
+			mwindow->gui->unlock_window();
+		}
+	}
+	return 1;
+}
 
+int CWindowToolAutoRangeTextBox::update_range()
+{
+	char string[BCSTRLEN];
+	LocalSession *local_session = coord->gui->mwindow->edl->local_session;
+	int group = Automation::autogrouptype(coord->type, 0);
+	float min = local_session->automation_mins[group];
+	float max = local_session->automation_maxs[group];
+	switch( group ) {
+	case AUTOGROUPTYPE_ZOOM:
+		sprintf(string, "%0.03f to %0.03f\n", min, max);
+		break;
+	case AUTOGROUPTYPE_X:
+	case AUTOGROUPTYPE_Y:
+		sprintf(string, "%0.0f to %.0f\n", min, max);
+		break;
+	}
+	update(string);
+	return 1;
+}
 
 
 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
@@ -944,8 +1283,7 @@ int CWindowCameraLeft::handle_event()
 		int w = 0, h = 0;
 		track->get_source_dimensions(
 			mwindow->edl->local_session->get_selectionstart(1),
-			w,
-			h);
+			w, h);
 
 		if(w && h)
 		{
@@ -976,8 +1314,7 @@ int CWindowCameraCenter::handle_event()
 	Track *track = mwindow->cwindow->calculate_affected_track();
 	if(track)
 		x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-			track->automation->autos[AUTOMATION_CAMERA_X],
-			1);
+			track->automation->autos[AUTOMATION_CAMERA_X], 1);
 
 	if(x_auto)
 	{
@@ -1014,8 +1351,7 @@ int CWindowCameraRight::handle_event()
 		int w = 0, h = 0;
 		track->get_source_dimensions(
 			mwindow->edl->local_session->get_selectionstart(1),
-			w,
-			h);
+			w, h);
 
 		if(w && h)
 		{
@@ -1054,8 +1390,7 @@ int CWindowCameraTop::handle_event()
 		int w = 0, h = 0;
 		track->get_source_dimensions(
 			mwindow->edl->local_session->get_selectionstart(1),
-			w,
-			h);
+			w, h);
 
 		if(w && h)
 		{
@@ -1122,8 +1457,7 @@ int CWindowCameraBottom::handle_event()
 		int w = 0, h = 0;
 		track->get_source_dimensions(
 			mwindow->edl->local_session->get_selectionstart(1),
-			w,
-			h);
+			w, h);
 
 		if(w && h)
 		{
@@ -1139,13 +1473,71 @@ int CWindowCameraBottom::handle_event()
 	return 1;
 }
 
+CWindowCameraAddKeyframe::CWindowCameraAddKeyframe(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Add Keyframe: Shift-F11"));
+}
+
+int CWindowCameraAddKeyframe::handle_event()
+{
+	return gui->press(&CWindowCanvas::camera_keyframe);
+}
+
+CWindowCameraReset::CWindowCameraReset(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Reset Camera: F11"));
+}
+
+int CWindowCameraReset::handle_event()
+{
+	mwindow->edl->local_session->reset_view_limits();
+	CWindowCameraGUI *gui = (CWindowCameraGUI *)this->gui;
+	return gui->press(&CWindowCanvas::reset_camera);
+}
+
+CWindowCurveAutoEdge::CWindowCurveAutoEdge(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Toggle(x, y, mwindow->theme->get_image_set("bump_edge"), gui->edge)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Bump edit edge left/right"));
+}
+
+int CWindowCurveAutoEdge::handle_event()
+{
+	gui->edge = get_value();
+	gui->update();
+	return 1;
+}
+
+CWindowCurveAutoSpan::CWindowCurveAutoSpan(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Toggle(x, y, mwindow->theme->get_image_set("bump_span"), gui->span)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Bump spans to next/prev"));
+}
+
+int CWindowCurveAutoSpan::handle_event()
+{
+	gui->span = get_value();
+	gui->update();
+	return 1;
+}
+
 
 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow,
- 	thread,
-	_(PROGRAM_NAME ": Projector"),
-	170,
-	170)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Projector"), xS(580), yS(200))
 {
 }
 CWindowProjectorGUI::~CWindowProjectorGUI()
@@ -1153,62 +1545,87 @@ CWindowProjectorGUI::~CWindowProjectorGUI()
 }
 void CWindowProjectorGUI::create_objects()
 {
-	int x = 10, y = 10, x1;
+	int xs5 = xS(5), xs10 = xS(10), xs15 = xS(15), xs25 = xS(25);
+	int ys10 = yS(10), ys30 = yS(30);
+	int x = xs10, y = ys10;
 	Track *track = mwindow->cwindow->calculate_affected_track();
 	FloatAuto *x_auto = 0;
 	FloatAuto *y_auto = 0;
 	FloatAuto *z_auto = 0;
 	BC_Title *title;
 	BC_Button *button;
+	span = 1;  edge = 0;
 
 	lock_window("CWindowProjectorGUI::create_objects");
 	if( track ) {
 		mwindow->cwindow->calculate_affected_autos(track,
 			&x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
 	}
-
-	add_subwindow(title = new BC_Title(x, y, "X:"));
-	x += title->get_w();
-	this->x = new CWindowCoord(this, x, y,
-		x_auto ? x_auto->get_value() : (float)0);
+	int x1 = x;
+	add_subwindow(bar1 = new BC_TitleBar(x1, y, xS(340), xs10, xs10, _("Position")));
+	x1 += bar1->get_w() + xS(35);
+	add_subwindow(bar2 = new BC_TitleBar(x1, y, get_w()-x1-xs10, xs10, xs10, _("Range")));
+	y += bar1->get_h() + ys10;
+	add_subwindow(title = new BC_Title(x = xs10, y, "X:"));
+	x1 = x + title->get_w() + xS(3);
+	float xvalue = x_auto ? x_auto->get_value() : 0;
+	this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_PROJECTOR_X);
 	this->x->create_objects();
-	y += 30;
-	x = 10;
-	add_subwindow(title = new BC_Title(x, y, "Y:"));
-	x += title->get_w();
-	this->y = new CWindowCoord(this, x, y,
-		y_auto ? y_auto->get_value() : (float)0);
+	this->x->range->set_tooltip(_("expand X range"));
+	y += ys30;
+	add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
+	float yvalue = y_auto ? y_auto->get_value() : 0;
+	this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_PROJECTOR_Y);
 	this->y->create_objects();
-	y += 30;
-	x = 10;
-	add_subwindow(title = new BC_Title(x, y, "Z:"));
-	x += title->get_w();
-	this->z = new CWindowCoord(this, x, y,
-		z_auto ? z_auto->get_value() : (float)1);
+	this->y->range->set_tooltip(_("expand Y range"));
+	y += ys30;
+	add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
+	float zvalue = z_auto ? z_auto->get_value() : 1;
+	this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_PROJECTOR_Z);
 	this->z->create_objects();
+	this->z->range->set_tooltip(_("expand Zoom range"));
 	this->z->set_increment(0.01);
+	y += ys30 + ys10;
+
+	x1 = x;
+	add_subwindow(bar3 = new BC_TitleBar(x1, y, xS(180)-x1, xs5, xs5, _("Justify")));
+	x1 += bar3->get_w() + xS(35);
+	add_subwindow(bar4 = new BC_TitleBar(x1, y, xS(375)-x1, xs5, xs5, _("Curve type")));
+	x1 += bar4->get_w() + xS(25);
+	add_subwindow(bar5 = new BC_TitleBar(x1, y, get_w()-xS(60)-x1, xs5, xs5, _("Keyframe")));
+	y += bar3->get_h() + ys10;
 
-	y += 30;
-	x1 = 10;
+	x1 = x;
 	add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
-
-	y += button->get_h();
-	x1 = 10;
+	x1 += button->get_w() + xs25;
 	add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
 	x1 += button->get_w();
 	add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
-
-// additional Buttons to control the curve mode of the "current" keyframe
-	x1 += button->get_w() + 15;
-	add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
-	x1 += button->get_w();
-	add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
+	x1 += button->get_w() + xS(35);
+	add_subwindow(t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
+	x1 += t_smooth->get_w() + xs10;
+	add_subwindow(t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
+	x1 += t_linear->get_w() + xs10;
+	add_subwindow(t_tangent = new CWindowCurveToggle(Projector_Crv_Tangent, mwindow, this, x1, y));
+	x1 += t_tangent->get_w() + xs10;
+	add_subwindow(t_free = new CWindowCurveToggle(Projector_Crv_Free, mwindow, this, x1, y));
+	x1 += t_free->get_w() + xs10;
+	add_subwindow(t_bump = new CWindowCurveToggle(Projector_Crv_Bump, mwindow, this, x1, y));
+	x1 += button->get_w() + xs25;
+	y += yS(5);
+	add_subwindow(add_keyframe = new CWindowProjectorAddKeyframe(mwindow, this, x1, y));
+	x1 += add_keyframe->get_w() + xs15;
+	add_subwindow(auto_edge = new CWindowCurveAutoEdge(mwindow, this, x1, y));
+	x1 += auto_edge->get_w() + xs10;
+	add_subwindow(auto_span = new CWindowCurveAutoSpan(mwindow, this, x1, y));
+	x1 += auto_span->get_w() + xS(50);
+	add_subwindow(reset = new CWindowProjectorReset(mwindow, this, x1, y));
 
 // fill in current auto keyframe values, set toggle states.
 	this->update();
@@ -1217,64 +1634,16 @@ void CWindowProjectorGUI::create_objects()
 
 void CWindowProjectorGUI::handle_event()
 {
-	FloatAuto *x_auto = 0;
-	FloatAuto *y_auto = 0;
-	FloatAuto *z_auto = 0;
 	Track *track = mwindow->cwindow->calculate_affected_track();
-
-	if(track)
-	{
-		mwindow->undo->update_undo_before(_("projector"), this);
-		if(event_caller == x)
-		{
-			x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_PROJECTOR_X],
-				1);
-			if(x_auto)
-			{
-				x_auto->set_value(atof(x->get_text()));
-				update();
-				update_preview();
-			}
-		}
-		else
-		if(event_caller == y)
-		{
-			y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_PROJECTOR_Y],
-				1);
-			if(y_auto)
-			{
-				y_auto->set_value(atof(y->get_text()));
-				update();
-				update_preview();
-			}
-		}
-		else
-		if(event_caller == z)
-		{
-			z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-				track->automation->autos[AUTOMATION_PROJECTOR_Z],
-				1);
-			if(z_auto)
-			{
-				float zoom = atof(z->get_text());
-				if(zoom > 100.) zoom = 100.;
-				else if(zoom < 0.01) zoom = 0.01;
-// 			if (zoom != atof(z->get_text()))
-// 				z->update(zoom);
-				z_auto->set_value(zoom);
-
-				mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
-				mwindow->gui->draw_overlays(1);
-				mwindow->gui->unlock_window();
-
-				update();
-				update_preview();
-			}
-		}
-		mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
-	}
+	if( !track ) return;
+	mwindow->undo->update_undo_before(_("projector"), this);
+	if( event_caller == x )
+		update_auto(track, AUTOMATION_PROJECTOR_X, x);
+	else if( event_caller == y )
+		update_auto(track, AUTOMATION_PROJECTOR_Y, y);
+	else if( event_caller == z )
+		update_auto(track, AUTOMATION_PROJECTOR_Z, z);
+	mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
 }
 
 void CWindowProjectorGUI::update()
@@ -1283,28 +1652,48 @@ void CWindowProjectorGUI::update()
 	FloatAuto *y_auto = 0;
 	FloatAuto *z_auto = 0;
 	Track *track = mwindow->cwindow->calculate_affected_track();
+	int bg_color = get_resources()->text_background;
+	int hi_color = bg_color ^ 0x444444;
 	if( track ) {
 		mwindow->cwindow->calculate_affected_autos(track,
 			&x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
 	}
 
-	if(x_auto)
-		x->update(x_auto->get_value());
-	if(y_auto)
-		y->update(y_auto->get_value());
-	if(z_auto) {
-		float value = z_auto->get_value();
-		z->update(value);
+	if( x_auto ) {
+		int color = (edge || span) && x_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		x->get_textbox()->set_back_color(color);
+		float xvalue = x_auto->get_value(edge);
+		x->update_gui(xvalue);
+	}
+	if( y_auto ) {
+		int color = (edge || span) && y_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		y->get_textbox()->set_back_color(color);
+		float yvalue = y_auto->get_value(edge);
+		y->update_gui(yvalue);
+	}
+	if( z_auto ) {
+		int color = (edge || span) && z_auto->curve_mode == FloatAuto::BUMP ?
+			hi_color : bg_color;
+		z->get_textbox()->set_back_color(color);
+		float zvalue = z_auto->get_value(edge);
+		z->update_gui(zvalue);
 		thread->gui->lock_window("CWindowProjectorGUI::update");
-		thread->gui->composite_panel->cpanel_zoom->update(value);
+		thread->gui->composite_panel->cpanel_zoom->update(zvalue);
 		thread->gui->unlock_window();
 	}
 
-	if( x_auto && y_auto && z_auto )
-	{
+	if( x_auto && y_auto && z_auto ) {
 		t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
 		t_linear->check_toggle_state(x_auto, y_auto, z_auto);
+		t_tangent->check_toggle_state(x_auto, y_auto, z_auto);
+		t_free->check_toggle_state(x_auto, y_auto, z_auto);
+		t_bump->check_toggle_state(x_auto, y_auto, z_auto);
 	}
+	x->range_text->update_range();
+	y->range_text->update_range();
+	z->range_text->update_range();
 }
 
 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
@@ -1350,8 +1739,7 @@ int CWindowProjectorCenter::handle_event()
 	Track *track = mwindow->cwindow->calculate_affected_track();
 	if(track)
 		x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
-			track->automation->autos[AUTOMATION_PROJECTOR_X],
-			1);
+			track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
 
 	if(x_auto)
 	{
@@ -1486,10 +1874,50 @@ int CWindowProjectorBottom::handle_event()
 	return 1;
 }
 
+CWindowProjectorAddKeyframe::CWindowProjectorAddKeyframe(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Add Keyframe: Shift-F12"));
+}
+
+int CWindowProjectorAddKeyframe::handle_event()
+{
+	return gui->press(&CWindowCanvas::projector_keyframe);
+}
+
+CWindowProjectorReset::CWindowProjectorReset(MWindow *mwindow,
+		CWindowToolGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Reset Projector: F12"));
+}
+
+int CWindowProjectorReset::handle_event()
+{
+	mwindow->edl->local_session->reset_view_limits();
+	CWindowProjectorGUI *gui = (CWindowProjectorGUI *)this->gui;
+	return gui->press(&CWindowCanvas::reset_projector);
+}
+
+int CWindowToolGUI::press(void (CWindowCanvas::*fn)())
+{
+	unlock_window();
+	CWindowGUI *cw_gui = thread->gui;
+	cw_gui->lock_window("CWindowGUI::press");
+	(cw_gui->canvas->*fn)();
+	cw_gui->unlock_window();
+	lock_window("CWindowToolGUI::press");
+	return 1;
+}
 
 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
 		int x, int y, int w, const char *text)
- : BC_PopupTextBox(gui, 0, text, x, y, w, 120)
+ : BC_PopupTextBox(gui, 0, text, x, y, w, yS(120))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -1507,7 +1935,7 @@ int CWindowMaskOnTrack::handle_event()
 	if( k >= 0 ) {
 		track_item = (CWindowMaskItem *)track_items[k];
 		Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
-		if( track && track->record ) track_id = track->get_id();
+		if( track && track->is_armed() ) track_id = track->get_id();
 	}
 	else
 		track_id = mwindow->cwindow->mask_track_id;
@@ -1531,7 +1959,7 @@ void CWindowMaskOnTrack::update_items()
 	for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
 		if( track->data_type != TRACK_VIDEO ) continue;
 		MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
-		int color = !track->record ? RED : mask_autos->first ?  high_color : -1;
+		int color = !track->is_armed() ? RED : mask_autos->first ?  high_color : -1;
 		MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
 		for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
 			if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
@@ -1579,7 +2007,7 @@ int CWindowMaskTrackTumbler::do_event(int dir)
 			track_item = items[0];
 	}
 	Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
-	int track_id = track_item && track && track->record ? track_item->id : -1;
+	int track_id = track_item && track && track->is_armed() ? track_item->id : -1;
 	gui->mask_on_track->set_back_color(track_id >= 0 ?
 		gui->get_resources()->text_background :
 		gui->get_resources()->text_background_disarmed);
@@ -1595,7 +2023,7 @@ int CWindowMaskTrackTumbler::do_event(int dir)
 
 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
 		int x, int y, const char *text)
- : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
+ : BC_PopupTextBox(gui, 0, text, x, y, xS(100), yS(160))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -1749,8 +2177,8 @@ int CWindowMaskEnable::handle_event()
 }
 
 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
-	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Enable"))
+	CWindowMaskGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -1922,22 +2350,12 @@ int CWindowMaskDelPoint::handle_event()
 	return 1;
 }
 
-int CWindowMaskDelPoint::keypress_event()
-{
-	if( get_keypress() == BACKSPACE ||
-	    get_keypress() == DELETE )
-		return handle_event();
-	return 0;
-}
-
-
-
 
 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y)
  : BC_TumbleTextBox(gui,
 		(int64_t)mwindow->cwindow->gui->affected_point,
-		(int64_t)0, INT64_MAX, x, y, 100)
+		(int64_t)0, INT64_MAX, x, y, xS(70))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -2018,9 +2436,9 @@ CWindowMaskScaleXY::~CWindowMaskScaleXY()
 int CWindowMaskScaleXY::handle_event()
 {
 	gui->scale_mode = id;
-	gui->mask_scale_x->update(id == 0);
-	gui->mask_scale_y->update(id == 1);
-	gui->mask_scale_xy->update(id == 2);
+	gui->mask_scale_x->update(id == MASK_SCALE_X);
+	gui->mask_scale_y->update(id == MASK_SCALE_Y);
+	gui->mask_scale_xy->update(id == MASK_SCALE_XY);
 	return 1;
 }
 
@@ -2087,7 +2505,7 @@ int CWindowMaskDrawBoundary::handle_event()
 
 
 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
- : BC_TumbleTextBox(gui, 0, -FEATHER_MAX, FEATHER_MAX, x, y, 64, 2)
+ : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, xS(64), 2)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -2134,7 +2552,6 @@ int CWindowMaskFeather::update_value(float v)
 			if( !gui->mask_enables[i]->get_value() ) continue;
 			SubMask *sub_mask = keyframe->get_submask(i);
 			float feather = sub_mask->feather + change;
-			bclamp(feather, -FEATHER_MAX, FEATHER_MAX);
 			sub_mask->feather = feather;
 		}
 #ifdef USE_KEYFRAME_SPANNING
@@ -2150,13 +2567,15 @@ int CWindowMaskFeather::update_value(float v)
 int CWindowMaskFeather::handle_event()
 {
 	float v = atof(get_text());
+	if( fabsf(v) > MAX_FEATHER )
+		BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
 	gui->feather_slider->update(v);
 	return gui->feather->update_value(v);
 }
 
 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
 		CWindowMaskGUI *gui, int x, int y, int w, float v)
- : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX, FEATHER_MAX, v)
+ : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -2164,6 +2583,7 @@ CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
 	timer = new Timer();
 	stick = 0;
 	last_v = 0;
+	max = FEATHER_MAX;
 }
 
 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
@@ -2173,36 +2593,50 @@ CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
 
 int CWindowMaskFeatherSlider::handle_event()
 {
+	int sticky = 0;
 	float v = get_value();
-	if( stick > 0 ) {
-		int64_t ms = timer->get_difference();
-		if( ms < 250 && --stick > 0 ) {
-			if( get_value() == 0 ) return 1;
-			update(v = 0);
+	if( fabsf(v) > MAX_FEATHER )
+		v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
+	if( stick && timer->get_difference() >= 250 )
+		stick = 0; // no events for .25 sec
+	if( stick && (last_v * (v-last_v)) < 0 )
+		stick = 0; // dv changed direction
+	if( stick ) {
+		if( --stick > 0 ) {
+			timer->update();
+			update(last_v);
+			return 1;
 		}
-		else {
-			stick = 0;
-			last_v = v;
+		if( last_v ) {
+			max *= 1.25;
+			if( max > MAX_FEATHER ) max = MAX_FEATHER;
+			update(get_w(), v=last_v, -max-5, max+5);
+			button_release_event();
 		}
 	}
-	else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
-		stick = 16;
-		v = 0;
-	}
-	else
-		last_v = v;
-	timer->update();
+	else if( v > max ) { v = max;  sticky = 24; }
+	else if( v < -max ) { v = -max; sticky = 24; }
+	else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0;  sticky = 16; }
+	if( sticky ) { update(v);  stick = sticky;  timer->update(); }
+	last_v = v;
 	gui->feather->BC_TumbleTextBox::update(v);
 	return gui->feather->update_value(v);
 }
 
 int CWindowMaskFeatherSlider::update(float v)
 {
-	return BC_FSlider::update(v);
+	float vv = fabsf(v);
+	if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
+	while( max < vv ) max *= 1.25;
+	return update(get_w(), v, -max-5, max+5);
+}
+int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
+{
+	return BC_FSlider::update(r, v, mn, mx);
 }
 
 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
- : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
+ : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, xS(64), 2)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -2351,6 +2785,24 @@ int CWindowMaskGangFocus::handle_event()
 	return 1;
 }
 
+CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
+		CWindowMaskGUI *gui, int x, int y)
+ : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Gang points"));
+}
+
+CWindowMaskGangPoint::~CWindowMaskGangPoint()
+{
+}
+
+int CWindowMaskGangPoint::handle_event()
+{
+	return 1;
+}
+
 
 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
 		const char *tip, int type, int on, int x, int y, const char *images)
@@ -2491,7 +2943,7 @@ int CWindowMaskGangFeather::handle_event()
 
 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
  : CWindowToolGUI(mwindow, thread,
-	_(PROGRAM_NAME ": Mask"), 460, 700)
+	_(PROGRAM_NAME ": Mask"), xS(440), yS(700))
 {
 	this->mwindow = mwindow;
 	this->thread = thread;
@@ -2517,33 +2969,37 @@ CWindowMaskGUI::~CWindowMaskGUI()
 
 void CWindowMaskGUI::create_objects()
 {
+	int t[SUBMASKS];
 	Theme *theme = mwindow->theme;
-	int x = 10, y = 10, margin = theme->widget_border;
+	int xs10 = xS(10), ys10 = yS(10);
+	int x = xs10, y = ys10;
+	int margin = theme->widget_border;
 	int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
 	int clr_x = get_w()-x - clr_w;
-	int del_w = CWindowMaskDelMask::calculate_w(this,_("Delete"));
-	int del_x = clr_x-2*margin - del_w;
 
 	lock_window("CWindowMaskGUI::create_objects");
 	BC_TitleBar *title_bar;
-	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks on Track")));
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Masks on Track")));
 	y += title_bar->get_h() + margin;
 	BC_Title *title;
 	add_subwindow(title = new BC_Title(x,y, _("Track:")));
-	int x1 = x + 90;
+	int x1 = x + xS(90), ww = clr_x-2*margin - x1;
+	for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
+	int del_x = t[5];
 	Track *track = mwindow->cwindow->calculate_affected_track();
 	const char *text = track ? track->title : "";
 	mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
-	mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, 100, text);
+	mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, xS(100), text);
 	mask_on_track->create_objects();
 	mask_on_track->set_tooltip(_("Video track"));
 	int x2 = x1 + mask_on_track->get_w();
 	add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
 	mwindow->edl->local_session->solo_track_id = -1;
-	x2 = del_x + (del_w - CWindowMaskSoloTrack::calculate_w(this)) / 2;
-	add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, x2, y, 0));
+	add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
 	y += mask_on_track->get_h() + margin;
-	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks")));
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Masks")));
 	y += title_bar->get_h() + margin;
 	add_subwindow(title = new BC_Title(x, y, _("Mask:")));
 	mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
@@ -2552,15 +3008,6 @@ void CWindowMaskGUI::create_objects()
 	add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
 	add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
 	y += mask_name->get_h() + 2*margin;
-	add_subwindow(title = new BC_Title(x, y, _("Presets:")));
-	add_subwindow(mask_shape = new CWindowMaskShape(mwindow, this));
-	mask_shape->create_objects();
-	add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, x2=x1, y, 80));
-	x2 += mask_load->get_w() + 2*margin;
-	add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, x2, y, 80));
-	x2 += mask_save->get_w() + 2*margin;
-	add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, x2, y, 80));
-	y += mask_load->get_h() + 2*margin;
 	BC_Bar *bar;
 //	add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
 //	y += bar->get_h() + 2*margin;
@@ -2568,37 +3015,59 @@ void CWindowMaskGUI::create_objects()
 	add_subwindow(title = new BC_Title(x, y, _("Select:")));
 	int bw = 0, bh = 0;
 	BC_CheckBox::calculate_extents(this, &bw, &bh);
-	int bdx = bw + 2*margin;
-	x2 = x1;
-	for( int i=0; i<SUBMASKS; x2+=bdx, ++i ) {
+	for( int i=0; i<SUBMASKS; ++i ) {
 		int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
-		mask_buttons[i] = new CWindowMaskButton(mwindow, this, x2, y, i, v);
+		mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
 		add_subwindow(mask_buttons[i]);
 	}
-	x2 += margin;
-	add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, x2, y));
+	add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
 	y += bh + margin;
-	x2 = x1;
-	for( int i=0; i<SUBMASKS; x2+=bdx, ++i ) {
+	for( int i=0; i<SUBMASKS; ++i ) {
 		char text[BCSTRLEN];  sprintf(text, "%d", i);
 		int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
-		mask_blabels[i] = new BC_Title(x2+tx, y, text);
+		mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
 		add_subwindow(mask_blabels[i]);
 	}
-	x2 += margin;
-	add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, x2, y, 80));
 	y += mask_blabels[0]->get_h() + margin;
-	add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, x, y, x1-x-2*margin));
-	x2 = x1;
-	for( int i=0; i<SUBMASKS; x2+=bdx, ++i ) {
-		mask_enables[i] = new CWindowMaskEnable(mwindow, this, x2, y, i, 1);
+	add_subwindow(title = new BC_Title(x, y, _("Enable:")));
+	for( int i=0; i<SUBMASKS; ++i ) {
+		mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
 		add_subwindow(mask_enables[i]);
 	}
-	x2 += margin;
-	add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, x2, y, 80));
+	add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
 	y += mask_enables[0]->get_h() + 2*margin;
-	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Fade & Feather")));
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Preset Shapes")));
 	y += title_bar->get_h() + margin;
+	add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
+		"mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
+	add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
+		"mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
+	add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
+		"mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
+	add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
+		"mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
+	add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
+	add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, xS(80)));
+	add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, xS(80)));
+	add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, xS(80)));
+	y += mask_load->get_h() + 2*margin;
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Position & Scale")));
+	y += title_bar->get_h() + 2*margin;
+	add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, xS(80)));
+	add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, xS(80)));
+
+	add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
+		t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
+	add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
+		t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
+	add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
+		t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
+	y += mask_center->get_h() + 2*margin;
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Fade & Feather")));
+	y += title_bar->get_h() + 2*margin;
 
 	add_subwindow(title = new BC_Title(x, y, _("Fade:")));
 	fade = new CWindowMaskFade(mwindow, this, x1, y);
@@ -2616,30 +3085,29 @@ void CWindowMaskGUI::create_objects()
 	add_subwindow(feather_slider);
 	add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
 	y += feather->get_h() + 2*margin;
-	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Mask Points")));
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Mask Points")));
 	y += title_bar->get_h() + margin;
 
-	x1 = x + 60;
 	add_subwindow(title = new BC_Title(x, y, _("Point:")));
-	active_point = new CWindowMaskAffectedPoint(mwindow, this, x1, y);
+	active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
 	active_point->create_objects();
-	int x3  = x1 + active_point->get_w() + 4*margin;
 // typ=0, this mask, this point
 	add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
-		_("linear point"), 0, 0, x3, y, "mask_pnt_linear_images"));
-	int x4  = x3 + mask_pnt_linear->get_w() + 2*margin;
+		_("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
 	add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
-		_("smooth point"), 0, 1, x4, y, "mask_pnt_smooth_images"));
+		_("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
 	add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
+	add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
 	y += active_point->get_h() + margin;
 	add_subwindow(title = new BC_Title(x, y, "X:"));
-	this->x = new CWindowCoord(this, x1, y, (float)0.0);
+	this->x = new CWindowCoord(this, t[0], y, (float)0.0);
 	this->x->create_objects();
 // typ>0, this mask, all points
 	add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
-		_("linear curve"), 1, 0, x3, y, "mask_crv_linear_images"));
+		_("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
 	add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
-		_("smooth curve"), 1, 1, x4, y, "mask_crv_smooth_images"));
+		_("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
 	add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
 	y += this->x->get_h() + margin;
 	add_subwindow(title = new BC_Title(x, y, "Y:"));
@@ -2647,43 +3115,32 @@ void CWindowMaskGUI::create_objects()
 	this->y->create_objects();
 // typ<0, all masks, all points
 	add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
-		_("linear all"), -1, 0, x3, y, "mask_all_linear_images"));
+		_("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
 	add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
-		_("smooth all"), -1, 1, x4, y, "mask_all_smooth_images"));
+		_("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
 	add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
 	y += this->y->get_h() + 2*margin;
-	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Pivot Point")));
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
+			_("Pivot Point")));
 	y += title_bar->get_h() + margin;
 
 	add_subwindow(title = new BC_Title(x, y, "X:"));
 	float cx = mwindow->edl->session->output_w / 2.f;
 	focus_x = new CWindowCoord(this, x1, y, cx);
 	focus_x->create_objects();
-	x2 = x1 + focus_x->get_w() + 3*margin;
-	add_subwindow(title = new BC_Title(x2, y, _("Scaling Mode:")));
-	x2 = clr_x - 2*margin - CWindowMaskFocus::calculate_w(this);
-	add_subwindow(focus = new CWindowMaskFocus(mwindow, this, x2, y));
+	add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
 	add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
 	y += focus_x->get_h() + margin;
 	add_subwindow(title = new BC_Title(x, y, "Y:"));
 	float cy = mwindow->edl->session->output_h / 2.f;
 	focus_y = new CWindowCoord(this, x1, y, cy);
 	focus_y->create_objects();
-	x2 = x1 + focus_y->get_w() + 3*margin;
-	add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
-		x2, y, theme->get_image_set("mask_scale_x"), 0, 0, _("scale x")));
-	x2 += mask_scale_x->get_w() + margin;
-	add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
-		x2, y, theme->get_image_set("mask_scale_y"), 0, 1, _("scale y")));
-	x2 += mask_scale_y->get_w() + margin;
-	add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
-		x2, y, theme->get_image_set("mask_scale_xy"), 1, 2, _("scale xy")));
-	y += focus_x->get_h() + 2*margin;
+	y += focus_y->get_h() + 2*margin;
 	add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
 	y += bar->get_h() + margin;
-	add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
+	add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, x, y));
 	y += this->apply_before_plugins->get_h();
-	add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
+	add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, x, y));
 	add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
 	y += this->disable_opengl_masking->get_h() + 2*margin;
 	help_y = y;
@@ -2693,7 +3150,6 @@ void CWindowMaskGUI::create_objects()
 		"Shift+LMB: move an end point\n"
 		"Ctrl+LMB: move a control point\n"
 		"Alt+LMB: to drag translate the mask\n"
-		"Shift+Key Delete: to delete the point\n"
 		"Shift+MMB: Set Pivot Point at pointer\n"
 		"Wheel: rotate around Pivot Point\n"
 		"Shift+Wheel: scale around Pivot Point\n"
@@ -2760,7 +3216,7 @@ void CWindowMaskGUI::update()
 //printf("CWindowMaskGUI::update 1\n");
 	get_keyframe(track, autos, keyframe, mask, point, 0);
 	mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
-	mask_on_track->set_back_color(!track || track->record ?
+	mask_on_track->set_back_color(!track || track->is_armed() ?
 		get_resources()->text_background :
 		get_resources()->text_background_disarmed);
 	mask_on_track->update_items();
@@ -2797,44 +3253,53 @@ void CWindowMaskGUI::update()
 
 void CWindowMaskGUI::handle_event()
 {
-	Track *track;
-	MaskAuto *keyframe;
-	MaskAutos *autos;
-	SubMask *mask;
-	MaskPoint *point;
-	get_keyframe(track, autos, keyframe, mask, point, 0);
-
-	mwindow->undo->update_undo_before(_("mask point"), this);
-
-	if(point)
-	{
+	int redraw = 0;
+	if( event_caller == this->focus_x ||
+	    event_caller == this->focus_y ) {
+		redraw = 1;
+	}
+	else if( event_caller == this->x ||
+		 event_caller == this->y ) {
+		Track *track;
+		MaskAuto *keyframe;
+		MaskAutos *autos;
+		SubMask *mask;
+		MaskPoint *point;
+		get_keyframe(track, autos, keyframe, mask, point, 0);
+
+		mwindow->undo->update_undo_before(_("mask point"), this);
+
+		if( point ) {
+			float px = atof(x->get_text());
+			float py = atof(y->get_text());
+			float dx = px - point->x, dy = py - point->y;
 #ifdef USE_KEYFRAME_SPANNING
 // Create temp keyframe
-		MaskAuto temp_keyframe(mwindow->edl, autos);
-		temp_keyframe.copy_data(keyframe);
+			MaskAuto temp_keyframe(mwindow->edl, autos);
+			temp_keyframe.copy_data(keyframe);
 // Get affected point in temp keyframe
-		mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
-		if(mwindow->cwindow->gui->affected_point < mask->points.total &&
-			mwindow->cwindow->gui->affected_point >= 0)
-		{
-			point = mask->points.values[mwindow->cwindow->gui->affected_point];
-		}
-
-		if(point)
-		{
-			point->x = atof(x->get_text());
-			point->y = atof(y->get_text());
+			mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
+#endif
+			MaskPoints &points = mask->points;
+			int gang = gang_point->get_value();
+			int k = mwindow->cwindow->gui->affected_point;
+			int n = gang ? points.size() : k+1;
+			for( int i=gang? 0 : k; i<n; ++i ) {
+				if( i < 0 || i >= points.size() ) continue;
+				MaskPoint *point = points[i];
+				point->x += dx;  point->y += dy;
+			}
+#ifdef USE_KEYFRAME_SPANNING
 // Commit to spanned keyframes
 			autos->update_parameter(&temp_keyframe);
-		}
-#else
-		point->x = atof(x->get_text());
-		point->y = atof(y->get_text());
 #endif
+		}
+		mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
+		redraw = 1;
 	}
 
-	update_preview();
-	mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
+	if( redraw )
+		update_preview();
 }
 
 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
@@ -2944,7 +3409,7 @@ int CWindowMaskGUI::save_mask(const char *nm)
 	int i = masks.size();
 	while( --i >= 0 ) {
 		if( strcmp(masks[i]->name, nm) ) continue;
-		masks.remove_object_number(i);
+		masks.remove_object_number(i++);
 	}
 	mask = new SubMask(0, -1);
 	strncpy(mask->name, nm, sizeof(mask->name)-1);
@@ -2962,7 +3427,7 @@ int CWindowMaskGUI::del_mask(const char *nm)
 	int i = masks.size();
 	while( --i >= 0 ) {
 		if( strcmp(masks[i]->name, nm) ) continue;
-		masks.remove_object_number(i);
+		masks.remove_object_number(i++);
 	}
 	save_masks(masks);
 	masks.remove_all_objects();
@@ -3084,9 +3549,73 @@ int CWindowMaskGUI::normal_mask()
 }
 
 
+CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
+ : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_use_button(0);
+}
+
+CWindowMaskLoadList::~CWindowMaskLoadList()
+{
+}
+
+
+int CWindowMaskLoadList::handle_event()
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
+#ifdef USE_KEYFRAME_SPANNING
+	int create_it = 0;
+#else
+	int create_it = 1;
+#endif
+
+	mwindow->undo->update_undo_before(_("mask shape"), this);
+
+// Get existing keyframe
+	gui->get_keyframe(track, autos, keyframe,
+			mask, point, create_it);
+	CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
+	if( track && item ) {
+#ifdef USE_KEYFRAME_SPANNING
+		MaskAuto temp_keyframe(mwindow->edl, autos);
+		temp_keyframe.copy_data(keyframe);
+		keyframe = &temp_keyframe;
+		mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
+#endif
+		ArrayList<SubMask *> masks;
+		gui->load_masks(masks);
+		mask->copy_from(*masks[item->id], 0);
+		masks.remove_all_objects();
+#ifdef USE_KEYFRAME_SPANNING
+		autos->update_parameter(keyframe);
+#endif
+		gui->update();
+		gui->update_preview(1);
+	}
+	mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
+	return 1;
+}
+
+void CWindowMaskLoadList::create_objects()
+{
+	shape_items.remove_all_objects();
+	ArrayList<SubMask *> masks;
+	gui->load_masks(masks);
+	for( int i=0; i<masks.size(); ++i )
+		shape_items.append(new CWindowMaskItem(masks[i]->name, i));
+	masks.remove_all_objects();
+	update(&shape_items, 0, 0, 1);
+}
+
 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Load"))
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -3095,16 +3624,16 @@ CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
 
 int CWindowMaskLoad::handle_event()
 {
-	gui->mask_shape->create_objects();
+	gui->mask_load_list->create_objects();
 	int px, py;
 	get_abs_cursor(px, py);
-	return gui->mask_shape->activate(px, py, 120,160);
+	return gui->mask_load_list->activate(px, py, xS(120),yS(160));
 }
 
 
 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Save"))
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -3180,24 +3709,26 @@ void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
 
 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
 			int x, int y, const char *title)
- : BC_Window(title, x, y, 320, 100, 320, 100, 0, 0, 1)
+ : BC_Window(title, x, y, xS(320), yS(100), xS(320), yS(100), 0, 0, 1)
 {
 	this->preset_dialog = preset_dialog;
 }
 
 void CWindowMaskPresetGUI::create_objects()
 {
-	int x = 10, y = 10, pad = 8;
+	int xs8 = xS(8), xs10 = xS(10);
+	int ys10 = yS(10);
+	int x = xs10, y = ys10;
 	lock_window("CWindowMaskPresetGUI::create_objects");
 	BC_Title *title;
 	add_subwindow(title = new BC_Title(x, y,
 		preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
-	int x1 = x + title->get_w() + pad;
-	int x2 = get_w() - x - pad - x1 -
+	int x1 = x + title->get_w() + xs8;
+	int x2 = get_w() - x - xs8 - x1 -
 		BC_WindowBase::get_resources()->listbox_button[0]->get_w();
 	CWindowMaskGUI *gui = preset_dialog->gui;
 	preset_text = new CWindowMaskPresetText(this,
-		x1, y, x2, 120, gui->mask_name->get_text());
+		x1, y, x2, yS(120), gui->mask_name->get_text());
 	preset_text->create_objects();
 	preset_text->set_tooltip(_("Mask name"));
 	preset_text->update_items();
@@ -3240,11 +3771,11 @@ void CWindowMaskPresetText::update_items()
 
 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Del"))
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
-	set_tooltip(_("delete preset"));
+	set_tooltip(_("Delete preset"));
 }
 
 int CWindowMaskDelete::handle_event()
@@ -3260,7 +3791,7 @@ int CWindowMaskDelete::handle_event()
 
 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Center"))
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -3275,7 +3806,7 @@ int CWindowMaskCenter::handle_event()
 
 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
 	CWindowMaskGUI *gui, int x, int y, int w)
- : BC_GenericButton(x, y, w, _("Normal"))
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -3288,12 +3819,14 @@ int CWindowMaskNormal::handle_event()
 }
 
 
-CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui)
- : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
+CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
+		const char *images, int shape, int x, int y, const char *tip)
+ : BC_Button(x, y, mwindow->theme->get_image_set(images))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
-	set_use_button(0);
+	this->shape = shape;
+	set_tooltip(tip);
 }
 
 CWindowMaskShape::~CWindowMaskShape()
@@ -3369,14 +3902,6 @@ void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
 	}
 }
 
-void CWindowMaskShape::load_shape(int i, SubMask *sub_mask)
-{
-	ArrayList<SubMask *> masks;
-	gui->load_masks(masks);
-	sub_mask->copy_from(*masks[i], 0);
-	masks.remove_all_objects();
-}
-
 int CWindowMaskShape::handle_event()
 {
 	MaskAutos *autos;
@@ -3395,20 +3920,15 @@ int CWindowMaskShape::handle_event()
 // Get existing keyframe
 	gui->get_keyframe(track, autos, keyframe,
 			mask, point, create_it);
-	CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
-	if( track && item ) {
+	if( track ) {
 #ifdef USE_KEYFRAME_SPANNING
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
 		keyframe = &temp_keyframe;
 		mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
 #endif
-		int k = item->id;
 		if( mask ) {
-			if( k < MASK_SHAPE_BUILTIN )
-				builtin_shape(k, mask);
-			else
-				load_shape(k-MASK_SHAPE_BUILTIN, mask);
+			builtin_shape(shape, mask);
 #ifdef USE_KEYFRAME_SPANNING
 			autos->update_parameter(keyframe);
 #endif
@@ -3420,22 +3940,6 @@ int CWindowMaskShape::handle_event()
 	return 1;
 }
 
-void CWindowMaskShape::create_objects()
-{
-	shape_items.remove_all_objects();
-	shape_items.append(new CWindowMaskItem(_("square"), MASK_SHAPE_SQUARE));
-	shape_items.append(new CWindowMaskItem(_("circle"), MASK_SHAPE_CIRCLE));
-	shape_items.append(new CWindowMaskItem(_("triangle"), MASK_SHAPE_TRIANGLE));
-	shape_items.append(new CWindowMaskItem(_("oval"), MASK_SHAPE_OVAL));
-	ArrayList<SubMask *> masks;
-	gui->load_masks(masks);
-	int id = MASK_SHAPE_BUILTIN;
-	for( int i=0; i<masks.size(); ++i )
-		shape_items.append(new CWindowMaskItem(masks[i]->name, id++));
-	masks.remove_all_objects();
-	update(&shape_items, 0, 0, 1);
-}
-
 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
 {
         char path[BCTEXTLEN];
@@ -3477,7 +3981,7 @@ void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
 
 
 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), xS(320), yS(240))
 {
 }
 
@@ -3487,28 +3991,30 @@ CWindowRulerGUI::~CWindowRulerGUI()
 
 void CWindowRulerGUI::create_objects()
 {
-	int x = 10, y = 10, x1 = 100;
+	int xs10 = xS(10), xs200 = xS(200);
+	int ys5 = yS(5), ys10 = yS(10);
+	int x = xs10, y = ys10, x1 = xS(100);
 	BC_Title *title;
 
 	lock_window("CWindowRulerGUI::create_objects");
 	add_subwindow(title = new BC_Title(x, y, _("Current:")));
-	add_subwindow(current = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 5;
+	add_subwindow(current = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys5;
 	add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
-	add_subwindow(point1 = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 5;
+	add_subwindow(point1 = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys5;
 	add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
-	add_subwindow(point2 = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 5;
+	add_subwindow(point2 = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys5;
 	add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
-	add_subwindow(deltas = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 5;
+	add_subwindow(deltas = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys5;
 	add_subwindow(title = new BC_Title(x, y, _("Distance:")));
-	add_subwindow(distance = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 5;
+	add_subwindow(distance = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys5;
 	add_subwindow(title = new BC_Title(x, y, _("Angle:")));
-	add_subwindow(angle = new BC_TextBox(x1, y, 200, 1, ""));
-	y += title->get_h() + 10;
+	add_subwindow(angle = new BC_TextBox(x1, y, xs200, 1, ""));
+	y += title->get_h() + ys10;
 	char string[BCTEXTLEN];
 	sprintf(string,
 		 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
@@ -3516,7 +4022,7 @@ void CWindowRulerGUI::create_objects()
 	add_subwindow(title = new BC_Title(x,
 		y,
 		string));
-	y += title->get_h() + 10;
+	y += title->get_h() + ys10;
 	sprintf(string, _("Press Alt to translate the ruler."));
 	add_subwindow(title = new BC_Title(x,
 		y,
@@ -3555,6 +4061,3 @@ void CWindowRulerGUI::handle_event()
 {
 }
 
-
-
-