X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fcwindowtool.C;h=371464e9d4753fbdc701071f027a72945852e9a1;hp=e0e27e4d12d1dedb72c4d58531bd665862745b98;hb=8e67d840c5a93f77de021102a4f0bfc4e07504f4;hpb=2778975bea06a53d8165a5e37bdacde1ae5f3320

diff --git a/cinelerra-5.1/cinelerra/cwindowtool.C b/cinelerra-5.1/cinelerra/cwindowtool.C
index e0e27e4d..371464e9 100644
--- a/cinelerra-5.1/cinelerra/cwindowtool.C
+++ b/cinelerra-5.1/cinelerra/cwindowtool.C
@@ -23,6 +23,7 @@
 
 #include "automation.h"
 #include "bccolors.h"
+#include "bctimer.h"
 #include "clip.h"
 #include "condition.h"
 #include "cpanel.h"
@@ -32,6 +33,8 @@
 #include "cwindowtool.h"
 #include "edl.h"
 #include "edlsession.h"
+#include "file.h"
+#include "filexml.h"
 #include "floatauto.h"
 #include "floatautos.h"
 #include "keys.h"
@@ -46,6 +49,7 @@
 #include "mwindowgui.h"
 #include "theme.h"
 #include "track.h"
+#include "tracks.h"
 #include "trackcanvas.h"
 #include "transportque.h"
 
@@ -179,6 +183,16 @@ void CWindowTool::hide_tool()
 	}
 }
 
+void CWindowTool::raise_tool()
+{
+	if(tool_gui && mwindow->edl->session->tool_window)
+	{
+		tool_gui->lock_window("CWindowTool::show_tool");
+		tool_gui->raise_window();
+		tool_gui->unlock_window();
+	}
+}
+
 
 void CWindowTool::run()
 {
@@ -278,17 +292,13 @@ int CWindowToolGUI::close_event()
 	flush();
 	mwindow->edl->session->tool_window = 0;
 	unlock_window();
-
-
-
 	thread->gui->lock_window("CWindowToolGUI::close_event");
 	thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
 	thread->gui->flush();
 	thread->gui->unlock_window();
-
 	lock_window("CWindowToolGUI::close_event");
 	return 1;
-;}
+}
 
 int CWindowToolGUI::keypress_event()
 {
@@ -325,19 +335,32 @@ int CWindowToolGUI::translation_event()
 }
 
 
+void CWindowToolGUI::update_preview(int changed_edl)
+{
+	unlock_window();
+	draw_preview(changed_edl);
+	lock_window("CWindowToolGUI::update_preview");
+}
 
-
+void CWindowToolGUI::draw_preview(int changed_edl)
+{
+	CWindowGUI *cgui = mwindow->cwindow->gui;
+	cgui->lock_window("CWindowToolGUI::draw_preview");
+	int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
+	cgui->sync_parameters(change_type, 0, 1);
+	cgui->unlock_window();
+}
 
 
 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)
+ : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 70, 3)
 {
 	this->gui = gui;
 	set_log_floatincrement(log_increment);
 }
 
 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)
+ : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 70, 3)
 {
 	this->gui = gui;
 }
@@ -466,9 +489,7 @@ void CWindowCropGUI::handle_event()
  	mwindow->edl->session->crop_y2 = atol(height->get_text()) +
  		mwindow->edl->session->crop_y1;
 	update();
-	mwindow->cwindow->gui->lock_window("CWindowCropGUI::handle_event");
-	mwindow->cwindow->gui->canvas->draw_refresh();
-	mwindow->cwindow->gui->unlock_window();
+	mwindow->cwindow->gui->canvas->redraw(1);
 }
 
 void CWindowCropGUI::update()
@@ -688,10 +709,10 @@ void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAut
 // three automation lines have the same curve mode.
 // For mixed states the toggle stays off.
 	set_value( x->curve_mode == this->cfg.mode &&
-	           y->curve_mode == this->cfg.mode &&
-	           z->curve_mode == this->cfg.mode
-	         ,true // redraw to show new state
-	         );
+		   y->curve_mode == this->cfg.mode &&
+		   z->curve_mode == this->cfg.mode
+		   ,true // redraw to show new state
+		);
 }
 
 int CWindowCurveToggle::handle_event()
@@ -805,15 +826,6 @@ void CWindowCameraGUI::create_objects()
 	unlock_window();
 }
 
-void CWindowCameraGUI::update_preview()
-{
-	CWindowGUI *cgui = mwindow->cwindow->gui;
-	cgui->lock_window("CWindowCameraGUI::update_preview");
-	cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
-	cgui->unlock_window();
-}
-
-
 void CWindowCameraGUI::handle_event()
 {
 	FloatAuto *x_auto = 0;
@@ -1203,14 +1215,6 @@ void CWindowProjectorGUI::create_objects()
 	unlock_window();
 }
 
-void CWindowProjectorGUI::update_preview()
-{
-	CWindowGUI *cgui = mwindow->cwindow->gui;
-	cgui->lock_window("CWindowProjectorGUI::update_preview");
-	cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
-	cgui->unlock_window();
-}
-
 void CWindowProjectorGUI::handle_event()
 {
 	FloatAuto *x_auto = 0;
@@ -1483,164 +1487,359 @@ int CWindowProjectorBottom::handle_event()
 }
 
 
-CWindowMaskMode::CWindowMaskMode(MWindow *mwindow,
-	CWindowToolGUI *gui, int x, int y, const char *text)
- : BC_PopupMenu(x, y, 220, text, 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)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
 }
 
-void CWindowMaskMode::create_objects()
+CWindowMaskOnTrack::~CWindowMaskOnTrack()
 {
-	add_item(new BC_MenuItem(mode_to_text(MASK_MULTIPLY_ALPHA)));
-	add_item(new BC_MenuItem(mode_to_text(MASK_SUBTRACT_ALPHA)));
 }
 
-char* CWindowMaskMode::mode_to_text(int mode)
+int CWindowMaskOnTrack::handle_event()
 {
-	switch(mode)
-	{
-		case MASK_MULTIPLY_ALPHA:
-			return _("Multiply alpha");
-			break;
+	CWindowMaskItem *track_item = 0;
+	int k = get_number(), track_id = -1;
+//printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
+	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();
+	}
+	else
+		track_id = mwindow->cwindow->mask_track_id;
+	set_back_color(track_id >= 0 ?
+		gui->get_resources()->text_background :
+		gui->get_resources()->text_background_disarmed);
+	if( mwindow->cwindow->mask_track_id != track_id )
+		gui->mask_on_track->update(track_item ? track_item->get_text() : "");
+	mwindow->cwindow->mask_track_id = track_id;
+	mwindow->edl->local_session->solo_track_id = -1;
+	gui->mask_solo_track->update(0);
+	gui->update();
+	gui->update_preview(1);
+	return 1;
+}
 
-		case MASK_SUBTRACT_ALPHA:
-			return _("Subtract alpha");
-			break;
+void CWindowMaskOnTrack::update_items()
+{
+	track_items.remove_all_objects();
+	int high_color = gui->get_resources()->button_highlighted;
+	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;
+		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;
+		track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
 	}
+	update_list(&track_items);
+}
 
-	return _("Subtract alpha");
+CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
+		int x, int y)
+ : BC_Tumbler(x, y)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+}
+CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
+{
 }
 
-int CWindowMaskMode::text_to_mode(char *text)
+int CWindowMaskTrackTumbler::handle_up_event()
 {
-	if(!strcasecmp(text, _("Multiply alpha")))
-		return MASK_MULTIPLY_ALPHA;
-	else
-	if(!strcasecmp(text, _("Subtract alpha")))
-		return MASK_SUBTRACT_ALPHA;
+	return do_event(1);
+}
+
+int CWindowMaskTrackTumbler::handle_down_event()
+{
+	return do_event(-1);
+}
+
+int CWindowMaskTrackTumbler::do_event(int dir)
+{
+	CWindowMaskItem *track_item = 0;
+	CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
+	int n = gui->mask_on_track->track_items.size();
+	int id = mwindow->cwindow->mask_track_id;
+	if( n > 0 ) {	
+		int k = n;
+		while( --k >= 0 && items[k]->id != id );
+		if( k >= 0 ) {
+			k += dir;
+			bclamp(k, 0, n-1);
+			track_item = items[k];
+		}
+		else
+			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;
+	gui->mask_on_track->set_back_color(track_id >= 0 ?
+		gui->get_resources()->text_background :
+		gui->get_resources()->text_background_disarmed);
+	gui->mask_on_track->update(track_item ? track_item->get_text() : "");
+	mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
+	mwindow->edl->local_session->solo_track_id = -1;
+	gui->mask_solo_track->update(0);
+	gui->update();
+	gui->update_preview(1);
+	return 1;
+}
+
+
+CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
+		int x, int y, const char *text)
+ : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+}
 
