X-Git-Url: https://git.cinelerra-gg.org/git/?p=goodguy%2Fcinelerra.git;a=blobdiff_plain;f=cinelerra-5.1%2Fcinelerra%2Fcwindowtool.C;h=3a0d72b8e6a25fbe1c98f2e23f424be1c7b340db;hp=f0f372a5aba2f82315f2ee38d7a232af060e21a8;hb=6d8835a537ca709e122226506548de0d4942aa32;hpb=7fd85fb66168f6b518c5f2d73e04036e87faa0e1 diff --git a/cinelerra-5.1/cinelerra/cwindowtool.C b/cinelerra-5.1/cinelerra/cwindowtool.C index f0f372a5..3a0d72b8 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,24 +709,22 @@ 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() { - 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(); @@ -748,17 +767,14 @@ void CWindowCameraGUI::create_objects() { 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:")); @@ -810,20 +826,6 @@ void CWindowCameraGUI::create_objects() 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; @@ -893,17 +895,9 @@ void CWindowCameraGUI::update() 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) @@ -940,16 +934,9 @@ int CWindowCameraLeft::handle_event() 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) @@ -1017,16 +1004,9 @@ int CWindowCameraRight::handle_event() 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) @@ -1064,16 +1044,9 @@ int CWindowCameraTop::handle_event() 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) @@ -1139,16 +1112,9 @@ int CWindowCameraBottom::handle_event() 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) @@ -1196,16 +1162,9 @@ void CWindowProjectorGUI::create_objects() 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:")); @@ -1256,19 +1215,6 @@ void CWindowProjectorGUI::create_objects() 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; @@ -1337,17 +1283,9 @@ void CWindowProjectorGUI::update() 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) @@ -1381,16 +1319,9 @@ int CWindowProjectorLeft::handle_event() 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) { @@ -1447,16 +1378,9 @@ int CWindowProjectorRight::handle_event() 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) @@ -1485,16 +1409,9 @@ int CWindowProjectorTop::handle_event() 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) @@ -1551,16 +1468,9 @@ int CWindowProjectorBottom::handle_event() 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) @@ -1577,412 +1487,1611 @@ 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 && imasks.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; imasks.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<masks == m ) + track->masks = 0; + else + track->masks = m; + for( int i=0; imask_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( ; ipoints.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( ; ipoints.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; imask_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; imask_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]); icwindow->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; iedl->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; iget_h() + margin; + add_subwindow(title = new BC_Title(x, y, _("Enable:"))); + for( int i=0; iget_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; iupdate((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; iget_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; jget_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= 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 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 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; ix; 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; ix -= 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; ix; cy += p->y; + } + cx /= psz; cy /= psz; + for( int i=0; ix-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; ix, 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; @@ -1995,316 +3104,411 @@ 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 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 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 masks; + gui->load_masks(masks); + for( int i=0; iname, 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 && kget_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 masks; + pgui->preset_dialog->gui->load_masks(masks); + for( int i=0; iname, 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 &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 &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; icopy(&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) { }