#include "automation.h"
#include "bccolors.h"
+#include "bctimer.h"
#include "clip.h"
#include "condition.h"
#include "cpanel.h"
#include "cwindowtool.h"
#include "edl.h"
#include "edlsession.h"
+#include "file.h"
+#include "filexml.h"
#include "floatauto.h"
#include "floatautos.h"
#include "keys.h"
#include "mwindowgui.h"
#include "theme.h"
#include "track.h"
+#include "tracks.h"
#include "trackcanvas.h"
#include "transportque.h"
}
}
+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()
{
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()
{
}
+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;
}
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()
// 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()
{
- FloatAuto *x=0, *y=0, *z=0;
Track *track = mwindow->cwindow->calculate_affected_track();
-
- if(track)
- { mwindow->cwindow->calculate_affected_autos(&x, &y, &z,
- track, cfg.use_camera, 0,0,0); // don't create new keyframe
-
- if(x) x->change_curve_mode(cfg.mode);
- if(y) y->change_curve_mode(cfg.mode);
- if(z) z->change_curve_mode(cfg.mode);
+ if(track) {
+ FloatAuto *x=0, *y=0, *z=0;
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
+ if( x ) x->change_curve_mode(cfg.mode);
+ if( y ) y->change_curve_mode(cfg.mode);
+ if( z ) z->change_curve_mode(cfg.mode);
gui->update();
gui->update_preview();
{
int x = 10, y = 10, x1;
Track *track = mwindow->cwindow->calculate_affected_track();
- FloatAuto *x_auto = 0;
- FloatAuto *y_auto = 0;
- FloatAuto *z_auto = 0;
+ FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
BC_Title *title;
BC_Button *button;
lock_window("CWindowCameraGUI::create_objects");
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- &y_auto, &z_auto, track, 1, 0, 0, 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
}
add_subwindow(title = new BC_Title(x, y, "X:"));
unlock_window();
}
-void CWindowCameraGUI::update_preview()
-{
- mwindow->gui->lock_window("CWindowCameraGUI::update_preview");
- mwindow->restart_brender();
- mwindow->gui->draw_overlays(1);
- mwindow->sync_parameters(CHANGE_PARAMS);
- mwindow->gui->unlock_window();
- mwindow->cwindow->refresh_frame(CHANGE_NONE);
- mwindow->cwindow->gui->lock_window("CWindowCameraGUI::update_preview");
- mwindow->cwindow->gui->canvas->draw_refresh();
- mwindow->cwindow->gui->unlock_window();
-}
-
-
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->cwindow->calculate_affected_autos(&x_auto,
- &y_auto,
- &z_auto,
- track,
- 1,
- 0,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
}
if(x_auto)
FloatAuto *x_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- 0,
- &z_auto,
- track,
- 1,
- 1,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, 0, &z_auto, 1, 1, 0, 0);
}
if(x_auto && z_auto)
FloatAuto *x_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- 0,
- &z_auto,
- track,
- 1,
- 1,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, 0, &z_auto, 1, 1, 0, 0);
}
if(x_auto && z_auto)
FloatAuto *y_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(0,
- &y_auto,
- &z_auto,
- track,
- 1,
- 0,
- 1,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ 0, &y_auto, &z_auto, 1, 0, 1, 0);
}
if(y_auto && z_auto)
FloatAuto *y_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(0,
- &y_auto,
- &z_auto,
- track,
- 1,
- 0,
- 1,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ 0, &y_auto, &z_auto, 1, 0, 1, 0);
}
if(y_auto && z_auto)
BC_Button *button;
lock_window("CWindowProjectorGUI::create_objects");
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- &y_auto,
- &z_auto,
- track,
- 0,
- 0,
- 0,
- 0);
+ 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:"));
unlock_window();
}
-void CWindowProjectorGUI::update_preview()
-{
- mwindow->gui->lock_window("CWindowProjectorGUI::update_preview");
- mwindow->restart_brender();
- mwindow->sync_parameters(CHANGE_PARAMS);
- mwindow->gui->draw_overlays(1);
- mwindow->gui->unlock_window();
- mwindow->cwindow->refresh_frame(CHANGE_NONE);
- mwindow->cwindow->gui->lock_window("CWindowProjectorGUI::update_preview");
- mwindow->cwindow->gui->canvas->draw_refresh();
- mwindow->cwindow->gui->unlock_window();
-}
-
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->cwindow->calculate_affected_autos(&x_auto,
- &y_auto,
- &z_auto,
- track,
- 0,
- 0,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
}
if(x_auto)
FloatAuto *x_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- 0,
- &z_auto,
- track,
- 0,
- 1,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, 0, &z_auto, 0, 1, 0, 0);
}
if(x_auto && z_auto)
{
FloatAuto *x_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(&x_auto,
- 0,
- &z_auto,
- track,
- 0,
- 1,
- 0,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ &x_auto, 0, &z_auto, 0, 1, 0, 0);
}
if(x_auto && z_auto)
FloatAuto *y_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(0,
- &y_auto,
- &z_auto,
- track,
- 0,
- 0,
- 1,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ 0, &y_auto, &z_auto, 0, 0, 1, 0);
}
if(y_auto && z_auto)
FloatAuto *y_auto = 0;
FloatAuto *z_auto = 0;
Track *track = mwindow->cwindow->calculate_affected_track();
- if(track)
- {
- mwindow->cwindow->calculate_affected_autos(0,
- &y_auto,
- &z_auto,
- track,
- 0,
- 0,
- 1,
- 0);
+ if( track ) {
+ mwindow->cwindow->calculate_affected_autos(track,
+ 0, &y_auto, &z_auto, 0, 0, 1, 0);
}
if(y_auto && z_auto)
}
-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);
+}
- return MASK_SUBTRACT_ALPHA;
+int CWindowMaskTrackTumbler::handle_down_event()
+{
+ return do_event(-1);
}
-int CWindowMaskMode::handle_event()
+int CWindowMaskTrackTumbler::do_event(int dir)
{
- 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);
-#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);
-#else
- ((MaskAuto*)autos->default_auto)->mode =
- text_to_mode(get_text());
-#endif
- mwindow->undo->update_undo_after(_("mask mode"), LOAD_AUTOMATION);
+ 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];
}
-
-//printf("CWindowMaskMode::handle_event 1\n");
- gui->update_preview();
+ 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;
}
-
-
-
-
-
-
-CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
- CWindowToolGUI *gui,
- int x,
- int y)
- : BC_GenericButton(x, y, _("Delete"))
+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;
}
-int CWindowMaskDelete::handle_event()
+CWindowMaskName::~CWindowMaskName()
+{
+}
+
+int CWindowMaskName::handle_event()
{
+ Track *track;
MaskAutos *autos;
MaskAuto *keyframe;
- Track *track;
- MaskPoint *point;
SubMask *mask;
- int total_points = 0;
-
-// Get existing keyframe
- ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
-
- if(track)
- {
- mwindow->undo->update_undo_before(_("mask delete"), 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
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;
-
-// Commit change to span of keyframes
+ 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
- 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;
+ 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
- if( mwindow->cwindow->gui->affected_point >= total_points )
- mwindow->cwindow->gui->affected_point =
- total_points > 0 ? total_points-1 : 0;
-
gui->update();
gui->update_preview();
- mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
}
-
-
return 1;
}
-int CWindowMaskDelete::keypress_event()
+void CWindowMaskName::update_items(MaskAuto *keyframe)
{
- if(get_keypress() == BACKSPACE ||
- get_keypress() == DELETE)
- return handle_event();
- return 0;
+ 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);
}
-// 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;
-// }
-
-
-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)
+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;
}
-CWindowMaskNumber::~CWindowMaskNumber()
+CWindowMaskButton::~CWindowMaskButton()
{
}
-int CWindowMaskNumber::handle_event()
+int CWindowMaskButton::handle_event()
{
- mwindow->edl->session->cwindow_mask = atol(get_text());
+ 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;
}
-
-CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
- CWindowToolGUI *gui, int x, int y)
- : BC_TumbleTextBox(gui,
- (int64_t)mwindow->cwindow->gui->affected_point,
- (int64_t)0, INT64_MAX, x, y, 100)
+CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
+ int x, int y)
+ : BC_Tumbler(x, y)
{
this->mwindow = mwindow;
this->gui = gui;
}
-CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
+CWindowMaskThumbler::~CWindowMaskThumbler()
{
}
-int CWindowMaskAffectedPoint::handle_event()
+int CWindowMaskThumbler::handle_up_event()
{
- int total_points = 0;
- int affected_point = atol(get_text());
- Track *track = mwindow->cwindow->calculate_affected_track();
- if(track) {
- MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
- MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
- if( keyframe ) {
- SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
- total_points = mask->points.size();
- }
- }
- int active_point = affected_point;
- if( affected_point >= total_points )
- affected_point = total_points - 1;
- else if( affected_point < 0 )
- affected_point = 0;
- if( active_point != affected_point )
- update((int64_t)affected_point);
- mwindow->cwindow->gui->affected_point = affected_point;
+ 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()
+{
+}
+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("reset_button"))
+{
+ this->mwindow = mwindow;
+ this->gui = gui;
+ set_tooltip(_("Show/Hide mask"));
+}
-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)
+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"));
}
-CWindowMaskFeather::~CWindowMaskFeather()
+
+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 CWindowMaskFeather::handle_event()
+
+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 CWindowMaskDelMask::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 feather"), this);
+ int total_points;
// Get existing keyframe
- ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
- mask, point, create_it);
+ gui->get_keyframe(track, autos, keyframe, mask, point, 0);
+
+ if( track ) {
+ mwindow->undo->update_undo_before(_("mask delete"), 0);
- if(track)
- {
#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());
+ SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
+ submask->points.remove_all_objects();
+ total_points = 0;
// Commit change to span of keyframes
- autos->update_parameter(&temp_keyframe);
+ ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
#else
- keyframe->feather = atof(get_text());
+ for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
+ SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
+ 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 =
+ total_points > 0 ? total_points-1 : 0;
+
+ gui->update();
+ gui->update_preview();
+ mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
+ }
+
+ return 1;
+}
+
+CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
+ CWindowMaskGUI *gui, int x, int y)
+ : BC_GenericButton(x, y, _("Delete"))
+{
+ 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;
+
+// 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;
+
+// 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;
+
+ gui->update();
+ gui->update_preview();
+ mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
+ }
+
+ 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, 70)
+{
+ this->mwindow = mwindow;
+ this->gui = gui;
+}
+
+CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
+{
+}
+
+int CWindowMaskAffectedPoint::handle_event()
+{
+ int total_points = 0;
+ int affected_point = atol(get_text());
+ 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);
+ if( keyframe ) {
+ SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
+ total_points = mask->points.size();
+ }
+ }
+ int active_point = affected_point;
+ if( affected_point >= total_points )
+ affected_point = total_points - 1;
+ if( affected_point < 0 )
+ affected_point = 0;
+ if( active_point != affected_point )
+ update((int64_t)affected_point);
+ mwindow->cwindow->gui->affected_point = affected_point;
+ gui->update();
+ gui->update_preview();
+ return 1;
+}
+
+
+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"));
+}
+
+CWindowMaskFocus::~CWindowMaskFocus()
+{
+}
+
+int CWindowMaskFocus::handle_event()
+{
+ 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 == 0);
+ gui->mask_scale_y->update(id == 1);
+ gui->mask_scale_xy->update(id == 2);
+ 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, -FEATHER_MAX, FEATHER_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
+ int create_it = 1;
+#endif
+
+ mwindow->undo->update_undo_before(_("mask feather"), this);
+
+// Get existing keyframe
+ gui->get_keyframe(track, autos, keyframe,
+ mask, point, create_it);
+ if( track ) {
+ int gang = gui->gang_feather->get_value();
+#ifdef USE_KEYFRAME_SPANNING
+ MaskAuto temp_keyframe(mwindow->edl, autos);
+ temp_keyframe.copy_data(keyframe);
+ 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;
+ bclamp(feather, -FEATHER_MAX, FEATHER_MAX);
+ sub_mask->feather = feather;
+ }
+#ifdef USE_KEYFRAME_SPANNING
+ autos->update_parameter(keyframe);
+#endif
+ gui->update_preview();
+ }
+
+ mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
+ 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, FEATHER_MAX, v)
+{
+ this->mwindow = mwindow;
+ this->gui = gui;
+ set_precision(0.01);
+ timer = new Timer();
+ stick = 0;
+ last_v = 0;
+}
+
+CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
+{
+ delete timer;
+}
+
+int CWindowMaskFeatherSlider::handle_event()
+{
+ 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);
+ }
+ 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->feather->BC_TumbleTextBox::update(v);
+ return gui->feather->update_value(v);
+}
+
+int CWindowMaskFeatherSlider::update(float v)
+{
+ return BC_FSlider::update(v);
+}
+
+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()
+{
+}
+
+int CWindowMaskFade::update(float v)
+{
+ gui->fade_slider->update(v);
+ return BC_TumbleTextBox::update(v);
+}
+
+int CWindowMaskFade::update_value(float v)
+{
+ 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 fade"), this);
+
+// 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
+ MaskAuto temp_keyframe(mwindow->edl, autos);
+ temp_keyframe.copy_data(keyframe);
+ 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();
+ }
+
+ 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;
+}
+
+
+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;
+}
+
+int CWindowMaskBeforePlugins::handle_event()
+{
+ Track *track;
+ MaskAutos *autos;
+ MaskAuto *keyframe;
+ SubMask *mask;
+ MaskPoint *point;
+ gui->get_keyframe(track, autos, keyframe, mask, point, 1);
+
+ if (keyframe) {
+ 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(CWindowMaskGUI *gui, int x, int y)
+ : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
+{
+ this->gui = gui;
+}
+
+int CWindowDisableOpenGLMasking::handle_event()
+{
+ Track *track;
+ MaskAutos *autos;
+ MaskAuto *keyframe;
+ SubMask *mask;
+ MaskPoint *point;
+ gui->get_keyframe(track, autos, keyframe, mask, point, 1);
+
+ 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"), 440, 700)
+{
+ this->mwindow = mwindow;
+ this->thread = thread;
+ 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");
+ done_event();
+ delete active_point;
+ delete fade;
+ delete feather;
+ unlock_window();
+ delete preset_dialog;
+}
+
+void CWindowMaskGUI::create_objects()
+{
+ 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, _("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, _("Presets 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, 0, _("xlate/scale x")));
+ add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
+ t[6], y, theme->get_image_set("mask_scale_y"), 0, 1, _("xlate/scale y")));
+ add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
+ t[7], y, theme->get_image_set("mask_scale_xy"), 1, 2, _("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, x1, y);
+ feather->create_objects();
+ 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));
+ y += active_point->get_h() + margin;
+ add_subwindow(title = new BC_Title(x, y, "X:"));
+ 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, 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:"));
+ 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;
+
+ 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();
+ 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+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"
+ "Ctrl+Wheel: rotate/scale around pointer")));
+ help_h = y + title->get_h() + 2*margin;
+ update();
+ resize_window(get_w(), help_y);
+ unlock_window();
+}
+
+int CWindowMaskGUI::close_event()
+{
+ done_event();
+ return CWindowToolGUI::close_event();
+}
+
+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);
+ }
+
+ 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 ) {
+ point = mask->points.values[mwindow->cwindow->gui->affected_point];
+ }
+ }
+}
+
+void CWindowMaskGUI::update()
+{
+ Track *track;
+ MaskAutos *autos;
+ MaskAuto *keyframe;
+ SubMask *mask;
+ MaskPoint *point;
+//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 ?
+ 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);
+}
+
+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)
+ {
+#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);
+ 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());
+// Commit to spanned keyframes
+ autos->update_parameter(&temp_keyframe);
+ }
+#else
+ point->x = atof(x->get_text());
+ point->y = atof(y->get_text());
+#endif
+ }
+
+ update_preview();
+ mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
+}
+
+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);
+ }
+}
+
+// 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
+ int create_it = 0;
+#else
+ 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();
+ }
+
+ mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
+ return 1;
+}
+
+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);
- gui->update_preview();
+// 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;
+}
- mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
+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;
}
-CWindowMaskValue::CWindowMaskValue(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
- : BC_ISlider(x,
- y,
- 0,
- 200,
- 200,
- 0,
- 100,
- 0)
+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);
}
-CWindowMaskValue::~CWindowMaskValue()
+CWindowMaskLoadList::~CWindowMaskLoadList()
{
}
-int CWindowMaskValue::handle_event()
+
+int CWindowMaskLoadList::handle_event()
{
MaskAutos *autos;
MaskAuto *keyframe;
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 shape"), this);
- if(track)
- {
+// 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);
-// 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;
+ 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);
}
-
- gui->update_preview();
- mwindow->undo->update_undo_after(_("mask value"), LOAD_AUTOMATION);
+ 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);
+}
-CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowToolGUI *gui, int x, int y)
- : BC_CheckBox(x,
- y,
- 1,
- _("Apply mask before plugins"))
+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 CWindowMaskBeforePlugins::handle_event()
+int CWindowMaskLoad::handle_event()
{
- Track *track;
- MaskAutos *autos;
- MaskAuto *keyframe;
- SubMask *mask;
- MaskPoint *point;
- ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
-
- if (keyframe) {
- keyframe->apply_before_plugins = get_value();
- gui->update_preview();
- }
- return 1;
+ gui->mask_load_list->create_objects();
+ int px, py;
+ get_abs_cursor(px, py);
+ return gui->mask_load_list->activate(px, py, 120,160);
}
-CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowToolGUI *gui, int x, int y)
- : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
+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"));
}
-int CWindowDisableOpenGLMasking::handle_event()
+CWindowMaskSave::~CWindowMaskSave()
+{
+}
+
+int CWindowMaskSave::handle_event()
{
Track *track;
MaskAutos *autos;
MaskAuto *keyframe;
SubMask *mask;
MaskPoint *point;
- ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
-
- if (keyframe) {
- keyframe->disable_opengl_masking = get_value();
- gui->update_preview();
+ 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();
+}
-
-
-CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
- : CWindowToolGUI(mwindow, thread,
- _(PROGRAM_NAME ": Mask"), 330, 320)
+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->mwindow = mwindow;
- this->thread = thread;
- number = 0;
- active_point = 0;
- feather = 0;
+ this->preset_dialog = preset_dialog;
}
-CWindowMaskGUI::~CWindowMaskGUI()
+
+void CWindowMaskPresetGUI::create_objects()
{
- lock_window("CWindowMaskGUI::~CWindowMaskGUI");
- delete number;
- delete active_point;
- delete feather;
+ 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();
}
-void CWindowMaskGUI::create_objects()
+CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
+ int x, int y, int w, int h, const char *text)
+ : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
{
- 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);
+ this->pgui = pgui;
+}
- lock_window("CWindowMaskGUI::create_objects");
- 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, _("Feather:")));
- feather = new CWindowMaskFeather(mwindow,
- this, x + title->get_w() + margin, y);
- feather->create_objects();
- y += feather->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->create_objects();
- x += this->x->get_w() + 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->create_objects();
+int CWindowMaskPresetText::handle_event()
+{
+ int k = get_number();
+ if( k >= 0 && k<mask_items.size() )
+ update(mask_items[k]->get_text());
+ return 1;
+}
- 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;
+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);
+}
- add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
- y += this->apply_before_plugins->get_h() + margin;
- add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
- update();
- unlock_window();
+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"));
}
-void CWindowMaskGUI::get_keyframe(Track* &track,
- MaskAutos* &autos,
- MaskAuto* &keyframe,
- SubMask* &mask,
- MaskPoint* &point,
- int create_it)
+int CWindowMaskDelete::handle_event()
{
- autos = 0;
- keyframe = 0;
-
- 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);
- }
+ 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;
+}
- if(keyframe)
- mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
- else
- mask = 0;
- 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];
- }
- }
+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"));
}
-void CWindowMaskGUI::update()
+int CWindowMaskCenter::handle_event()
{
- Track *track;
- MaskAutos *autos;
- MaskAuto *keyframe;
- SubMask *mask;
- MaskPoint *point;
-//printf("CWindowMaskGUI::update 1\n");
- get_keyframe(track, autos, keyframe, mask, point, 0);
+ return gui->center_mask();
+}
- double position = mwindow->edl->local_session->get_selectionstart(1);
- position = mwindow->edl->align_to_frame(position, 0);
- if(track)
- {
- int64_t position_i = track->to_units(position, 0);
- if(point)
- {
- x->update(point->x);
- y->update(point->y);
- }
+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"));
+}
- 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);
- }
- }
+int CWindowMaskNormal::handle_event()
+{
+ return gui->normal_mask();
+}
-//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)
- {
-#ifdef USE_KEYFRAME_SPANNING
- mode->set_text(
- CWindowMaskMode::mode_to_text(keyframe->mode));
-#else
- mode->set_text(
- CWindowMaskMode::mode_to_text(((MaskAuto*)autos->default_auto)->mode));
-#endif
+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;
}
-//printf("CWindowMaskGUI::update 2\n");
}
-void CWindowMaskGUI::handle_event()
+int CWindowMaskShape::handle_event()
{
- Track *track;
- MaskAuto *keyframe;
MaskAutos *autos;
- SubMask *mask;
+ 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);
+ if( track ) {
#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
+ 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;
+}
- if(point)
- {
- point->x = atof(x->get_text());
- point->y = atof(y->get_text());
-// Commit to spanned keyframes
- autos->update_parameter(&temp_keyframe);
+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);
}
-#else
- point->x = atof(x->get_text());
- point->y = atof(y->get_text());
-#endif
}
-
- update_preview();
- mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
}
-void CWindowMaskGUI::update_preview()
+void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
{
- mwindow->gui->lock_window("CWindowMaskGUI::update_preview");
- mwindow->restart_brender();
- mwindow->sync_parameters(CHANGE_PARAMS);
- mwindow->gui->draw_overlays(1);
- mwindow->gui->unlock_window();
- mwindow->cwindow->refresh_frame(CHANGE_NONE);
- mwindow->cwindow->gui->lock_window("CWindowMaskGUI::update_preview");
- mwindow->cwindow->gui->canvas->draw_refresh();
- mwindow->cwindow->gui->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)
{
}
projects / goodguy / cinelerra.git / blobdiff