-	return MASK_SUBTRACT_ALPHA;
+CWindowMaskName::~CWindowMaskName()
+{
 }
 
-int CWindowMaskMode::handle_event()
+int CWindowMaskName::handle_event()
 {
+	Track *track;
 	MaskAutos *autos;
 	MaskAuto *keyframe;
-	Track *track;
-	MaskPoint *point;
 	SubMask *mask;
-// Get existing keyframe
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
-	if(track)
-	{
-		mwindow->undo->update_undo_before(_("mask mode"), 0);
+	MaskPoint *point;
+//printf("CWindowMaskGUI::update 1\n");
+	gui->get_keyframe(track, autos, keyframe, mask, point, 0);
+	if( track ) {
+		int k = get_number();
+		if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
+		else mwindow->edl->session->cwindow_mask = k;
+		if( k >= 0 && k < mask_items.size() ) {
+			mask_items[k]->set_text(get_text());
+			update_list(&mask_items);
+		}
 #ifdef USE_KEYFRAME_SPANNING
-// Create temp keyframe
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
-// Update parameter
-		temp_keyframe.mode = text_to_mode(get_text());
-// Commit change to span of keyframes
-		autos->update_parameter(&temp_keyframe);
+		SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
+		memset(submask->name, 0, sizeof(submask->name));
+		strncpy(submask->name, get_text(), sizeof(submask->name)-1);
+		((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
 #else
-		((MaskAuto*)autos->default_auto)->mode =
-			text_to_mode(get_text());
+		for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
+			SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
+			memset(submask->name, 0, sizeof(submask->name));
+			strncpy(submask->name, get_text(), sizeof(submask->name)-1);
+			current = current == (MaskAuto*)autos->default_auto ?
+				(MaskAuto*)autos->first : (MaskAuto*)NEXT;
+		}
 #endif
-		mwindow->undo->update_undo_after(_("mask mode"), LOAD_AUTOMATION);
+		gui->update();
+		gui->update_preview();
+	}
+	return 1;
+}
+
+void CWindowMaskName::update_items(MaskAuto *keyframe)
+{
+	mask_items.remove_all_objects();
+	int sz = !keyframe ? 0 : keyframe->masks.size();
+	for( int i=0; i<SUBMASKS; ++i ) {
+		char text[BCSTRLEN];  memset(text, 0, sizeof(text));
+		if( i < sz ) {
+			SubMask *sub_mask = keyframe->masks.get(i);
+			strncpy(text, sub_mask->name, sizeof(text)-1);
+		}
+		else
+			sprintf(text, "%d", i);
+		mask_items.append(new CWindowMaskItem(text));
 	}
+	update_list(&mask_items);
+}
+
+
+CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
+		 int x, int y, int no, int v)
+ : BC_CheckBox(x, y, v)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	this->no = no;
+}
 
-//printf("CWindowMaskMode::handle_event 1\n");
+CWindowMaskButton::~CWindowMaskButton()
+{
+}
+
+int CWindowMaskButton::handle_event()
+{
+	mwindow->edl->session->cwindow_mask = no;
+	gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
+	gui->update();
 	gui->update_preview();
 	return 1;
 }
 
+CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
+		int x, int y)
+ : BC_Tumbler(x, y)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+}
 
+CWindowMaskThumbler::~CWindowMaskThumbler()
+{
+}
 
+int CWindowMaskThumbler::handle_up_event()
+{
+	return do_event(1);
+}
 
+int CWindowMaskThumbler::handle_down_event()
+{
+	return do_event(-1);
+}
 
+int CWindowMaskThumbler::do_event(int dir)
+{
+	int k = mwindow->edl->session->cwindow_mask;
+	if( (k+=dir) >= SUBMASKS ) k = 0;
+	else if( k < 0 ) k = SUBMASKS-1;
+	mwindow->edl->session->cwindow_mask = k;
+	gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
+	gui->update();
+	gui->update_preview();
+	return 1;
+}
 
+CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
+		 int x, int y, int no, int v)
+ : BC_CheckBox(x, y, v)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	this->no = no;
+}
 
+CWindowMaskEnable::~CWindowMaskEnable()
+{
+}
 
-CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
-	CWindowToolGUI *gui,
-	int x,
-	int y)
+int CWindowMaskEnable::handle_event()
+{
+	Track *track = mwindow->cwindow->calculate_mask_track();
+	if( track ) {
+		mwindow->undo->update_undo_before(_("mask enable"), this);
+		int bit = 1 << no;
+		if( get_value() )
+			track->masks |= bit;
+		else
+			track->masks &= ~bit;
+		gui->update();
+		gui->update_preview(1);
+		mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
+	}
+	return 1;
+}
+
+CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Show/Hide mask"));
+}
+
+int CWindowMaskUnclear::handle_event()
+{
+	Track *track = mwindow->cwindow->calculate_mask_track();
+	if( track ) {
+		mwindow->undo->update_undo_before(_("mask enables"), this);
+		int m = (1<<SUBMASKS)-1;
+		if( track->masks == m )
+			track->masks = 0;
+		else
+			track->masks = m;
+		for( int i=0; i<SUBMASKS; ++i )
+			gui->mask_enables[i]->update((track->masks>>i) & 1);
+		gui->update_preview(1);
+		mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
+	}
+	return 1;
+}
+
+CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y, int v)
+ : BC_CheckBox(x, y, v, _("Solo"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Solo video track"));
+}
+
+int CWindowMaskSoloTrack::handle_event()
+{
+	mwindow->edl->local_session->solo_track_id =
+		get_value() ? mwindow->cwindow->mask_track_id : -1;
+	gui->update_preview(1);
+	return 1;
+}
+
+int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
+{
+	int w = 0, h = 0;
+	calculate_extents(gui, &w, &h, _("Solo"));
+	return w;
+}
+
+CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y)
  : BC_GenericButton(x, y, _("Delete"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
+	set_tooltip(_("Delete mask"));
 }
 
-int CWindowMaskDelete::handle_event()
+int CWindowMaskDelMask::handle_event()
 {
 	MaskAutos *autos;
 	MaskAuto *keyframe;
 	Track *track;
 	MaskPoint *point;
 	SubMask *mask;
-	int total_points = 0;
+	int total_points;
 
 // Get existing keyframe
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
+	gui->get_keyframe(track, autos, keyframe, mask, point, 0);
 
-	if(track)
-	{
+	if( track ) {
 		mwindow->undo->update_undo_before(_("mask delete"), 0);
 
 #ifdef USE_KEYFRAME_SPANNING
 // Create temp keyframe
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
-// Update parameter
 		SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
-		if( shift_down() )
-			submask->points.remove_all_objects();
-
-		for(int i = mwindow->cwindow->gui->affected_point;
-			i < submask->points.total - 1;
-			i++)
-		{
-			*submask->points.values[i] = *submask->points.values[i + 1];
-		}
-
-		if(submask->points.total)
-		{
-			submask->points.remove_object(
-				submask->points.values[submask->points.total - 1]);
-		}
-		total_points = submask->points.total;
-
+		submask->points.remove_all_objects();
+		total_points = 0;
 // Commit change to span of keyframes
 		((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
 #else
-		for(MaskAuto *current = (MaskAuto*)autos->default_auto;
-			current; )
-		{
+		for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
 			SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
-			if( shift_down() )
-				submask->points.remove_all_objects();
-
-			for(int i = mwindow->cwindow->gui->affected_point;
-				i < submask->points.total - 1;
-				i++)
-			{
-				*submask->points.values[i] = *submask->points.values[i + 1];
-			}
-
-			if(submask->points.total)
-			{
-				submask->points.remove_object(
-					submask->points.values[submask->points.total - 1]);
-			}
-			total_points = submask->points.total;
-
-			if(current == (MaskAuto*)autos->default_auto)
-				current = (MaskAuto*)autos->first;
-			else
-				current = (MaskAuto*)NEXT;
+			submask->points.remove_all_objects();
+			current = current == (MaskAuto*)autos->default_auto ?
+				(MaskAuto*)autos->first : (MaskAuto*)NEXT;
 		}
+		total_points = 0;
 #endif
 		if( mwindow->cwindow->gui->affected_point >= total_points )
 			mwindow->cwindow->gui->affected_point =
@@ -1651,130 +1850,84 @@ int CWindowMaskDelete::handle_event()
 		mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
 	}
 
-
 	return 1;
 }
 
-int CWindowMaskDelete::keypress_event()
+CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y)
+ : BC_GenericButton(x, y, _("Delete"))
 {
-	if(get_keypress() == BACKSPACE ||
-		get_keypress() == DELETE)
-		return handle_event();
-	return 0;
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Delete point"));
 }
 
+int CWindowMaskDelPoint::handle_event()
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
+	int total_points;
 
-// CWindowMaskCycleNext::CWindowMaskCycleNext(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
-//  : BC_GenericButton(x, y, _("Cycle next"))
-// {
-// 	this->mwindow = mwindow;
-// 	this->gui = gui;
-// }
-// int CWindowMaskCycleNext::handle_event()
-// {
-// 	MaskAuto *keyframe;
-//	MaskAutos *autos;
-// 	Track *track;
-// 	MaskPoint *point;
-// 	SubMask *mask;
-// 	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
-//
-// 	MaskPoint *temp;
-//
-// // Should apply to all keyframes
-// 	if(keyframe && mask->points.total)
-// 	{
-// 		temp = mask->points.values[0];
-//
-// 		for(int i = 0; i < mask->points.total - 1; i++)
-// 		{
-// 			mask->points.values[i] = mask->points.values[i + 1];
-// 		}
-// 		mask->points.values[mask->points.total - 1] = temp;
-//
-// 		mwindow->cwindow->gui->affected_point--;
-// 		if(mwindow->cwindow->gui->affected_point < 0)
-// 			mwindow->cwindow->gui->affected_point = mask->points.total - 1;
-//
-// 		gui->update();
-// 		gui->update_preview();
-// 	}
-//
-// 	return 1;
-// }
-//
-// CWindowMaskCyclePrev::CWindowMaskCyclePrev(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
-//  : BC_GenericButton(x, y, _("Cycle prev"))
-// {
-// 	this->mwindow = mwindow;
-// 	this->gui = gui;
-// }
-// int CWindowMaskCyclePrev::handle_event()
-// {
-// 	MaskAuto *keyframe;
-//	MaskAutos *autos;
-// 	Track *track;
-// 	MaskPoint *point;
-// 	SubMask *mask;
-// 	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
-//
-// // Should apply to all keyframes
-// 	MaskPoint *temp;
-// 	if(keyframe && mask->points.total)
-// 	{
-// 		temp = mask->points.values[mask->points.total - 1];
-//
-// 		for(int i = mask->points.total - 1; i > 0; i--)
-// 		{
-// 			mask->points.values[i] = mask->points.values[i - 1];
-// 		}
-// 		mask->points.values[0] = temp;
-//
-// 		mwindow->cwindow->gui->affected_point++;
-// 		if(mwindow->cwindow->gui->affected_point >= mask->points.total)
-// 			mwindow->cwindow->gui->affected_point = 0;
-//
-// 		gui->update();
-// 		gui->update_preview();
-// 	}
-// 	return 1;
-// }
+// Get existing keyframe
+	gui->get_keyframe(track, autos, keyframe, mask, point, 0);
+	if( track ) {
+		mwindow->undo->update_undo_before(_("point delete"), 0);
 
+#ifdef USE_KEYFRAME_SPANNING
+// Create temp keyframe
+		MaskAuto temp_keyframe(mwindow->edl, autos);
+		temp_keyframe.copy_data(keyframe);
+// Update parameter
+		SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
+		int i = mwindow->cwindow->gui->affected_point;
+		for( ; i<submask->points.total-1; ++i )
+			*submask->points.values[i] = *submask->points.values[i+1];
+		if( submask->points.total > 0 ) {
+			point = submask->points.values[submask->points.total-1];
+			submask->points.remove_object(point);
+		}
+		total_points = submask->points.total;
 
-CWindowMaskNumber::CWindowMaskNumber(MWindow *mwindow,
-	CWindowToolGUI *gui,
-	int x,
-	int y)
- : BC_TumbleTextBox(gui,
-		(int64_t)mwindow->edl->session->cwindow_mask,
-		(int64_t)0,
-		(int64_t)SUBMASKS - 1,
-		x,
-		y,
-		100)
-{
-	this->mwindow = mwindow;
-	this->gui = gui;
-}
+// Commit change to span of keyframes
+		((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
+#else
+		total_points = 0;
+		MaskAuto *current = (MaskAuto*)autos->default_auto;
+		while( current ) {
+			SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
+			int i = mwindow->cwindow->gui->affected_point;
+			for( ; i<submask->points.total-1; ++i )
+				*submask->points.values[i] = *submask->points.values[i+1];
+			if( submask->points.total > 0 ) {
+				point = submask->points.values[submask->points.total-1];
+				submask->points.remove_object(point);
+			}
+			total_points = submask->points.total;
+			current = current == (MaskAuto*)autos->default_auto ?
+				(MaskAuto*)autos->first : (MaskAuto*)NEXT;
+		}
+#endif
+		if( mwindow->cwindow->gui->affected_point >= total_points )
+			mwindow->cwindow->gui->affected_point =
+				total_points > 0 ? total_points-1 : 0;
 
-CWindowMaskNumber::~CWindowMaskNumber()
-{
-}
+		gui->update();
+		gui->update_preview();
+		mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
+	}
 
-int CWindowMaskNumber::handle_event()
-{
-	mwindow->edl->session->cwindow_mask = atol(get_text());
-	gui->update();
-	gui->update_preview();
 	return 1;
 }
 
 
 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
-	CWindowToolGUI *gui, int x, int y)
+	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, 70)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
@@ -1788,7 +1941,7 @@ int CWindowMaskAffectedPoint::handle_event()
 {
 	int total_points = 0;
 	int affected_point = atol(get_text());
-	Track *track = mwindow->cwindow->calculate_affected_track();
+	Track *track = mwindow->cwindow->calculate_mask_track();
 	if(track) {
 		MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
 		MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
@@ -1800,7 +1953,7 @@ int CWindowMaskAffectedPoint::handle_event()
 	int active_point = affected_point;
 	if( affected_point >= total_points )
 		affected_point = total_points - 1;
-	else if( affected_point < 0 )
+	if( affected_point < 0 )
 		affected_point = 0;
 	if( active_point != affected_point )
 		update((int64_t)affected_point);
@@ -1811,31 +1964,141 @@ int CWindowMaskAffectedPoint::handle_event()
 }
 
 
-
-
-
-CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
- : BC_TumbleTextBox(gui,
-		(int64_t)0,
-		(int64_t)0,
-		(int64_t)0xff,
-		x,
-		y,
-		100)
+CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, gui->focused, _("Focus"))
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
+	set_tooltip(_("Center for rotate/scale"));
 }
-CWindowMaskFeather::~CWindowMaskFeather()
+
+CWindowMaskFocus::~CWindowMaskFocus()
 {
 }
-int CWindowMaskFeather::handle_event()
+
+int CWindowMaskFocus::handle_event()
 {
-	MaskAutos *autos;
-	MaskAuto *keyframe;
-	Track *track;
-	MaskPoint *point;
-	SubMask *mask;
+ 	gui->focused = get_value();
+	gui->update();
+	gui->update_preview();
+	return 1;
+}
+
+int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
+{
+	int w, h;
+	calculate_extents(gui, &w, &h, _("Focus"));
+	return w;
+}
+
+CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
+		int x, int y, VFrame **data, int v, int id, const char *tip)
+ : BC_Toggle(x, y, data, v)
+{
+	this->id = id;
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(tip);
+}
+
+CWindowMaskScaleXY::~CWindowMaskScaleXY()
+{
+}
+
+int CWindowMaskScaleXY::handle_event()
+{
+	gui->scale_mode = id;
+	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;
+}
+
+CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, 0, _("Help"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Show help text"));
+}
+
+CWindowMaskHelp::~CWindowMaskHelp()
+{
+}
+
+int CWindowMaskHelp::handle_event()
+{
+	gui->helped = get_value();
+	gui->resize_window(gui->get_w(),
+		gui->helped ? gui->help_h : gui->help_y);
+	gui->update();
+	return 1;
+}
+
+CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, gui->markers, _("Markers"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip("Display points");
+}
+
+CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
+{
+}
+
+int CWindowMaskDrawMarkers::handle_event()
+{
+	gui->markers = get_value();
+	gui->update();
+	gui->update_preview();
+	return 1;
+}
+
+CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip("Display mask outline");
+}
+
+CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
+{
+}
+
+int CWindowMaskDrawBoundary::handle_event()
+{
+	gui->boundary = get_value();
+	gui->update();
+	gui->update_preview();
+	return 1;
+}
+
+
+CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, 64, 2)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+}
+CWindowMaskFeather::~CWindowMaskFeather()
+{
+}
+
+int CWindowMaskFeather::update(float v)
+{
+	gui->feather_slider->update(v);
+	return BC_TumbleTextBox::update(v);
+}
+
+int CWindowMaskFeather::update_value(float v)
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
 #ifdef USE_KEYFRAME_SPANNING
 	int create_it = 0;
 #else
@@ -1845,23 +2108,27 @@ int CWindowMaskFeather::handle_event()
 	mwindow->undo->update_undo_before(_("mask feather"), this);
 
 // Get existing keyframe
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
+	gui->get_keyframe(track, autos, keyframe,
 			mask, point, create_it);
-
-	if(track)
-	{
+	if( track ) {
+		int gang = gui->gang_feather->get_value();
 #ifdef USE_KEYFRAME_SPANNING
-// Create temp keyframe
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
-// Update parameter
-		temp_keyframe.feather = atof(get_text());
-// Commit change to span of keyframes
-		autos->update_parameter(&temp_keyframe);
-#else
-		keyframe->feather = atof(get_text());
+		keyframe = &temp_keyframe;
+#endif
+		float change = v - mask->feather;
+		int k = mwindow->edl->session->cwindow_mask;
+		int n = gang ? keyframe->masks.size() : k+1;
+		for( int i=gang? 0 : k; i<n; ++i ) {
+			if( !gui->mask_enables[i]->get_value() ) continue;
+			SubMask *sub_mask = keyframe->get_submask(i);
+			float feather = sub_mask->feather + change;
+			sub_mask->feather = feather;
+		}
+#ifdef USE_KEYFRAME_SPANNING
+		autos->update_parameter(keyframe);
 #endif
-
 		gui->update_preview();
 	}
 
@@ -1869,26 +2136,88 @@ int CWindowMaskFeather::handle_event()
 	return 1;
 }
 
+int CWindowMaskFeather::handle_event()
+{
+	float v = atof(get_text());
+	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-5, FEATHER_MAX+5, v)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_precision(0.01);
+	timer = new Timer();
+	stick = 0;
+	last_v = 0;
+	max = FEATHER_MAX;
+}
+
+CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
+{
+	delete timer;
+}
+
+int CWindowMaskFeatherSlider::handle_event()
+{
+	int sticky = 0;
+	float v = get_value();
+	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;
+		}
+		if( last_v ) {
+			max *= 1.25;
+			update(get_w(), v=last_v, -max-5, max+5);
+			button_release_event();
+		}
+	}
+	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)
+{
+	float vv = fabsf(v);
+	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);
+}
 
-CWindowMaskValue::CWindowMaskValue(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
- : BC_ISlider(x,
-			y,
-			0,
-			200,
-			200,
-			0,
-			100,
-			0)
+CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
+ : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
 {
 	this->mwindow = mwindow;
 	this->gui = gui;
 }
+CWindowMaskFade::~CWindowMaskFade()
+{
+}
 
-CWindowMaskValue::~CWindowMaskValue()
+int CWindowMaskFade::update(float v)
 {
+	gui->fade_slider->update(v);
+	return BC_TumbleTextBox::update(v);
 }
 
-int CWindowMaskValue::handle_event()
+int CWindowMaskFade::update_value(float v)
 {
 	MaskAutos *autos;
 	MaskAuto *keyframe;
@@ -1901,36 +2230,164 @@ int CWindowMaskValue::handle_event()
 	int create_it = 1;
 #endif
 
-	mwindow->undo->update_undo_before(_("mask value"), this);
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
-		mask, point, create_it);
+	mwindow->undo->update_undo_before(_("mask fade"), this);
 
-	if(track)
-	{
+// Get existing keyframe
+	gui->get_keyframe(track, autos, keyframe,
+			mask, point, create_it);
+	if( track ) {
+		int gang = gui->gang_fader->get_value();
 #ifdef USE_KEYFRAME_SPANNING
-// Create temp keyframe
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
-// Update parameter
-		temp_keyframe.value = get_value();
-// Commit change to span of keyframes
-		autos->update_parameter(&temp_keyframe);
-#else
-		keyframe->value = get_value();
+		keyframe = &temp_keyframe;
+#endif
+		float change = v - mask->fader;
+		int k = mwindow->edl->session->cwindow_mask;
+		int n = gang ? keyframe->masks.size() : k+1;
+		for( int i=gang? 0 : k; i<n; ++i ) {
+			if( !gui->mask_enables[i]->get_value() ) continue;
+			SubMask *sub_mask = keyframe->get_submask(i);
+			float fader = sub_mask->fader + change;
+			bclamp(fader, -100.f, 100.f);
+			sub_mask->fader = fader;
+		}
+#ifdef USE_KEYFRAME_SPANNING
+		autos->update_parameter(keyframe);
 #endif
+		gui->update_preview();
 	}
 
-	gui->update_preview();
-	mwindow->undo->update_undo_after(_("mask value"), LOAD_AUTOMATION);
+	mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
+	return 1;
+}
+
+int CWindowMaskFade::handle_event()
+{
+	float v = atof(get_text());
+	gui->fade_slider->update(v);
+	return gui->fade->update_value(v);
+}
+
+CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
+		int x, int y, int w)
+ : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	timer = new Timer();
+	stick = 0;
+	last_v = 0;
+}
+
+CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
+{
+	delete timer;
+}
+
+int CWindowMaskFadeSlider::handle_event()
+{
+	float v = 100*get_value()/200;
+	if( stick > 0 ) {
+		int64_t ms = timer->get_difference();
+		if( ms < 250 && --stick > 0 ) {
+			if( get_value() == 0 ) return 1;
+			update(v = 0);
+		}
+		else {
+			stick = 0;
+			last_v = v;
+		}
+	}
+	else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
+		stick = 16;
+		v = 0;
+	}
+	else
+		last_v = v;
+	timer->update();
+	gui->fade->BC_TumbleTextBox::update(v);
+	return gui->fade->update_value(v);
+}
+
+int CWindowMaskFadeSlider::update(int64_t v)
+{
+	return BC_ISlider::update(200*v/100);
+}
+
+CWindowMaskGangFader::CWindowMaskGangFader(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 fader"));
+}
+
+CWindowMaskGangFader::~CWindowMaskGangFader()
+{
+}
+
+int CWindowMaskGangFader::handle_event()
+{
+	return 1;
+}
+
+CWindowMaskGangFocus::CWindowMaskGangFocus(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 rotate/scale/translate"));
+}
+
+CWindowMaskGangFocus::~CWindowMaskGangFocus()
+{
+}
+
+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;
 }
 
 
-CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowToolGUI *gui, int x, int y)
- : BC_CheckBox(x,
- 	y,
-	1,
-	_("Apply mask before plugins"))
+CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
+		const char *tip, int type, int on, int x, int y, const char *images)
+ : BC_Button(x, y, mwindow->theme->get_image_set(images))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	this->type = type;
+	this->on = on;
+	set_tooltip(tip);
+}
+
+int CWindowMaskSmoothButton::handle_event()
+{
+	return gui->smooth_mask(type, on);
+}
+
+CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
 {
 	this->gui = gui;
 }
@@ -1942,17 +2399,25 @@ int CWindowMaskBeforePlugins::handle_event()
 	MaskAuto *keyframe;
 	SubMask *mask;
 	MaskPoint *point;
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
+	gui->get_keyframe(track, autos, keyframe, mask, point, 1);
 
 	if (keyframe) {
-		keyframe->apply_before_plugins = get_value();
+		int v = get_value();
+#ifdef USE_KEYFRAME_SPANNING
+		MaskAuto temp_keyframe(gui->mwindow->edl, autos);
+		temp_keyframe.copy_data(keyframe);
+		temp_keyframe.apply_before_plugins = v;
+		autos->update_parameter(&temp_keyframe);
+#else
+		keyframe->apply_before_plugins = v;
+#endif
 		gui->update_preview();
 	}
 	return 1;
 }
 
 
-CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowToolGUI *gui, int x, int y)
+CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
  : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
 {
 	this->gui = gui;
@@ -1965,136 +2430,333 @@ int CWindowDisableOpenGLMasking::handle_event()
 	MaskAuto *keyframe;
 	SubMask *mask;
 	MaskPoint *point;
-	((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
+	gui->get_keyframe(track, autos, keyframe, mask, point, 1);
 
-	if (keyframe) {
-		keyframe->disable_opengl_masking = get_value();
+	if( keyframe ) {
+		int v = get_value();
+#ifdef USE_KEYFRAME_SPANNING
+		MaskAuto temp_keyframe(gui->mwindow->edl, autos);
+		temp_keyframe.copy_data(keyframe);
+		temp_keyframe.disable_opengl_masking = v;
+		autos->update_parameter(&temp_keyframe);
+#else
+		keyframe->disable_opengl_masking = v;
+#endif
 		gui->update_preview();
 	}
 	return 1;
 }
 
 
+CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
+		CWindowMaskGUI *gui, int x, int y)
+ : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Delete all masks"));
+}
+
+CWindowMaskClrMask::~CWindowMaskClrMask()
+{
+}
+
+int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
+{
+	VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
+	return vfrm->get_w();
+}
+
+int CWindowMaskClrMask::handle_event()
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
 
+// Get existing keyframe
+	gui->get_keyframe(track, autos, keyframe, mask, point, 0);
 
+	if( track ) {
+		mwindow->undo->update_undo_before(_("del masks"), 0);
+		((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
+		mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
+	}
 
+	gui->update();
+	gui->update_preview(1);
+	return 1;
+}
 
+CWindowMaskGangFeather::CWindowMaskGangFeather(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 feather"));
+}
 
+CWindowMaskGangFeather::~CWindowMaskGangFeather()
+{
+}
 
+int CWindowMaskGangFeather::handle_event()
+{
+	return 1;
+}
 
 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
  : CWindowToolGUI(mwindow, thread,
-	_(PROGRAM_NAME ": Mask"), 330, 320)
+	_(PROGRAM_NAME ": Mask"), 440, 700)
 {
 	this->mwindow = mwindow;
 	this->thread = thread;
-	number = 0;
 	active_point = 0;
+	fade = 0;
 	feather = 0;
+	focused = 0;
+	scale_mode = 2;
+	markers = 1;
+	boundary = 1;
+	preset_dialog = 0;
 }
 CWindowMaskGUI::~CWindowMaskGUI()
 {
 	lock_window("CWindowMaskGUI::~CWindowMaskGUI");
-	delete number;
+	done_event();
 	delete active_point;
+	delete fade;
 	delete feather;
 	unlock_window();
+	delete preset_dialog;
 }
 
 void CWindowMaskGUI::create_objects()
 {
-	int x = 10, y = 10, margin = mwindow->theme->widget_border;
-	//MaskAuto *keyframe = 0;
-	//Track *track = mwindow->cwindow->calculate_affected_track();
-	//if(track)
-	//	keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(track->automation->autos[AUTOMATION_MASK], 0);
+	Theme *theme = mwindow->theme;
+	int x = 10, y = 10, margin = theme->widget_border, t[SUBMASKS];
+	int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
+	int clr_x = get_w()-x - clr_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")));
+	y += title_bar->get_h() + margin;
 	BC_Title *title;
-	add_subwindow(title = new BC_Title(x, y, _("Mode:")));
-	add_subwindow(mode = new CWindowMaskMode(mwindow,
-		this, x + title->get_w() + margin, y, ""));
-	mode->create_objects();
-	y += mode->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Value:")));
-	add_subwindow(value = new CWindowMaskValue(mwindow, this, x + title->get_w() + margin, y));
-	y += value->get_h() + margin;
-	add_subwindow(delete_point = new CWindowMaskDelete(mwindow, this, x, y));
-	int x1 = x + delete_point->get_w() + 2*margin;
-	add_subwindow(title = new BC_Title(x1, y, _("Point:")));
-	x1 += title->get_w() + margin;
-	active_point = new CWindowMaskAffectedPoint(mwindow, this, x1, y);
-	active_point->create_objects();
-	y += delete_point->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Mask number:")));
-	number = new CWindowMaskNumber(mwindow,
-		this, x + title->get_w() + margin, y);
-	number->create_objects();
-	y += number->get_h() + margin;
+	add_subwindow(title = new BC_Title(x,y, _("Track:")));
+	int x1 = x + 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->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;
+	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")));
+	y += title_bar->get_h() + margin;
+	add_subwindow(title = new BC_Title(x, y, _("Mask:")));
+	mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
+	mask_name->create_objects();
+	mask_name->set_tooltip(_("Mask name"));
+	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;
+	BC_Bar *bar;
+//	add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
+//	y += bar->get_h() + 2*margin;
+
+	add_subwindow(title = new BC_Title(x, y, _("Select:")));
+	int bw = 0, bh = 0;
+	BC_CheckBox::calculate_extents(this, &bw, &bh);
+	for( int i=0; i<SUBMASKS; ++i ) {
+		int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
+		mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
+		add_subwindow(mask_buttons[i]);
+	}
+	add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
+	y += bh + margin;
+	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(t[i]+tx, y, text);
+		add_subwindow(mask_blabels[i]);
+	}
+	y += mask_blabels[0]->get_h() + margin;
+	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]);
+	}
+	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, _("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, 80));
+	add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, 80));
+	add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, 80));
+	y += mask_load->get_h() + 2*margin;
+	add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Position & Scale")));
+	y += title_bar->get_h() + 2*margin;
+	add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, 80));
+	add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, 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, 20, 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);
+	fade->create_objects();
+	x2 = x1 + fade->get_w() + 2*margin;
+	int w2 = clr_x-2*margin - x2;
+	add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
+	add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
+	y += fade->get_h() + margin;
 	add_subwindow(title = new BC_Title(x, y, _("Feather:")));
-	feather = new CWindowMaskFeather(mwindow,
-		this, x + title->get_w() + margin, y);
+	feather = new CWindowMaskFeather(mwindow, this, x1, y);
 	feather->create_objects();
-	y += feather->get_h() + margin;
+	w2 = clr_x - 2*margin - x2;
+	feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
+	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")));
+	y += title_bar->get_h() + margin;
+
+	add_subwindow(title = new BC_Title(x, y, _("Point:")));
+	active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
+	active_point->create_objects();
+// typ=0, this mask, this point
+	add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
+		_("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
+	add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
+		_("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:"));
-	x += title->get_w() + margin;
-	this->x = new CWindowCoord(this, x, y, (float)0.0);
+	this->x = new CWindowCoord(this, t[0], y, (float)0.0);
 	this->x->create_objects();
-	x += this->x->get_w() + margin;
+// typ>0, this mask, all points
+	add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
+		_("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
+	add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
+		_("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:"));
-	x += title->get_w() + margin;
-	this->y = new CWindowCoord(this, x, y, (float)0.0);
+	this->y = new CWindowCoord(this, x1, y, (float)0.0);
 	this->y->create_objects();
+// typ<0, all masks, all points
+	add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
+		_("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
+	add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
+		_("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")));
+	y += title_bar->get_h() + margin;
 
-	x = 10;
-	y += this->y->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Press Shift to move an end point")));
-	y += title->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Press Ctrl to move a control point")));
-	y += title->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Shift+click Delete to delete the mask")));
-	y += title->get_h() + margin;
-	add_subwindow(title = new BC_Title(x, y, _("Press Alt to translate the mask")));
-	y += 30;
-
+	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();
+	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();
+	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));
-	y += this->apply_before_plugins->get_h() + margin;
+	y += this->apply_before_plugins->get_h();
 	add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
-
+	add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
+	y += this->disable_opengl_masking->get_h() + 2*margin;
+	help_y = y;
+	add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
+	y += bar->get_h() + 2*margin;
+	add_subwindow(title = new BC_Title(x, y, _(
+		"Shift+LMB: move an end point\n"
+		"Ctrl+LMB: move a control point\n"
+		"Alt+LMB: to drag translate the mask\n"
+		"Shift+MMB: Set Pivot Point at pointer\n"
+		"Wheel: rotate around Pivot Point\n"
+		"Shift+Wheel: scale around Pivot Point\n"
+		"Ctrl+Wheel: rotate/scale around pointer")));
+	help_h = y + title->get_h() + 2*margin;
 	update();
+	resize_window(get_w(), help_y);
 	unlock_window();
 }
 
-void CWindowMaskGUI::get_keyframe(Track* &track,
-	MaskAutos* &autos,
-	MaskAuto* &keyframe,
-	SubMask* &mask,
-	MaskPoint* &point,
-	int create_it)
+int CWindowMaskGUI::close_event()
 {
-	autos = 0;
-	keyframe = 0;
+	done_event();
+	return CWindowToolGUI::close_event();
+}
 
-	track = mwindow->cwindow->calculate_affected_track();
-	if(track)
-	{
+void CWindowMaskGUI::done_event()
+{
+	if( mwindow->in_destructor ) return;
+	int &solo_track_id = mwindow->edl->local_session->solo_track_id;
+	if( solo_track_id >= 0 ) {
+		solo_track_id = -1;
+		update_preview();
+	}
+}
+
+void CWindowMaskGUI::get_keyframe(Track* &track,
+		MaskAutos* &autos, MaskAuto* &keyframe,
+		SubMask* &mask, MaskPoint* &point, int create_it)
+{
+	autos = 0;
+	keyframe = 0;
+
+	track = mwindow->cwindow->calculate_mask_track();
+	if( !track )
+		track = mwindow->cwindow->calculate_affected_track();
+		
+	if(track) {
 		autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
 		keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
 			autos,
 			create_it);
 	}
 
-	if(keyframe)
-		mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
-	else
-		mask = 0;
+	mask = !keyframe ? 0 :
+		keyframe->get_submask(mwindow->edl->session->cwindow_mask);
 
 	point = 0;
-	if(keyframe)
-	{
-		if(mwindow->cwindow->gui->affected_point < mask->points.total &&
-			mwindow->cwindow->gui->affected_point >= 0)
-		{
+	if( keyframe ) {
+		if( mwindow->cwindow->gui->affected_point < mask->points.total &&
+			mwindow->cwindow->gui->affected_point >= 0 ) {
 			point = mask->points.values[mwindow->cwindow->gui->affected_point];
 		}
 	}
@@ -2109,103 +2771,771 @@ void CWindowMaskGUI::update()
 	MaskPoint *point;
 //printf("CWindowMaskGUI::update 1\n");
 	get_keyframe(track, autos, keyframe, mask, point, 0);
-
-	double position = mwindow->edl->local_session->get_selectionstart(1);
-	position = mwindow->edl->align_to_frame(position, 0);
-	if(track)
-	{
+	mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
+	mask_on_track->set_back_color(!track || track->record ?
+		get_resources()->text_background :
+		get_resources()->text_background_disarmed);
+	mask_on_track->update_items();
+	mask_on_track->update(!track ? "" : track->title);
+	mask_name->update_items(keyframe);
+	const char *text = "";
+	int sz = !keyframe ? 0 : keyframe->masks.size();
+	int k = mwindow->edl->session->cwindow_mask;
+	if( k >= 0 && k < sz )
+		text = keyframe->masks[k]->name;
+	else
+		k = mwindow->edl->session->cwindow_mask = 0;
+	mask_name->update(text);
+	update_buttons(keyframe, k);
+	if( point ) {
+		x->update(point->x);
+		y->update(point->y);
+	}
+	if( track ) {
+		double position = mwindow->edl->local_session->get_selectionstart(1);
 		int64_t position_i = track->to_units(position, 0);
+		feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
+		fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
+		int show_mask = track->masks;
+		for( int i=0; i<SUBMASKS; ++i )
+			mask_enables[i]->update((show_mask>>i) & 1);
+	}
+	if( keyframe ) {
+		apply_before_plugins->update(keyframe->apply_before_plugins);
+		disable_opengl_masking->update(keyframe->disable_opengl_masking);
+	}
+	active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
+}
 
-		if(point)
-		{
-			x->update(point->x);
-			y->update(point->y);
+void CWindowMaskGUI::handle_event()
+{
+	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);
+// Get affected point in temp keyframe
+			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);
+#endif
 		}
+		mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
+		redraw = 1;
+	}
 
-		if(mask)
-		{
-			feather->update((int64_t)autos->get_feather(position_i, PLAY_FORWARD));
-			value->update((int64_t)autos->get_value(position_i, PLAY_FORWARD));
-			apply_before_plugins->update((int64_t)keyframe->apply_before_plugins);
-			disable_opengl_masking->update((int64_t)keyframe->disable_opengl_masking);
+	if( redraw )
+		update_preview();
+}
+
+void CWindowMaskGUI::set_focused(int v, float cx, float cy)
+{
+	CWindowGUI *cgui = mwindow->cwindow->gui;
+	cgui->unlock_window();
+	lock_window("CWindowMaskGUI::set_focused");
+	if( focused != v )
+		focus->update(focused = v);
+	focus_x->update(cx);
+	focus_y->update(cy);
+	unlock_window();
+	cgui->lock_window("CWindowCanvas::set_focused");
+}
+
+void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
+{
+	int text_color = get_resources()->default_text_color;
+	int high_color = get_resources()->button_highlighted;
+	for( int i=0; i<SUBMASKS; ++i ) {
+		int color = text_color;
+		if( keyframe ) {
+			SubMask *submask = keyframe->get_submask(i);
+			if( submask && submask->points.size() )
+				color = high_color;
 		}
+		mask_blabels[i]->set_color(color);
+		mask_buttons[i]->update(i==k ? 1 : 0);
 	}
+}
 
-//printf("CWindowMaskGUI::update 1\n");
-	active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
-	number->update((int64_t)mwindow->edl->session->cwindow_mask);
-
-//printf("CWindowMaskGUI::update 1\n");
-	if(track)
-	{
+// typ=0, this mask, this point
+// typ>0, this mask, all points
+// typ<0, all masks, all points
+// dxy= on? pt[+1]-pt[-1] : dxy=0
+int CWindowMaskGUI::smooth_mask(int typ, int on)
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
 #ifdef USE_KEYFRAME_SPANNING
-		mode->set_text(
-			CWindowMaskMode::mode_to_text(keyframe->mode));
+	int create_it = 0;
 #else
-		mode->set_text(
-			CWindowMaskMode::mode_to_text(((MaskAuto*)autos->default_auto)->mode));
+	int create_it = 1;
+#endif
+
+	mwindow->undo->update_undo_before(_("mask smooth"), this);
+
+// Get existing keyframe
+	get_keyframe(track, autos, keyframe,
+			mask, point, create_it);
+	if( track ) {
+#ifdef USE_KEYFRAME_SPANNING
+		MaskAuto temp_keyframe(mwindow->edl, autos);
+		temp_keyframe.copy_data(keyframe);
+		keyframe = &temp_keyframe;
+#endif
+		int k = mwindow->edl->session->cwindow_mask;
+		int n = typ>=0 ? k+1 : keyframe->masks.size();
+		for( int j=typ<0? 0 : k; j<n; ++j ) {
+			if( !mask_enables[j]->get_value() ) continue;
+			SubMask *sub_mask = keyframe->get_submask(j);
+			MaskPoints &points = sub_mask->points;
+			int psz = points.size();
+			if( psz < 3 ) continue;
+			int l = mwindow->cwindow->gui->affected_point;
+			if( l > psz ) l = psz;
+			int m = typ ? psz : l+1;
+			for( int i=typ ? 0 : l; i<m; ++i ) {
+				int i0 = i-1, i1 = i+1;
+				if( i0 < 0 ) i0 = psz-1;
+				if( i1 >= psz ) i1 = 0;
+				MaskPoint *p0 = points[i0];
+				MaskPoint *p  = points[i];
+				MaskPoint *p1 = points[i1];
+				float dx = !on ? 0 : p1->x - p0->x;
+				float dy = !on ? 0 : p1->y - p0->y;
+				p->control_x1 = -dx/4;  p->control_y1 = -dy/4;
+				p->control_x2 =  dx/4;  p->control_y2 =  dy/4;
+			}
+		}
+#ifdef USE_KEYFRAME_SPANNING
+		autos->update_parameter(keyframe);
 #endif
+		update_preview();
 	}
-//printf("CWindowMaskGUI::update 2\n");
+
+	mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
+	return 1;
 }
 
-void CWindowMaskGUI::handle_event()
+int CWindowMaskGUI::save_mask(const char *nm)
 {
+	int k = mwindow->edl->session->cwindow_mask;
+	MaskAutos *autos;
+	MaskAuto *keyframe;
 	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
+	get_keyframe(track, autos, keyframe, mask, point, 0);
+	if( !track ) return 0;
+	SubMask *sub_mask = keyframe->get_submask(k);
+	ArrayList<SubMask *> masks;
+	load_masks(masks);
+	int i = masks.size();
+	while( --i >= 0 ) {
+		if( strcmp(masks[i]->name, nm) ) continue;
+		masks.remove_object_number(i);
+	}
+	mask = new SubMask(0, -1);
+	strncpy(mask->name, nm, sizeof(mask->name)-1);
+	mask->copy_from(*sub_mask, 0);
+	masks.append(mask);
+	save_masks(masks);
+	masks.remove_all_objects();
+	return 1;
+}
+
+int CWindowMaskGUI::del_mask(const char *nm)
+{
+	ArrayList<SubMask *> masks;
+	load_masks(masks);
+	int i = masks.size();
+	while( --i >= 0 ) {
+		if( strcmp(masks[i]->name, nm) ) continue;
+		masks.remove_object_number(i);
+	}
+	save_masks(masks);
+	masks.remove_all_objects();
+	return 1;
+}
+
+int CWindowMaskGUI::center_mask()
+{
+	int k = mwindow->edl->session->cwindow_mask;
+	MaskAutos *autos;
 	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
+#ifdef USE_KEYFRAME_SPANNING
+	int create_it = 0;
+#else
+	int create_it = 1;
+#endif
+	get_keyframe(track, autos, keyframe,
+			mask, point, create_it);
+	if( !track ) return 0;
+	mwindow->undo->update_undo_before(_("mask center"), this);
+
+// Get existing keyframe
+#ifdef USE_KEYFRAME_SPANNING
+	MaskAuto temp_keyframe(mwindow->edl, autos);
+	temp_keyframe.copy_data(keyframe);
+	keyframe = &temp_keyframe;
+#endif
+	SubMask *sub_mask = keyframe->get_submask(k);
+	MaskPoints &points = sub_mask->points;
+	int psz = points.size();
+	if( psz > 0 ) {
+		float cx = 0, cy = 0;
+		for( int i=0; i<psz; ++i ) {
+			MaskPoint *p  = points[i];
+			cx += p->x;  cy += p->y;
+		}
+		cx /= psz;  cy /= psz;
+		cx -= mwindow->edl->session->output_w / 2.f;
+		cy -= mwindow->edl->session->output_h / 2.f;
+		for( int i=0; i<psz; ++i ) {
+			MaskPoint *p  = points[i];
+			p->x -= cx;  p->y -= cy;
+		}
+	}
+#ifdef USE_KEYFRAME_SPANNING
+	autos->update_parameter(keyframe);
+#endif
+	update_preview();
+	mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
+	return 1;
+}
+
+int CWindowMaskGUI::normal_mask()
+{
+	int k = mwindow->edl->session->cwindow_mask;
 	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
 	SubMask *mask;
+#ifdef USE_KEYFRAME_SPANNING
+	int create_it = 0;
+#else
+	int create_it = 1;
+#endif
+// Get existing keyframe
+	get_keyframe(track, autos, keyframe,
+			mask, point, create_it);
+	if( !track ) return 0;
+	mwindow->undo->update_undo_before(_("mask normal"), this);
+
+#ifdef USE_KEYFRAME_SPANNING
+	MaskAuto temp_keyframe(mwindow->edl, autos);
+	temp_keyframe.copy_data(keyframe);
+	keyframe = &temp_keyframe;
+#endif
+	SubMask *sub_mask = keyframe->get_submask(k);
+	MaskPoints &points = sub_mask->points;
+	int psz = points.size();
+	float cx = 0, cy = 0;
+	double dr = 0;
+	if( psz > 0 ) {
+		for( int i=0; i<psz; ++i ) {
+			MaskPoint *p  = points[i];
+			cx += p->x;  cy += p->y;
+		}
+		cx /= psz;  cy /= psz;
+		for( int i=0; i<psz; ++i ) {
+			MaskPoint *p  = points[i];
+			float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
+			double d = sqrt(dx*dx + dy*dy);
+			if( dr < d ) dr = d;
+		}
+	}
+	if( dr > 0 ) {
+		float out_w = mwindow->edl->session->output_w;
+		float out_h = mwindow->edl->session->output_h;
+		float r = bmax(out_w, out_h);
+		float s = r / (4 * dr * sqrt(2.));
+		for( int i=0; i<psz; ++i ) {
+			MaskPoint *p  = points[i];
+			float x = p->x, y = p->y;
+			p->x = (x-cx) * s + cx;
+			p->y = (y-cy) * s + cy;
+			p->control_x1 *= s;  p->control_y1 *= s;
+			p->control_x2 *= s;  p->control_y2 *= s;
+		}
+	}
+#ifdef USE_KEYFRAME_SPANNING
+	autos->update_parameter(keyframe);
+#endif
+	update_preview();
+
+	mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
+	return 1;
+}
+
+
+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;
-	get_keyframe(track, autos, keyframe, mask, point, 0);
+	SubMask *mask;
+#ifdef USE_KEYFRAME_SPANNING
+	int create_it = 0;
+#else
+	int create_it = 1;
+#endif
 
-	mwindow->undo->update_undo_before(_("mask point"), this);
+	mwindow->undo->update_undo_before(_("mask shape"), this);
 
-	if(point)
-	{
+// 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
-// Create temp keyframe
 		MaskAuto temp_keyframe(mwindow->edl, autos);
 		temp_keyframe.copy_data(keyframe);
-// Get affected point in temp keyframe
+		keyframe = &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];
-		}
+#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;
+}
 
-		if(point)
-		{
-			point->x = atof(x->get_text());
-			point->y = atof(y->get_text());
-// Commit to spanned keyframes
-			autos->update_parameter(&temp_keyframe);
-		}
+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_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Load preset"));
+}
+
+int CWindowMaskLoad::handle_event()
+{
+	gui->mask_load_list->create_objects();
+	int px, py;
+	get_abs_cursor(px, py);
+	return gui->mask_load_list->activate(px, py, 120,160);
+}
+
+
+CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y, int w)
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Save preset"));
+}
+
+CWindowMaskSave::~CWindowMaskSave()
+{
+}
+
+int CWindowMaskSave::handle_event()
+{
+	Track *track;
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	SubMask *mask;
+	MaskPoint *point;
+	gui->get_keyframe(track, autos, keyframe, mask, point, 0);
+	if( track ) {
+		int sx = 0, sy = 0;
+		gui->get_abs_cursor(sx, sy);
+		if( !gui->preset_dialog )
+			gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
+		gui->preset_dialog->start_dialog(sx, sy, keyframe);
+	}
+	return 1;
+}
+
+CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
+ : BC_DialogThread()
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	pgui = 0;
+}
+
+CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
+{
+	close_window();
+}
+
+void CWindowMaskPresetDialog::handle_close_event(int result)
+{
+	pgui = 0;
+}
+
+void CWindowMaskPresetDialog::handle_done_event(int result)
+{
+	if( result ) return;
+	const char *nm = pgui->preset_text->get_text();
+	if( keyframe )
+		gui->save_mask(nm);
+	else
+		gui->del_mask(nm);
+}
+
+BC_Window* CWindowMaskPresetDialog::new_gui()
+{
+	pgui = new CWindowMaskPresetGUI(this, sx, sy,
+		keyframe ? _(PROGRAM_NAME ": Save Mask") :
+			   _(PROGRAM_NAME ": Delete Mask"));
+	pgui->create_objects();
+	return pgui;
+}
+
+void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
+{
+	close_window();
+	this->sx = sx;  this->sy = sy;
+	this->keyframe = keyframe;
+	start();
+}
+
+CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
+			int x, int y, const char *title)
+ : BC_Window(title, x, y, 320, 100, 320, 100, 0, 0, 1)
+{
+	this->preset_dialog = preset_dialog;
+}
+
+void CWindowMaskPresetGUI::create_objects()
+{
+	int x = 10, y = 10, pad = 8;
+	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 -
+		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());
+	preset_text->create_objects();
+	preset_text->set_tooltip(_("Mask name"));
+	preset_text->update_items();
+	add_subwindow(new BC_OKButton(this));
+	add_subwindow(new BC_CancelButton(this));
+	show_window();
+	raise_window();
+	unlock_window();
+}
+
+CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
+		int x, int y, int w, int h, const char *text)
+ : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
+{
+	this->pgui = pgui;
+}
+
+int CWindowMaskPresetText::handle_event()
+{
+	int k = get_number();
+	if( k >= 0 && k<mask_items.size() )
+		update(mask_items[k]->get_text());
+	return 1;
+}
+
+void CWindowMaskPresetText::update_items()
+{
+	mask_items.remove_all_objects();
+	ArrayList<SubMask *> masks;
+	pgui->preset_dialog->gui->load_masks(masks);
+	for( int i=0; i<masks.size(); ++i ) {
+		char text[BCSTRLEN];  memset(text, 0, sizeof(text));
+		strncpy(text, masks[i]->name, sizeof(text)-1);
+		mask_items.append(new CWindowMaskItem(text));
+	}
+	masks.remove_all_objects();
+	update_list(&mask_items);
+}
+
+
+CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y, int w)
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("Delete preset"));
+}
+
+int CWindowMaskDelete::handle_event()
+{
+	int sx = 0, sy = 0;
+	gui->get_abs_cursor(sx, sy);
+	if( !gui->preset_dialog )
+		gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
+	gui->preset_dialog->start_dialog(sx, sy, 0);
+	return 1;
+}
+
+
+CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y, int w)
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("center mask"));
+}
+
+int CWindowMaskCenter::handle_event()
+{
+	return gui->center_mask();
+}
+
+
+CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
+	CWindowMaskGUI *gui, int x, int y, int w)
+ : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
+{
+	this->mwindow = mwindow;
+	this->gui = gui;
+	set_tooltip(_("normalize mask"));
+}
+
+int CWindowMaskNormal::handle_event()
+{
+	return gui->normal_mask();
+}
+
+
+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;
+	this->shape = shape;
+	set_tooltip(tip);
+}
+
+CWindowMaskShape::~CWindowMaskShape()
+{
+}
+
+void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
+{
+	int out_w = mwindow->edl->session->output_w;
+	int out_h = mwindow->edl->session->output_h;
+	float cx = out_w/2.f, cy = out_h/2.f;
+	float r = bmax(cx, cy) / 4.f;
+	double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
+	float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
+	MaskPoint *pt = 0;
+	MaskPoints &points = sub_mask->points;
+	points.remove_all_objects();
+	switch( i ) {
+	case MASK_SHAPE_SQUARE:
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy - r;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy - r;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy + r;
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy + r;
+		break;
+	case MASK_SHAPE_CIRCLE:
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy - r;
+		pt->control_x1 = -rc;  pt->control_y1 =  rc;
+		pt->control_x2 =  rc;  pt->control_y2 = -rc;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy - r;
+		pt->control_x1 = -rc;  pt->control_y1 = -rc;
+		pt->control_x2 =  rc;  pt->control_y2 =  rc;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy + r;
+		pt->control_x1 =  rc;  pt->control_y1 = -rc;
+		pt->control_x2 = -rc;  pt->control_y2 =  rc;
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy + r;
+		pt->control_x1 =  rc;  pt->control_y1 =  rc;
+		pt->control_x2 = -rc;  pt->control_y2 = -rc;
+		break;
+	case MASK_SHAPE_TRIANGLE:
+		points.append(pt = new MaskPoint());
+		pt->x = cx + 0;  pt->y = cy - r*(sqrt(3.)-1.);
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy + r;
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy + r;
+		break;
+	case MASK_SHAPE_OVAL:
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy - r2;
+		pt->control_x1 = -r2;  pt->control_y1 =  r4;
+		pt->control_x2 =  r2;  pt->control_y2 = -r4;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy - r2;
+		pt->control_x1 = -r2;  pt->control_y1 = -r4;
+		pt->control_x2 =  r2;  pt->control_y2 =  r4;
+		points.append(pt = new MaskPoint());
+		pt->x = cx + r;  pt->y = cy + r2;
+		pt->control_x1 =  r2;  pt->control_y1 = -r4;
+		pt->control_x2 = -r2;  pt->control_y2 =  r4;
+		points.append(pt = new MaskPoint());
+		pt->x = cx - r;  pt->y = cy + r2;
+		pt->control_x1 =  r2;  pt->control_y1 =  r4;
+		pt->control_x2 = -r2;  pt->control_y2 = -r4;
+		break;
+	}
+}
+
+int CWindowMaskShape::handle_event()
+{
+	MaskAutos *autos;
+	MaskAuto *keyframe;
+	Track *track;
+	MaskPoint *point;
+	SubMask *mask;
+#ifdef USE_KEYFRAME_SPANNING
+	int create_it = 0;
 #else
-		point->x = atof(x->get_text());
-		point->y = atof(y->get_text());
+	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);
+	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
+		if( mask ) {
+			builtin_shape(shape, mask);
+#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;
+}
 
-	update_preview();
-	mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
+void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
+{
+        char path[BCTEXTLEN];
+        sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
+        FileSystem fs;
+        fs.complete_path(path);
+	FileXML file;
+	file.read_from_file(path, 1);
+
+	masks.remove_all_objects();
+	int result;
+	while( !(result = file.read_tag()) ) {
+		if( file.tag.title_is("MASK") ) {
+			SubMask *sub_mask = new SubMask(0, -1);
+			char name[BCTEXTLEN];  name[0] = 0;
+			file.tag.get_property("NAME", name);
+			strncpy(sub_mask->name, name, sizeof(sub_mask->name));
+			sub_mask->load(&file);
+			masks.append(sub_mask);
+		}
+	}
 }
 
-void CWindowMaskGUI::update_preview()
+void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
 {
-	CWindowGUI *cgui = mwindow->cwindow->gui;
-	cgui->lock_window("CWindowMaskGUI::update_preview");
-	cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
-	cgui->unlock_window();
+	FileXML file;
+	for( int i=0; i<masks.size(); ++i ) {
+		SubMask *sub_mask = masks[i];
+		sub_mask->copy(&file);
+	}
+	file.terminate_string();
+
+        char path[BCTEXTLEN];
+        sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
+        FileSystem fs;
+        fs.complete_path(path);
+	file.write_to_file(path);
 }
 
 
 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow,
- 	thread,
-	_(PROGRAM_NAME ": Ruler"),
-	320,
-	240)
+ : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
 {
 }