3 * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "automation.h"
28 #include "condition.h"
30 #include "cplayback.h"
32 #include "cwindowgui.h"
33 #include "cwindowtool.h"
35 #include "edlsession.h"
38 #include "floatauto.h"
39 #include "floatautos.h"
42 #include "localsession.h"
43 #include "mainsession.h"
46 #include "maskautos.h"
49 #include "mwindowgui.h"
53 #include "trackcanvas.h"
54 #include "transportque.h"
57 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
60 this->mwindow = mwindow;
64 current_tool = CWINDOW_NONE;
66 input_lock = new Condition(0, "CWindowTool::input_lock");
67 output_lock = new Condition(1, "CWindowTool::output_lock");
68 tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
71 CWindowTool::~CWindowTool()
82 void CWindowTool::start_tool(int operation)
84 CWindowToolGUI *new_gui = 0;
87 //printf("CWindowTool::start_tool 1\n");
88 if(current_tool != operation)
90 int previous_tool = current_tool;
91 current_tool = operation;
95 new_gui = new CWindowEyedropGUI(mwindow, this);
98 new_gui = new CWindowCropGUI(mwindow, this);
101 new_gui = new CWindowCameraGUI(mwindow, this);
103 case CWINDOW_PROJECTOR:
104 new_gui = new CWindowProjectorGUI(mwindow, this);
107 new_gui = new CWindowMaskGUI(mwindow, this);
110 new_gui = new CWindowRulerGUI(mwindow, this);
112 case CWINDOW_PROTECT:
113 mwindow->edl->session->tool_window = 0;
114 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(0);
122 //printf("CWindowTool::start_tool 1\n");
128 // Wait for previous tool GUI to finish
129 output_lock->lock("CWindowTool::start_tool");
130 this->tool_gui = new_gui;
131 tool_gui->create_objects();
132 if( previous_tool == CWINDOW_PROTECT || previous_tool == CWINDOW_NONE ) {
133 mwindow->edl->session->tool_window = 1;
134 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
136 mwindow->edl->session->tool_window = new_gui ? 1 : 0;
137 update_show_window();
139 // Signal thread to run next tool GUI
140 input_lock->unlock();
142 //printf("CWindowTool::start_tool 1\n");
147 tool_gui->lock_window("CWindowTool::start_tool");
149 tool_gui->unlock_window();
152 //printf("CWindowTool::start_tool 2\n");
157 void CWindowTool::stop_tool()
161 tool_gui->lock_window("CWindowTool::stop_tool");
162 tool_gui->set_done(0);
163 tool_gui->unlock_window();
167 void CWindowTool::show_tool()
169 if(tool_gui && mwindow->edl->session->tool_window)
171 tool_gui->lock_window("CWindowTool::show_tool");
172 tool_gui->show_window();
173 tool_gui->unlock_window();
177 void CWindowTool::hide_tool()
179 if(tool_gui && mwindow->edl->session->tool_window)
181 tool_gui->lock_window("CWindowTool::show_tool");
182 tool_gui->hide_window();
183 tool_gui->unlock_window();
187 void CWindowTool::raise_tool()
189 if(tool_gui && mwindow->edl->session->tool_window)
191 tool_gui->lock_window("CWindowTool::show_tool");
192 tool_gui->raise_window();
193 tool_gui->unlock_window();
198 void CWindowTool::run()
202 input_lock->lock("CWindowTool::run");
205 tool_gui->run_window();
206 tool_gui_lock->lock("CWindowTool::run");
209 tool_gui_lock->unlock();
211 output_lock->unlock();
215 void CWindowTool::update_show_window()
219 tool_gui->lock_window("CWindowTool::update_show_window");
221 if(mwindow->edl->session->tool_window)
224 tool_gui->show_window();
227 tool_gui->hide_window();
230 tool_gui->unlock_window();
234 void CWindowTool::raise_window()
238 gui->unlock_window();
239 tool_gui->lock_window("CWindowTool::raise_window");
240 tool_gui->raise_window();
241 tool_gui->unlock_window();
242 gui->lock_window("CWindowTool::raise_window");
246 void CWindowTool::update_values()
248 tool_gui_lock->lock("CWindowTool::update_values");
251 tool_gui->lock_window("CWindowTool::update_values");
254 tool_gui->unlock_window();
256 tool_gui_lock->unlock();
265 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
271 mwindow->session->ctool_x,
272 mwindow->session->ctool_y,
281 this->mwindow = mwindow;
282 this->thread = thread;
283 current_operation = 0;
286 CWindowToolGUI::~CWindowToolGUI()
290 int CWindowToolGUI::close_event()
294 mwindow->edl->session->tool_window = 0;
296 thread->gui->lock_window("CWindowToolGUI::close_event");
297 thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
298 thread->gui->flush();
299 thread->gui->unlock_window();
300 lock_window("CWindowToolGUI::close_event");
304 int CWindowToolGUI::keypress_event()
308 switch( get_keypress() ) {
311 return close_event();
324 resend_event(thread->gui);
331 int CWindowToolGUI::translation_event()
333 mwindow->session->ctool_x = get_x();
334 mwindow->session->ctool_y = get_y();
339 void CWindowToolGUI::update_preview(int changed_edl)
342 draw_preview(changed_edl);
343 lock_window("CWindowToolGUI::update_preview");
346 void CWindowToolGUI::draw_preview(int changed_edl)
348 CWindowGUI *cgui = mwindow->cwindow->gui;
349 cgui->lock_window("CWindowToolGUI::draw_preview");
350 int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
351 cgui->sync_parameters(change_type, 0, 1);
352 cgui->unlock_window();
356 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
357 : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 70, 3)
360 set_log_floatincrement(log_increment);
363 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
364 : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 70)
368 int CWindowCoord::handle_event()
370 gui->event_caller = this;
376 CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
377 : BC_GenericButton(x, y, _("Apply"))
379 this->mwindow = mwindow;
380 this->crop_gui = crop_gui;
382 int CWindowCropApply::handle_event()
384 mwindow->crop_video(crop_gui->crop_mode->mode);
389 int CWindowCropApply::keypress_event()
391 if(get_keypress() == 0xd)
399 const char *CWindowCropOpMode::crop_ops[] = {
405 CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
406 int mode, int x, int y)
407 : BC_PopupMenu(x, y, 140, _(crop_ops[mode]), 1)
409 this->mwindow = mwindow;
410 this->crop_gui = crop_gui;
413 CWindowCropOpMode::~CWindowCropOpMode()
417 void CWindowCropOpMode::create_objects()
419 for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
420 add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
424 int CWindowCropOpMode::handle_event()
426 set_text(_(crop_ops[mode]));
430 CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
437 int CWindowCropOpItem::handle_event()
439 popup->set_text(get_text());
441 return popup->handle_event();
448 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
449 : CWindowToolGUI(mwindow,
451 _(PROGRAM_NAME ": Crop"),
458 CWindowCropGUI::~CWindowCropGUI()
462 void CWindowCropGUI::create_objects()
467 lock_window("CWindowCropGUI::create_objects");
469 int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
470 BC_Title::calculate_h(this, "X")) + 5;
471 add_subwindow(title = new BC_Title(x, y, "X1:"));
472 column1 = MAX(column1, title->get_w());
474 add_subwindow(title = new BC_Title(x, y, _("W:")));
475 column1 = MAX(column1, title->get_w());
477 add_subwindow(new CWindowCropApply(mwindow, this, x, y));
481 x1 = new CWindowCoord(thread->tool_gui, x, y,
482 mwindow->edl->session->crop_x1);
483 x1->create_objects();
484 x1->set_boundaries((int64_t)0, (int64_t)65536);
486 width = new CWindowCoord(thread->tool_gui, x, y,
487 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
488 width->create_objects();
489 width->set_boundaries((int64_t)1, (int64_t)65536);
492 x += x1->get_w() + 10;
495 add_subwindow(title = new BC_Title(x, y, "Y1:"));
496 column2 = MAX(column2, title->get_w());
498 add_subwindow(title = new BC_Title(x, y, _("H:")));
499 column2 = MAX(column2, title->get_w());
504 y1 = new CWindowCoord(thread->tool_gui, x, y,
505 mwindow->edl->session->crop_y1);
506 y1->create_objects();
507 y1->set_boundaries((int64_t)0, (int64_t)65536);
510 height = new CWindowCoord(thread->tool_gui, x, y,
511 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
512 height->create_objects();
513 height->set_boundaries((int64_t)1, (int64_t)65536);
516 add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
517 CROP_REFORMAT, x, y));
518 crop_mode->create_objects();
523 void CWindowCropGUI::handle_event()
526 new_x1 = atol(x1->get_text());
527 new_y1 = atol(y1->get_text());
528 if(new_x1 != mwindow->edl->session->crop_x1)
530 mwindow->edl->session->crop_x2 = new_x1 +
531 mwindow->edl->session->crop_x2 -
532 mwindow->edl->session->crop_x1;
533 mwindow->edl->session->crop_x1 = new_x1;
535 if(new_y1 != mwindow->edl->session->crop_y1)
537 mwindow->edl->session->crop_y2 = new_y1 +
538 mwindow->edl->session->crop_y2 -
539 mwindow->edl->session->crop_y1;
540 mwindow->edl->session->crop_y1 = atol(y1->get_text());
542 mwindow->edl->session->crop_x2 = atol(width->get_text()) +
543 mwindow->edl->session->crop_x1;
544 mwindow->edl->session->crop_y2 = atol(height->get_text()) +
545 mwindow->edl->session->crop_y1;
547 mwindow->cwindow->gui->canvas->redraw(1);
550 void CWindowCropGUI::update()
552 x1->update((int64_t)mwindow->edl->session->crop_x1);
553 y1->update((int64_t)mwindow->edl->session->crop_y1);
554 width->update((int64_t)mwindow->edl->session->crop_x2 -
555 mwindow->edl->session->crop_x1);
556 height->update((int64_t)mwindow->edl->session->crop_y2 -
557 mwindow->edl->session->crop_y1);
561 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
562 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), 220, 290)
566 CWindowEyedropGUI::~CWindowEyedropGUI()
570 void CWindowEyedropGUI::create_objects()
572 int margin = mwindow->theme->widget_border;
575 int x2 = 70, x3 = x2 + 60;
576 lock_window("CWindowEyedropGUI::create_objects");
577 BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
578 add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
579 y += title0->get_h() + margin;
580 add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
581 y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
583 add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
584 y += title1->get_h() + margin;
585 add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
586 y += title2->get_h() + margin;
587 add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
588 y += title3->get_h() + margin;
590 add_subwindow(title4 = new BC_Title(x, y, "Y:"));
591 y += title4->get_h() + margin;
592 add_subwindow(title5 = new BC_Title(x, y, "U:"));
593 y += title5->get_h() + margin;
594 add_subwindow(title6 = new BC_Title(x, y, "V:"));
596 add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
598 radius = new CWindowCoord(this, x2, title7->get_y(),
599 mwindow->edl->session->eyedrop_radius);
600 radius->create_objects();
601 radius->set_boundaries((int64_t)0, (int64_t)255);
603 add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
604 add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
605 add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
606 add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
608 add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
609 add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
610 add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
611 add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
613 y = title6->get_y() + this->v->get_h() + 2*margin;
614 add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
615 y += sample->get_h() + margin;
616 add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
621 void CWindowEyedropGUI::update()
623 char string[BCTEXTLEN];
624 sprintf(string, "%d, %d",
625 thread->gui->eyedrop_x,
626 thread->gui->eyedrop_y);
627 current->update(string);
629 radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
631 LocalSession *local_session = mwindow->edl->local_session;
632 int use_max = local_session->use_max;
633 float r = use_max ? local_session->red_max : local_session->red;
634 float g = use_max ? local_session->green_max : local_session->green;
635 float b = use_max ? local_session->blue_max : local_session->blue;
636 this->red->update(r);
637 this->green->update(g);
638 this->blue->update(b);
640 int rx = 255*r + 0.5; bclamp(rx,0,255);
641 int gx = 255*g + 0.5; bclamp(gx,0,255);
642 int bx = 255*b + 0.5; bclamp(bx,0,255);
643 char rgb_text[BCSTRLEN];
644 sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
645 rgb_hex->update(rgb_text);
648 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
650 this->u->update(u); u += 0.5;
651 this->v->update(v); v += 0.5;
653 int yx = 255*y + 0.5; bclamp(yx,0,255);
654 int ux = 255*u + 0.5; bclamp(ux,0,255);
655 int vx = 255*v + 0.5; bclamp(vx,0,255);
656 char yuv_text[BCSTRLEN];
657 sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
658 yuv_hex->update(yuv_text);
660 int rgb = (rx << 16) | (gx << 8) | (bx << 0);
661 sample->set_color(rgb);
662 sample->draw_box(0, 0, sample->get_w(), sample->get_h());
663 sample->set_color(BLACK);
664 sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
668 void CWindowEyedropGUI::handle_event()
670 int new_radius = atoi(radius->get_text());
671 if(new_radius != mwindow->edl->session->eyedrop_radius)
673 CWindowGUI *gui = mwindow->cwindow->gui;
674 if(gui->eyedrop_visible)
676 gui->lock_window("CWindowEyedropGUI::handle_event");
679 gui->canvas->do_eyedrop(rerender, 0, 1);
682 mwindow->edl->session->eyedrop_radius = new_radius;
684 if(gui->eyedrop_visible)
688 gui->canvas->do_eyedrop(rerender, 0, 1);
689 gui->unlock_window();
696 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
698 // Configuration for all possible Keyframe Curve Mode toggles
700 FloatAuto::t_mode mode;
706 const _CVD Camera_Crv_Smooth =
710 N_("\"smooth\" Curve on current Camera Keyframes")
712 const _CVD Camera_Crv_Linear =
716 N_("\"linear\" Curve on current Camera Keyframes")
718 const _CVD Projector_Crv_Smooth =
722 N_("\"smooth\" Curve on current Projector Keyframes")
724 const _CVD Projector_Crv_Linear =
728 N_("\"linear\" Curve on current Projector Keyframes")
731 // Implementation Class für Keyframe Curve Mode buttons
733 // This button reflects the state of the "current" keyframe
734 // (the nearest keyframe on the left) for all three automation
735 // lines together. Clicking on this button (re)sets the curve
736 // mode for the three "current" keyframes simultanously, but
737 // never creates a new keyframe.
739 class CWindowCurveToggle : public BC_Toggle
742 CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
743 void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
752 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
753 : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
757 this->mwindow = mwindow;
758 set_tooltip(_(cfg.tooltip));
761 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
763 // the toggle state is only set to ON if all
764 // three automation lines have the same curve mode.
765 // For mixed states the toggle stays off.
766 set_value( x->curve_mode == this->cfg.mode &&
767 y->curve_mode == this->cfg.mode &&
768 z->curve_mode == this->cfg.mode
769 ,true // redraw to show new state
773 int CWindowCurveToggle::handle_event()
775 Track *track = mwindow->cwindow->calculate_affected_track();
777 FloatAuto *x=0, *y=0, *z=0;
778 mwindow->cwindow->calculate_affected_autos(track,
779 &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
780 if( x ) x->change_curve_mode(cfg.mode);
781 if( y ) y->change_curve_mode(cfg.mode);
782 if( z ) z->change_curve_mode(cfg.mode);
785 gui->update_preview();
792 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
793 CWindowEyedropGUI *gui, int x, int y)
794 : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
796 this->mwindow = mwindow;
800 int CWindowEyedropCheckBox::handle_event()
802 mwindow->edl->local_session->use_max = get_value();
809 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
810 : CWindowToolGUI(mwindow,
812 _(PROGRAM_NAME ": Camera"),
817 CWindowCameraGUI::~CWindowCameraGUI()
821 void CWindowCameraGUI::create_objects()
823 int x = 10, y = 10, x1;
824 Track *track = mwindow->cwindow->calculate_affected_track();
825 FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
829 lock_window("CWindowCameraGUI::create_objects");
831 mwindow->cwindow->calculate_affected_autos(track,
832 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
835 add_subwindow(title = new BC_Title(x, y, "X:"));
837 this->x = new CWindowCoord(this, x, y,
838 x_auto ? x_auto->get_value() : (float)0);
839 this->x->create_objects();
844 add_subwindow(title = new BC_Title(x, y, "Y:"));
846 this->y = new CWindowCoord(this, x, y,
847 y_auto ? y_auto->get_value() : (float)0);
848 this->y->create_objects();
851 add_subwindow(title = new BC_Title(x, y, "Z:"));
853 this->z = new CWindowCoord(this, x, y,
854 z_auto ? z_auto->get_value() : (float)1);
855 this->z->create_objects();
856 this->z->set_increment(0.01);
860 add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
861 x1 += button->get_w();
862 add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
863 x1 += button->get_w();
864 add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
865 // additional Buttons to control the curve mode of the "current" keyframe
866 x1 += button->get_w() + 15;
867 add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
868 x1 += button->get_w() + 10;
869 add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
871 y += button->get_h();
873 add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
874 x1 += button->get_w();
875 add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
876 x1 += button->get_w();
877 add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
878 x1 += button->get_w() + 15;
879 add_subwindow(this->add_keyframe = new CWindowCameraAddKeyframe(mwindow, this, x1, y));
880 x1 += button->get_w() + 10;
881 add_subwindow(this->reset = new CWindowCameraReset(mwindow, this, x1, y));
883 // fill in current auto keyframe values, set toggle states.
888 void CWindowCameraGUI::handle_event()
890 FloatAuto *x_auto = 0;
891 FloatAuto *y_auto = 0;
892 FloatAuto *z_auto = 0;
893 Track *track = mwindow->cwindow->calculate_affected_track();
896 mwindow->undo->update_undo_before(_("camera"), this);
897 if(event_caller == x)
899 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
900 track->automation->autos[AUTOMATION_CAMERA_X],
904 x_auto->set_value(atof(x->get_text()));
910 if(event_caller == y)
912 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
913 track->automation->autos[AUTOMATION_CAMERA_Y],
917 y_auto->set_value(atof(y->get_text()));
923 if(event_caller == z)
925 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
926 track->automation->autos[AUTOMATION_CAMERA_Z],
930 float zoom = atof(z->get_text());
931 if(zoom > 100.) zoom = 100.;
933 if(zoom < 0.01) zoom = 0.01;
934 // Doesn't allow user to enter from scratch
935 // if(zoom != atof(z->get_text()))
938 z_auto->set_value(zoom);
939 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
940 mwindow->gui->draw_overlays(1);
941 mwindow->gui->unlock_window();
947 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
951 void CWindowCameraGUI::update()
953 FloatAuto *x_auto = 0;
954 FloatAuto *y_auto = 0;
955 FloatAuto *z_auto = 0;
956 Track *track = mwindow->cwindow->calculate_affected_track();
958 mwindow->cwindow->calculate_affected_autos(track,
959 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
963 x->update(x_auto->get_value());
965 y->update(y_auto->get_value());
967 float value = z_auto->get_value();
969 thread->gui->lock_window("CWindowCameraGUI::update");
970 thread->gui->composite_panel->cpanel_zoom->update(value);
971 thread->gui->unlock_window();
974 if( x_auto && y_auto && z_auto )
976 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
977 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
984 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
985 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
988 this->mwindow = mwindow;
989 set_tooltip(_("Left justify"));
991 int CWindowCameraLeft::handle_event()
993 FloatAuto *x_auto = 0;
994 FloatAuto *z_auto = 0;
995 Track *track = mwindow->cwindow->calculate_affected_track();
997 mwindow->cwindow->calculate_affected_autos(track,
998 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1001 if(x_auto && z_auto)
1004 track->get_source_dimensions(
1005 mwindow->edl->local_session->get_selectionstart(1),
1011 mwindow->undo->update_undo_before(_("camera"), 0);
1013 (double)track->track_w / z_auto->get_value() / 2 -
1015 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1017 gui->update_preview();
1025 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1026 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1029 this->mwindow = mwindow;
1030 set_tooltip(_("Center horizontal"));
1032 int CWindowCameraCenter::handle_event()
1034 FloatAuto *x_auto = 0;
1035 Track *track = mwindow->cwindow->calculate_affected_track();
1037 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1038 track->automation->autos[AUTOMATION_CAMERA_X],
1043 mwindow->undo->update_undo_before(_("camera"), 0);
1044 x_auto->set_value(0);
1046 gui->update_preview();
1047 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1054 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1055 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1058 this->mwindow = mwindow;
1059 set_tooltip(_("Right justify"));
1061 int CWindowCameraRight::handle_event()
1063 FloatAuto *x_auto = 0;
1064 FloatAuto *z_auto = 0;
1065 Track *track = mwindow->cwindow->calculate_affected_track();
1067 mwindow->cwindow->calculate_affected_autos(track,
1068 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1071 if(x_auto && z_auto)
1074 track->get_source_dimensions(
1075 mwindow->edl->local_session->get_selectionstart(1),
1081 mwindow->undo->update_undo_before(_("camera"), 0);
1082 x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1085 gui->update_preview();
1086 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1094 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1095 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1098 this->mwindow = mwindow;
1099 set_tooltip(_("Top justify"));
1101 int CWindowCameraTop::handle_event()
1103 FloatAuto *y_auto = 0;
1104 FloatAuto *z_auto = 0;
1105 Track *track = mwindow->cwindow->calculate_affected_track();
1107 mwindow->cwindow->calculate_affected_autos(track,
1108 0, &y_auto, &z_auto, 1, 0, 1, 0);
1111 if(y_auto && z_auto)
1114 track->get_source_dimensions(
1115 mwindow->edl->local_session->get_selectionstart(1),
1121 mwindow->undo->update_undo_before(_("camera"), 0);
1122 y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1125 gui->update_preview();
1126 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1134 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1135 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1138 this->mwindow = mwindow;
1139 set_tooltip(_("Center vertical"));
1141 int CWindowCameraMiddle::handle_event()
1143 FloatAuto *y_auto = 0;
1144 Track *track = mwindow->cwindow->calculate_affected_track();
1146 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1147 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1151 mwindow->undo->update_undo_before(_("camera"), 0);
1152 y_auto->set_value(0);
1154 gui->update_preview();
1155 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1162 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1163 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1166 this->mwindow = mwindow;
1167 set_tooltip(_("Bottom justify"));
1169 int CWindowCameraBottom::handle_event()
1171 FloatAuto *y_auto = 0;
1172 FloatAuto *z_auto = 0;
1173 Track *track = mwindow->cwindow->calculate_affected_track();
1175 mwindow->cwindow->calculate_affected_autos(track,
1176 0, &y_auto, &z_auto, 1, 0, 1, 0);
1179 if(y_auto && z_auto)
1182 track->get_source_dimensions(
1183 mwindow->edl->local_session->get_selectionstart(1),
1189 mwindow->undo->update_undo_before(_("camera"), 0);
1190 y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1193 gui->update_preview();
1194 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1201 CWindowCameraAddKeyframe::CWindowCameraAddKeyframe(MWindow *mwindow,
1202 CWindowToolGUI *gui, int x, int y)
1203 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1205 this->mwindow = mwindow;
1207 set_tooltip(_("Add Keyframe: Shift-F11"));
1210 int CWindowCameraAddKeyframe::handle_event()
1212 return gui->press(&CWindowCanvas::camera_keyframe);
1215 CWindowCameraReset::CWindowCameraReset(MWindow *mwindow,
1216 CWindowToolGUI *gui, int x, int y)
1217 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1219 this->mwindow = mwindow;
1221 set_tooltip(_("Reset Camera: F11"));
1224 int CWindowCameraReset::handle_event()
1226 return gui->press(&CWindowCanvas::reset_camera);
1230 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1231 : CWindowToolGUI(mwindow,
1233 _(PROGRAM_NAME ": Projector"),
1238 CWindowProjectorGUI::~CWindowProjectorGUI()
1241 void CWindowProjectorGUI::create_objects()
1243 int x = 10, y = 10, x1;
1244 Track *track = mwindow->cwindow->calculate_affected_track();
1245 FloatAuto *x_auto = 0;
1246 FloatAuto *y_auto = 0;
1247 FloatAuto *z_auto = 0;
1251 lock_window("CWindowProjectorGUI::create_objects");
1253 mwindow->cwindow->calculate_affected_autos(track,
1254 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1257 add_subwindow(title = new BC_Title(x, y, "X:"));
1258 x += title->get_w();
1259 this->x = new CWindowCoord(this, x, y,
1260 x_auto ? x_auto->get_value() : (float)0);
1261 this->x->create_objects();
1264 add_subwindow(title = new BC_Title(x, y, "Y:"));
1265 x += title->get_w();
1266 this->y = new CWindowCoord(this, x, y,
1267 y_auto ? y_auto->get_value() : (float)0);
1268 this->y->create_objects();
1271 add_subwindow(title = new BC_Title(x, y, "Z:"));
1272 x += title->get_w();
1273 this->z = new CWindowCoord(this, x, y,
1274 z_auto ? z_auto->get_value() : (float)1);
1275 this->z->create_objects();
1276 this->z->set_increment(0.01);
1280 add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1281 x1 += button->get_w();
1282 add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1283 x1 += button->get_w();
1284 add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1285 // additional Buttons to control the curve mode of the "current" keyframe
1286 x1 += button->get_w() + 15;
1287 add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1288 x1 += button->get_w() + 10;
1289 add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1291 y += button->get_h();
1293 add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1294 x1 += button->get_w();
1295 add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1296 x1 += button->get_w();
1297 add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1298 x1 += button->get_w() + 15;
1299 add_subwindow(this->add_keyframe = new CWindowProjectorAddKeyframe(mwindow, this, x1, y));
1300 x1 += button->get_w() + 10;
1301 add_subwindow(this->reset = new CWindowProjectorReset(mwindow, this, x1, y));
1303 // fill in current auto keyframe values, set toggle states.
1308 void CWindowProjectorGUI::handle_event()
1310 FloatAuto *x_auto = 0;
1311 FloatAuto *y_auto = 0;
1312 FloatAuto *z_auto = 0;
1313 Track *track = mwindow->cwindow->calculate_affected_track();
1317 mwindow->undo->update_undo_before(_("projector"), this);
1318 if(event_caller == x)
1320 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1321 track->automation->autos[AUTOMATION_PROJECTOR_X],
1325 x_auto->set_value(atof(x->get_text()));
1331 if(event_caller == y)
1333 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1334 track->automation->autos[AUTOMATION_PROJECTOR_Y],
1338 y_auto->set_value(atof(y->get_text()));
1344 if(event_caller == z)
1346 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1347 track->automation->autos[AUTOMATION_PROJECTOR_Z],
1351 float zoom = atof(z->get_text());
1352 if(zoom > 100.) zoom = 100.;
1353 else if(zoom < 0.01) zoom = 0.01;
1354 // if (zoom != atof(z->get_text()))
1356 z_auto->set_value(zoom);
1358 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1359 mwindow->gui->draw_overlays(1);
1360 mwindow->gui->unlock_window();
1366 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1370 void CWindowProjectorGUI::update()
1372 FloatAuto *x_auto = 0;
1373 FloatAuto *y_auto = 0;
1374 FloatAuto *z_auto = 0;
1375 Track *track = mwindow->cwindow->calculate_affected_track();
1377 mwindow->cwindow->calculate_affected_autos(track,
1378 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1382 x->update(x_auto->get_value());
1384 y->update(y_auto->get_value());
1386 float value = z_auto->get_value();
1388 thread->gui->lock_window("CWindowProjectorGUI::update");
1389 thread->gui->composite_panel->cpanel_zoom->update(value);
1390 thread->gui->unlock_window();
1393 if( x_auto && y_auto && z_auto )
1395 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1396 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1400 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1401 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1404 this->mwindow = mwindow;
1405 set_tooltip(_("Left justify"));
1407 int CWindowProjectorLeft::handle_event()
1409 FloatAuto *x_auto = 0;
1410 FloatAuto *z_auto = 0;
1411 Track *track = mwindow->cwindow->calculate_affected_track();
1413 mwindow->cwindow->calculate_affected_autos(track,
1414 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1416 if(x_auto && z_auto)
1418 mwindow->undo->update_undo_before(_("projector"), 0);
1419 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1420 (double)mwindow->edl->session->output_w / 2 );
1422 gui->update_preview();
1423 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1430 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1431 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1434 this->mwindow = mwindow;
1435 set_tooltip(_("Center horizontal"));
1437 int CWindowProjectorCenter::handle_event()
1439 FloatAuto *x_auto = 0;
1440 Track *track = mwindow->cwindow->calculate_affected_track();
1442 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1443 track->automation->autos[AUTOMATION_PROJECTOR_X],
1448 mwindow->undo->update_undo_before(_("projector"), 0);
1449 x_auto->set_value(0);
1451 gui->update_preview();
1452 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1459 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1460 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1463 this->mwindow = mwindow;
1464 set_tooltip(_("Right justify"));
1466 int CWindowProjectorRight::handle_event()
1468 FloatAuto *x_auto = 0;
1469 FloatAuto *z_auto = 0;
1470 Track *track = mwindow->cwindow->calculate_affected_track();
1472 mwindow->cwindow->calculate_affected_autos(track,
1473 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1476 if(x_auto && z_auto)
1478 mwindow->undo->update_undo_before(_("projector"), 0);
1479 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1480 (double)mwindow->edl->session->output_w / 2));
1482 gui->update_preview();
1483 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1490 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1491 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1494 this->mwindow = mwindow;
1495 set_tooltip(_("Top justify"));
1497 int CWindowProjectorTop::handle_event()
1499 FloatAuto *y_auto = 0;
1500 FloatAuto *z_auto = 0;
1501 Track *track = mwindow->cwindow->calculate_affected_track();
1503 mwindow->cwindow->calculate_affected_autos(track,
1504 0, &y_auto, &z_auto, 0, 0, 1, 0);
1507 if(y_auto && z_auto)
1509 mwindow->undo->update_undo_before(_("projector"), 0);
1510 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1511 (double)mwindow->edl->session->output_h / 2 );
1513 gui->update_preview();
1514 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1521 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1522 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1525 this->mwindow = mwindow;
1526 set_tooltip(_("Center vertical"));
1528 int CWindowProjectorMiddle::handle_event()
1530 FloatAuto *y_auto = 0;
1531 Track *track = mwindow->cwindow->calculate_affected_track();
1533 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1534 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1538 mwindow->undo->update_undo_before(_("projector"), 0);
1539 y_auto->set_value(0);
1541 gui->update_preview();
1542 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1549 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1550 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1553 this->mwindow = mwindow;
1554 set_tooltip(_("Bottom justify"));
1556 int CWindowProjectorBottom::handle_event()
1558 FloatAuto *y_auto = 0;
1559 FloatAuto *z_auto = 0;
1560 Track *track = mwindow->cwindow->calculate_affected_track();
1562 mwindow->cwindow->calculate_affected_autos(track,
1563 0, &y_auto, &z_auto, 0, 0, 1, 0);
1566 if(y_auto && z_auto)
1568 mwindow->undo->update_undo_before(_("projector"), 0);
1569 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1570 (double)mwindow->edl->session->output_h / 2));
1572 gui->update_preview();
1573 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1579 CWindowProjectorAddKeyframe::CWindowProjectorAddKeyframe(MWindow *mwindow,
1580 CWindowToolGUI *gui, int x, int y)
1581 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1583 this->mwindow = mwindow;
1585 set_tooltip(_("Add Keyframe: Shift-F12"));
1588 int CWindowProjectorAddKeyframe::handle_event()
1590 return gui->press(&CWindowCanvas::projector_keyframe);
1593 CWindowProjectorReset::CWindowProjectorReset(MWindow *mwindow,
1594 CWindowToolGUI *gui, int x, int y)
1595 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1597 this->mwindow = mwindow;
1599 set_tooltip(_("Reset Projector: F12"));
1602 int CWindowProjectorReset::handle_event()
1604 return gui->press(&CWindowCanvas::reset_projector);
1607 int CWindowToolGUI::press(void (CWindowCanvas::*fn)())
1610 CWindowGUI *cw_gui = thread->gui;
1611 cw_gui->lock_window("CWindowGUI::press");
1612 (cw_gui->canvas->*fn)();
1613 cw_gui->unlock_window();
1614 lock_window("CWindowToolGUI::press");
1618 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1619 int x, int y, int w, const char *text)
1620 : BC_PopupTextBox(gui, 0, text, x, y, w, 120)
1622 this->mwindow = mwindow;
1626 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1630 int CWindowMaskOnTrack::handle_event()
1632 CWindowMaskItem *track_item = 0;
1633 int k = get_number(), track_id = -1;
1634 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1636 track_item = (CWindowMaskItem *)track_items[k];
1637 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1638 if( track && track->record ) track_id = track->get_id();
1641 track_id = mwindow->cwindow->mask_track_id;
1642 set_back_color(track_id >= 0 ?
1643 gui->get_resources()->text_background :
1644 gui->get_resources()->text_background_disarmed);
1645 if( mwindow->cwindow->mask_track_id != track_id )
1646 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1647 mwindow->cwindow->mask_track_id = track_id;
1648 mwindow->edl->local_session->solo_track_id = -1;
1649 gui->mask_solo_track->update(0);
1651 gui->update_preview(1);
1655 void CWindowMaskOnTrack::update_items()
1657 track_items.remove_all_objects();
1658 int high_color = gui->get_resources()->button_highlighted;
1659 for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1660 if( track->data_type != TRACK_VIDEO ) continue;
1661 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1662 int color = !track->record ? RED : mask_autos->first ? high_color : -1;
1663 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1664 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1665 if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1666 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1668 update_list(&track_items);
1671 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1675 this->mwindow = mwindow;
1678 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1682 int CWindowMaskTrackTumbler::handle_up_event()
1687 int CWindowMaskTrackTumbler::handle_down_event()
1689 return do_event(-1);
1692 int CWindowMaskTrackTumbler::do_event(int dir)
1694 CWindowMaskItem *track_item = 0;
1695 CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1696 int n = gui->mask_on_track->track_items.size();
1697 int id = mwindow->cwindow->mask_track_id;
1700 while( --k >= 0 && items[k]->id != id );
1704 track_item = items[k];
1707 track_item = items[0];
1709 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1710 int track_id = track_item && track && track->record ? track_item->id : -1;
1711 gui->mask_on_track->set_back_color(track_id >= 0 ?
1712 gui->get_resources()->text_background :
1713 gui->get_resources()->text_background_disarmed);
1714 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1715 mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1716 mwindow->edl->local_session->solo_track_id = -1;
1717 gui->mask_solo_track->update(0);
1719 gui->update_preview(1);
1724 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1725 int x, int y, const char *text)
1726 : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
1728 this->mwindow = mwindow;
1732 CWindowMaskName::~CWindowMaskName()
1736 int CWindowMaskName::handle_event()
1743 //printf("CWindowMaskGUI::update 1\n");
1744 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1746 int k = get_number();
1747 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1748 else mwindow->edl->session->cwindow_mask = k;
1749 if( k >= 0 && k < mask_items.size() ) {
1750 mask_items[k]->set_text(get_text());
1751 update_list(&mask_items);
1753 #ifdef USE_KEYFRAME_SPANNING
1754 MaskAuto temp_keyframe(mwindow->edl, autos);
1755 temp_keyframe.copy_data(keyframe);
1756 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1757 memset(submask->name, 0, sizeof(submask->name));
1758 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1759 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1761 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1762 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1763 memset(submask->name, 0, sizeof(submask->name));
1764 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1765 current = current == (MaskAuto*)autos->default_auto ?
1766 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1770 gui->update_preview();
1775 void CWindowMaskName::update_items(MaskAuto *keyframe)
1777 mask_items.remove_all_objects();
1778 int sz = !keyframe ? 0 : keyframe->masks.size();
1779 for( int i=0; i<SUBMASKS; ++i ) {
1780 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
1782 SubMask *sub_mask = keyframe->masks.get(i);
1783 strncpy(text, sub_mask->name, sizeof(text)-1);
1786 sprintf(text, "%d", i);
1787 mask_items.append(new CWindowMaskItem(text));
1789 update_list(&mask_items);
1793 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1794 int x, int y, int no, int v)
1795 : BC_CheckBox(x, y, v)
1797 this->mwindow = mwindow;
1802 CWindowMaskButton::~CWindowMaskButton()
1806 int CWindowMaskButton::handle_event()
1808 mwindow->edl->session->cwindow_mask = no;
1809 gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1811 gui->update_preview();
1815 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1819 this->mwindow = mwindow;
1823 CWindowMaskThumbler::~CWindowMaskThumbler()
1827 int CWindowMaskThumbler::handle_up_event()
1832 int CWindowMaskThumbler::handle_down_event()
1834 return do_event(-1);
1837 int CWindowMaskThumbler::do_event(int dir)
1839 int k = mwindow->edl->session->cwindow_mask;
1840 if( (k+=dir) >= SUBMASKS ) k = 0;
1841 else if( k < 0 ) k = SUBMASKS-1;
1842 mwindow->edl->session->cwindow_mask = k;
1843 gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1845 gui->update_preview();
1849 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1850 int x, int y, int no, int v)
1851 : BC_CheckBox(x, y, v)
1853 this->mwindow = mwindow;
1858 CWindowMaskEnable::~CWindowMaskEnable()
1862 int CWindowMaskEnable::handle_event()
1864 Track *track = mwindow->cwindow->calculate_mask_track();
1866 mwindow->undo->update_undo_before(_("mask enable"), this);
1869 track->masks |= bit;
1871 track->masks &= ~bit;
1873 gui->update_preview(1);
1874 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1879 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1880 CWindowMaskGUI *gui, int x, int y)
1881 : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1883 this->mwindow = mwindow;
1885 set_tooltip(_("Show/Hide mask"));
1888 int CWindowMaskUnclear::handle_event()
1890 Track *track = mwindow->cwindow->calculate_mask_track();
1892 mwindow->undo->update_undo_before(_("mask enables"), this);
1893 int m = (1<<SUBMASKS)-1;
1894 if( track->masks == m )
1898 for( int i=0; i<SUBMASKS; ++i )
1899 gui->mask_enables[i]->update((track->masks>>i) & 1);
1900 gui->update_preview(1);
1901 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
1906 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
1907 CWindowMaskGUI *gui, int x, int y, int v)
1908 : BC_CheckBox(x, y, v, _("Solo"))
1910 this->mwindow = mwindow;
1912 set_tooltip(_("Solo video track"));
1915 int CWindowMaskSoloTrack::handle_event()
1917 mwindow->edl->local_session->solo_track_id =
1918 get_value() ? mwindow->cwindow->mask_track_id : -1;
1919 gui->update_preview(1);
1923 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
1926 calculate_extents(gui, &w, &h, _("Solo"));
1930 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
1931 CWindowMaskGUI *gui, int x, int y)
1932 : BC_GenericButton(x, y, _("Delete"))
1934 this->mwindow = mwindow;
1936 set_tooltip(_("Delete mask"));
1939 int CWindowMaskDelMask::handle_event()
1948 // Get existing keyframe
1949 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1952 mwindow->undo->update_undo_before(_("mask delete"), 0);
1954 #ifdef USE_KEYFRAME_SPANNING
1955 // Create temp keyframe
1956 MaskAuto temp_keyframe(mwindow->edl, autos);
1957 temp_keyframe.copy_data(keyframe);
1958 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1959 submask->points.remove_all_objects();
1961 // Commit change to span of keyframes
1962 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1964 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1965 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1966 submask->points.remove_all_objects();
1967 current = current == (MaskAuto*)autos->default_auto ?
1968 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1972 if( mwindow->cwindow->gui->affected_point >= total_points )
1973 mwindow->cwindow->gui->affected_point =
1974 total_points > 0 ? total_points-1 : 0;
1977 gui->update_preview();
1978 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1984 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
1985 CWindowMaskGUI *gui, int x, int y)
1986 : BC_GenericButton(x, y, _("Delete"))
1988 this->mwindow = mwindow;
1990 set_tooltip(_("Delete point"));
1993 int CWindowMaskDelPoint::handle_event()
2002 // Get existing keyframe
2003 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2005 mwindow->undo->update_undo_before(_("point delete"), 0);
2007 #ifdef USE_KEYFRAME_SPANNING
2008 // Create temp keyframe
2009 MaskAuto temp_keyframe(mwindow->edl, autos);
2010 temp_keyframe.copy_data(keyframe);
2012 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2013 int i = mwindow->cwindow->gui->affected_point;
2014 for( ; i<submask->points.total-1; ++i )
2015 *submask->points.values[i] = *submask->points.values[i+1];
2016 if( submask->points.total > 0 ) {
2017 point = submask->points.values[submask->points.total-1];
2018 submask->points.remove_object(point);
2020 total_points = submask->points.total;
2022 // Commit change to span of keyframes
2023 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
2026 MaskAuto *current = (MaskAuto*)autos->default_auto;
2028 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2029 int i = mwindow->cwindow->gui->affected_point;
2030 for( ; i<submask->points.total-1; ++i )
2031 *submask->points.values[i] = *submask->points.values[i+1];
2032 if( submask->points.total > 0 ) {
2033 point = submask->points.values[submask->points.total-1];
2034 submask->points.remove_object(point);
2036 total_points = submask->points.total;
2037 current = current == (MaskAuto*)autos->default_auto ?
2038 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2041 if( mwindow->cwindow->gui->affected_point >= total_points )
2042 mwindow->cwindow->gui->affected_point =
2043 total_points > 0 ? total_points-1 : 0;
2046 gui->update_preview();
2047 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
2054 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
2055 CWindowMaskGUI *gui, int x, int y)
2056 : BC_TumbleTextBox(gui,
2057 (int64_t)mwindow->cwindow->gui->affected_point,
2058 (int64_t)0, INT64_MAX, x, y, 70)
2060 this->mwindow = mwindow;
2064 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
2068 int CWindowMaskAffectedPoint::handle_event()
2070 int total_points = 0;
2071 int affected_point = atol(get_text());
2072 Track *track = mwindow->cwindow->calculate_mask_track();
2074 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2075 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
2077 SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2078 total_points = mask->points.size();
2081 int active_point = affected_point;
2082 if( affected_point >= total_points )
2083 affected_point = total_points - 1;
2084 if( affected_point < 0 )
2086 if( active_point != affected_point )
2087 update((int64_t)affected_point);
2088 mwindow->cwindow->gui->affected_point = affected_point;
2090 gui->update_preview();
2095 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2096 : BC_CheckBox(x, y, gui->focused, _("Focus"))
2098 this->mwindow = mwindow;
2100 set_tooltip(_("Center for rotate/scale"));
2103 CWindowMaskFocus::~CWindowMaskFocus()
2107 int CWindowMaskFocus::handle_event()
2109 gui->focused = get_value();
2111 gui->update_preview();
2115 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
2118 calculate_extents(gui, &w, &h, _("Focus"));
2122 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
2123 int x, int y, VFrame **data, int v, int id, const char *tip)
2124 : BC_Toggle(x, y, data, v)
2127 this->mwindow = mwindow;
2132 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2136 int CWindowMaskScaleXY::handle_event()
2138 gui->scale_mode = id;
2139 gui->mask_scale_x->update(id == MASK_SCALE_X);
2140 gui->mask_scale_y->update(id == MASK_SCALE_Y);
2141 gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2145 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2146 : BC_CheckBox(x, y, 0, _("Help"))
2148 this->mwindow = mwindow;
2150 set_tooltip(_("Show help text"));
2153 CWindowMaskHelp::~CWindowMaskHelp()
2157 int CWindowMaskHelp::handle_event()
2159 gui->helped = get_value();
2160 gui->resize_window(gui->get_w(),
2161 gui->helped ? gui->help_h : gui->help_y);
2166 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2167 : BC_CheckBox(x, y, gui->markers, _("Markers"))
2169 this->mwindow = mwindow;
2171 set_tooltip("Display points");
2174 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2178 int CWindowMaskDrawMarkers::handle_event()
2180 gui->markers = get_value();
2182 gui->update_preview();
2186 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2187 : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2189 this->mwindow = mwindow;
2191 set_tooltip("Display mask outline");
2194 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2198 int CWindowMaskDrawBoundary::handle_event()
2200 gui->boundary = get_value();
2202 gui->update_preview();
2207 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2208 : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, 64, 2)
2210 this->mwindow = mwindow;
2213 CWindowMaskFeather::~CWindowMaskFeather()
2217 int CWindowMaskFeather::update(float v)
2219 gui->feather_slider->update(v);
2220 return BC_TumbleTextBox::update(v);
2223 int CWindowMaskFeather::update_value(float v)
2230 #ifdef USE_KEYFRAME_SPANNING
2236 mwindow->undo->update_undo_before(_("mask feather"), this);
2238 // Get existing keyframe
2239 gui->get_keyframe(track, autos, keyframe,
2240 mask, point, create_it);
2242 int gang = gui->gang_feather->get_value();
2243 #ifdef USE_KEYFRAME_SPANNING
2244 MaskAuto temp_keyframe(mwindow->edl, autos);
2245 temp_keyframe.copy_data(keyframe);
2246 keyframe = &temp_keyframe;
2248 float change = v - mask->feather;
2249 int k = mwindow->edl->session->cwindow_mask;
2250 int n = gang ? keyframe->masks.size() : k+1;
2251 for( int i=gang? 0 : k; i<n; ++i ) {
2252 if( !gui->mask_enables[i]->get_value() ) continue;
2253 SubMask *sub_mask = keyframe->get_submask(i);
2254 float feather = sub_mask->feather + change;
2255 sub_mask->feather = feather;
2257 #ifdef USE_KEYFRAME_SPANNING
2258 autos->update_parameter(keyframe);
2260 gui->update_preview();
2263 mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2267 int CWindowMaskFeather::handle_event()
2269 float v = atof(get_text());
2270 if( fabsf(v) > MAX_FEATHER )
2271 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2272 gui->feather_slider->update(v);
2273 return gui->feather->update_value(v);
2276 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2277 CWindowMaskGUI *gui, int x, int y, int w, float v)
2278 : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2280 this->mwindow = mwindow;
2282 set_precision(0.01);
2283 timer = new Timer();
2289 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2294 int CWindowMaskFeatherSlider::handle_event()
2297 float v = get_value();
2298 if( fabsf(v) > MAX_FEATHER )
2299 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2300 if( stick && timer->get_difference() >= 250 )
2301 stick = 0; // no events for .25 sec
2302 if( stick && (last_v * (v-last_v)) < 0 )
2303 stick = 0; // dv changed direction
2312 if( max > MAX_FEATHER ) max = MAX_FEATHER;
2313 update(get_w(), v=last_v, -max-5, max+5);
2314 button_release_event();
2317 else if( v > max ) { v = max; sticky = 24; }
2318 else if( v < -max ) { v = -max; sticky = 24; }
2319 else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0; sticky = 16; }
2320 if( sticky ) { update(v); stick = sticky; timer->update(); }
2322 gui->feather->BC_TumbleTextBox::update(v);
2323 return gui->feather->update_value(v);
2326 int CWindowMaskFeatherSlider::update(float v)
2328 float vv = fabsf(v);
2329 if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2330 while( max < vv ) max *= 1.25;
2331 return update(get_w(), v, -max-5, max+5);
2333 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2335 return BC_FSlider::update(r, v, mn, mx);
2338 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2339 : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
2341 this->mwindow = mwindow;
2344 CWindowMaskFade::~CWindowMaskFade()
2348 int CWindowMaskFade::update(float v)
2350 gui->fade_slider->update(v);
2351 return BC_TumbleTextBox::update(v);
2354 int CWindowMaskFade::update_value(float v)
2361 #ifdef USE_KEYFRAME_SPANNING
2367 mwindow->undo->update_undo_before(_("mask fade"), this);
2369 // Get existing keyframe
2370 gui->get_keyframe(track, autos, keyframe,
2371 mask, point, create_it);
2373 int gang = gui->gang_fader->get_value();
2374 #ifdef USE_KEYFRAME_SPANNING
2375 MaskAuto temp_keyframe(mwindow->edl, autos);
2376 temp_keyframe.copy_data(keyframe);
2377 keyframe = &temp_keyframe;
2379 float change = v - mask->fader;
2380 int k = mwindow->edl->session->cwindow_mask;
2381 int n = gang ? keyframe->masks.size() : k+1;
2382 for( int i=gang? 0 : k; i<n; ++i ) {
2383 if( !gui->mask_enables[i]->get_value() ) continue;
2384 SubMask *sub_mask = keyframe->get_submask(i);
2385 float fader = sub_mask->fader + change;
2386 bclamp(fader, -100.f, 100.f);
2387 sub_mask->fader = fader;
2389 #ifdef USE_KEYFRAME_SPANNING
2390 autos->update_parameter(keyframe);
2392 gui->update_preview();
2395 mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2399 int CWindowMaskFade::handle_event()
2401 float v = atof(get_text());
2402 gui->fade_slider->update(v);
2403 return gui->fade->update_value(v);
2406 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2407 int x, int y, int w)
2408 : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2410 this->mwindow = mwindow;
2412 timer = new Timer();
2417 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2422 int CWindowMaskFadeSlider::handle_event()
2424 float v = 100*get_value()/200;
2426 int64_t ms = timer->get_difference();
2427 if( ms < 250 && --stick > 0 ) {
2428 if( get_value() == 0 ) return 1;
2436 else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2443 gui->fade->BC_TumbleTextBox::update(v);
2444 return gui->fade->update_value(v);
2447 int CWindowMaskFadeSlider::update(int64_t v)
2449 return BC_ISlider::update(200*v/100);
2452 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2453 CWindowMaskGUI *gui, int x, int y)
2454 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2456 this->mwindow = mwindow;
2458 set_tooltip(_("Gang fader"));
2461 CWindowMaskGangFader::~CWindowMaskGangFader()
2465 int CWindowMaskGangFader::handle_event()
2470 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2471 CWindowMaskGUI *gui, int x, int y)
2472 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2474 this->mwindow = mwindow;
2476 set_tooltip(_("Gang rotate/scale/translate"));
2479 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2483 int CWindowMaskGangFocus::handle_event()
2488 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2489 CWindowMaskGUI *gui, int x, int y)
2490 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2492 this->mwindow = mwindow;
2494 set_tooltip(_("Gang points"));
2497 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2501 int CWindowMaskGangPoint::handle_event()
2507 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2508 const char *tip, int type, int on, int x, int y, const char *images)
2509 : BC_Button(x, y, mwindow->theme->get_image_set(images))
2511 this->mwindow = mwindow;
2518 int CWindowMaskSmoothButton::handle_event()
2520 return gui->smooth_mask(type, on);
2523 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2524 : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2529 int CWindowMaskBeforePlugins::handle_event()
2536 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2539 int v = get_value();
2540 #ifdef USE_KEYFRAME_SPANNING
2541 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2542 temp_keyframe.copy_data(keyframe);
2543 temp_keyframe.apply_before_plugins = v;
2544 autos->update_parameter(&temp_keyframe);
2546 keyframe->apply_before_plugins = v;
2548 gui->update_preview();
2554 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2555 : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2560 int CWindowDisableOpenGLMasking::handle_event()
2567 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2570 int v = get_value();
2571 #ifdef USE_KEYFRAME_SPANNING
2572 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2573 temp_keyframe.copy_data(keyframe);
2574 temp_keyframe.disable_opengl_masking = v;
2575 autos->update_parameter(&temp_keyframe);
2577 keyframe->disable_opengl_masking = v;
2579 gui->update_preview();
2585 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2586 CWindowMaskGUI *gui, int x, int y)
2587 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2589 this->mwindow = mwindow;
2591 set_tooltip(_("Delete all masks"));
2594 CWindowMaskClrMask::~CWindowMaskClrMask()
2598 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2600 VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2601 return vfrm->get_w();
2604 int CWindowMaskClrMask::handle_event()
2612 // Get existing keyframe
2613 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2616 mwindow->undo->update_undo_before(_("del masks"), 0);
2617 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2618 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2622 gui->update_preview(1);
2626 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2627 CWindowMaskGUI *gui, int x, int y)
2628 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2630 this->mwindow = mwindow;
2632 set_tooltip(_("Gang feather"));
2635 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2639 int CWindowMaskGangFeather::handle_event()
2644 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2645 : CWindowToolGUI(mwindow, thread,
2646 _(PROGRAM_NAME ": Mask"), 440, 700)
2648 this->mwindow = mwindow;
2649 this->thread = thread;
2659 CWindowMaskGUI::~CWindowMaskGUI()
2661 lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2663 delete active_point;
2667 delete preset_dialog;
2670 void CWindowMaskGUI::create_objects()
2672 Theme *theme = mwindow->theme;
2673 int x = 10, y = 10, margin = theme->widget_border, t[SUBMASKS];
2674 int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2675 int clr_x = get_w()-x - clr_w;
2677 lock_window("CWindowMaskGUI::create_objects");
2678 BC_TitleBar *title_bar;
2679 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks on Track")));
2680 y += title_bar->get_h() + margin;
2682 add_subwindow(title = new BC_Title(x,y, _("Track:")));
2683 int x1 = x + 90, ww = clr_x-2*margin - x1;
2684 for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2686 Track *track = mwindow->cwindow->calculate_affected_track();
2687 const char *text = track ? track->title : "";
2688 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2689 mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, 100, text);
2690 mask_on_track->create_objects();
2691 mask_on_track->set_tooltip(_("Video track"));
2692 int x2 = x1 + mask_on_track->get_w();
2693 add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2694 mwindow->edl->local_session->solo_track_id = -1;
2695 add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2696 y += mask_on_track->get_h() + margin;
2697 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks")));
2698 y += title_bar->get_h() + margin;
2699 add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2700 mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2701 mask_name->create_objects();
2702 mask_name->set_tooltip(_("Mask name"));
2703 add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2704 add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2705 y += mask_name->get_h() + 2*margin;
2707 // add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2708 // y += bar->get_h() + 2*margin;
2710 add_subwindow(title = new BC_Title(x, y, _("Select:")));
2712 BC_CheckBox::calculate_extents(this, &bw, &bh);
2713 for( int i=0; i<SUBMASKS; ++i ) {
2714 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2715 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2716 add_subwindow(mask_buttons[i]);
2718 add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2720 for( int i=0; i<SUBMASKS; ++i ) {
2721 char text[BCSTRLEN]; sprintf(text, "%d", i);
2722 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2723 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2724 add_subwindow(mask_blabels[i]);
2726 y += mask_blabels[0]->get_h() + margin;
2727 add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2728 for( int i=0; i<SUBMASKS; ++i ) {
2729 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2730 add_subwindow(mask_enables[i]);
2732 add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2733 y += mask_enables[0]->get_h() + 2*margin;
2734 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Preset Shapes")));
2735 y += title_bar->get_h() + margin;
2736 add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2737 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2738 add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2739 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2740 add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2741 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2742 add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2743 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2744 add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2745 add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, 80));
2746 add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, 80));
2747 add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, 80));
2748 y += mask_load->get_h() + 2*margin;
2749 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Position & Scale")));
2750 y += title_bar->get_h() + 2*margin;
2751 add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, 80));
2752 add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, 80));
2754 add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2755 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2756 add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2757 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2758 add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2759 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2760 y += mask_center->get_h() + 2*margin;
2761 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Fade & Feather")));
2762 y += title_bar->get_h() + 2*margin;
2764 add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2765 fade = new CWindowMaskFade(mwindow, this, x1, y);
2766 fade->create_objects();
2767 x2 = x1 + fade->get_w() + 2*margin;
2768 int w2 = clr_x-2*margin - x2;
2769 add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2770 add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2771 y += fade->get_h() + margin;
2772 add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2773 feather = new CWindowMaskFeather(mwindow, this, x1, y);
2774 feather->create_objects();
2775 w2 = clr_x - 2*margin - x2;
2776 feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2777 add_subwindow(feather_slider);
2778 add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2779 y += feather->get_h() + 2*margin;
2780 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Mask Points")));
2781 y += title_bar->get_h() + margin;
2783 add_subwindow(title = new BC_Title(x, y, _("Point:")));
2784 active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2785 active_point->create_objects();
2786 // typ=0, this mask, this point
2787 add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2788 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2789 add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2790 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2791 add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2792 add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2793 y += active_point->get_h() + margin;
2794 add_subwindow(title = new BC_Title(x, y, "X:"));
2795 this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2796 this->x->create_objects();
2797 // typ>0, this mask, all points
2798 add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2799 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2800 add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2801 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2802 add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2803 y += this->x->get_h() + margin;
2804 add_subwindow(title = new BC_Title(x, y, "Y:"));
2805 this->y = new CWindowCoord(this, x1, y, (float)0.0);
2806 this->y->create_objects();
2807 // typ<0, all masks, all points
2808 add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2809 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2810 add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2811 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2812 add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2813 y += this->y->get_h() + 2*margin;
2814 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Pivot Point")));
2815 y += title_bar->get_h() + margin;
2817 add_subwindow(title = new BC_Title(x, y, "X:"));
2818 float cx = mwindow->edl->session->output_w / 2.f;
2819 focus_x = new CWindowCoord(this, x1, y, cx);
2820 focus_x->create_objects();
2821 add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2822 add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2823 y += focus_x->get_h() + margin;
2824 add_subwindow(title = new BC_Title(x, y, "Y:"));
2825 float cy = mwindow->edl->session->output_h / 2.f;
2826 focus_y = new CWindowCoord(this, x1, y, cy);
2827 focus_y->create_objects();
2828 y += focus_y->get_h() + 2*margin;
2829 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2830 y += bar->get_h() + margin;
2831 add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
2832 y += this->apply_before_plugins->get_h();
2833 add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
2834 add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2835 y += this->disable_opengl_masking->get_h() + 2*margin;
2837 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2838 y += bar->get_h() + 2*margin;
2839 add_subwindow(title = new BC_Title(x, y, _(
2840 "Shift+LMB: move an end point\n"
2841 "Ctrl+LMB: move a control point\n"
2842 "Alt+LMB: to drag translate the mask\n"
2843 "Shift+MMB: Set Pivot Point at pointer\n"
2844 "Wheel: rotate around Pivot Point\n"
2845 "Shift+Wheel: scale around Pivot Point\n"
2846 "Ctrl+Wheel: rotate/scale around pointer")));
2847 help_h = y + title->get_h() + 2*margin;
2849 resize_window(get_w(), help_y);
2853 int CWindowMaskGUI::close_event()
2856 return CWindowToolGUI::close_event();
2859 void CWindowMaskGUI::done_event()
2861 if( mwindow->in_destructor ) return;
2862 int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2863 if( solo_track_id >= 0 ) {
2869 void CWindowMaskGUI::get_keyframe(Track* &track,
2870 MaskAutos* &autos, MaskAuto* &keyframe,
2871 SubMask* &mask, MaskPoint* &point, int create_it)
2876 track = mwindow->cwindow->calculate_mask_track();
2878 track = mwindow->cwindow->calculate_affected_track();
2881 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2882 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2887 mask = !keyframe ? 0 :
2888 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2892 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
2893 mwindow->cwindow->gui->affected_point >= 0 ) {
2894 point = mask->points.values[mwindow->cwindow->gui->affected_point];
2899 void CWindowMaskGUI::update()
2906 //printf("CWindowMaskGUI::update 1\n");
2907 get_keyframe(track, autos, keyframe, mask, point, 0);
2908 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2909 mask_on_track->set_back_color(!track || track->record ?
2910 get_resources()->text_background :
2911 get_resources()->text_background_disarmed);
2912 mask_on_track->update_items();
2913 mask_on_track->update(!track ? "" : track->title);
2914 mask_name->update_items(keyframe);
2915 const char *text = "";
2916 int sz = !keyframe ? 0 : keyframe->masks.size();
2917 int k = mwindow->edl->session->cwindow_mask;
2918 if( k >= 0 && k < sz )
2919 text = keyframe->masks[k]->name;
2921 k = mwindow->edl->session->cwindow_mask = 0;
2922 mask_name->update(text);
2923 update_buttons(keyframe, k);
2925 x->update(point->x);
2926 y->update(point->y);
2929 double position = mwindow->edl->local_session->get_selectionstart(1);
2930 int64_t position_i = track->to_units(position, 0);
2931 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
2932 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
2933 int show_mask = track->masks;
2934 for( int i=0; i<SUBMASKS; ++i )
2935 mask_enables[i]->update((show_mask>>i) & 1);
2938 apply_before_plugins->update(keyframe->apply_before_plugins);
2939 disable_opengl_masking->update(keyframe->disable_opengl_masking);
2941 active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2944 void CWindowMaskGUI::handle_event()
2947 if( event_caller == this->focus_x ||
2948 event_caller == this->focus_y ) {
2951 else if( event_caller == this->x ||
2952 event_caller == this->y ) {
2958 get_keyframe(track, autos, keyframe, mask, point, 0);
2960 mwindow->undo->update_undo_before(_("mask point"), this);
2963 float px = atof(x->get_text());
2964 float py = atof(y->get_text());
2965 float dx = px - point->x, dy = py - point->y;
2966 #ifdef USE_KEYFRAME_SPANNING
2967 // Create temp keyframe
2968 MaskAuto temp_keyframe(mwindow->edl, autos);
2969 temp_keyframe.copy_data(keyframe);
2970 // Get affected point in temp keyframe
2971 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2973 MaskPoints &points = mask->points;
2974 int gang = gang_point->get_value();
2975 int k = mwindow->cwindow->gui->affected_point;
2976 int n = gang ? points.size() : k+1;
2977 for( int i=gang? 0 : k; i<n; ++i ) {
2978 if( i < 0 || i >= points.size() ) continue;
2979 MaskPoint *point = points[i];
2980 point->x += dx; point->y += dy;
2982 #ifdef USE_KEYFRAME_SPANNING
2983 // Commit to spanned keyframes
2984 autos->update_parameter(&temp_keyframe);
2987 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2995 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
2997 CWindowGUI *cgui = mwindow->cwindow->gui;
2998 cgui->unlock_window();
2999 lock_window("CWindowMaskGUI::set_focused");
3001 focus->update(focused = v);
3002 focus_x->update(cx);
3003 focus_y->update(cy);
3005 cgui->lock_window("CWindowCanvas::set_focused");
3008 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
3010 int text_color = get_resources()->default_text_color;
3011 int high_color = get_resources()->button_highlighted;
3012 for( int i=0; i<SUBMASKS; ++i ) {
3013 int color = text_color;
3015 SubMask *submask = keyframe->get_submask(i);
3016 if( submask && submask->points.size() )
3019 mask_blabels[i]->set_color(color);
3020 mask_buttons[i]->update(i==k ? 1 : 0);
3024 // typ=0, this mask, this point
3025 // typ>0, this mask, all points
3026 // typ<0, all masks, all points
3027 // dxy= on? pt[+1]-pt[-1] : dxy=0
3028 int CWindowMaskGUI::smooth_mask(int typ, int on)
3035 #ifdef USE_KEYFRAME_SPANNING
3041 mwindow->undo->update_undo_before(_("mask smooth"), this);
3043 // Get existing keyframe
3044 get_keyframe(track, autos, keyframe,
3045 mask, point, create_it);
3047 #ifdef USE_KEYFRAME_SPANNING
3048 MaskAuto temp_keyframe(mwindow->edl, autos);
3049 temp_keyframe.copy_data(keyframe);
3050 keyframe = &temp_keyframe;
3052 int k = mwindow->edl->session->cwindow_mask;
3053 int n = typ>=0 ? k+1 : keyframe->masks.size();
3054 for( int j=typ<0? 0 : k; j<n; ++j ) {
3055 if( !mask_enables[j]->get_value() ) continue;
3056 SubMask *sub_mask = keyframe->get_submask(j);
3057 MaskPoints &points = sub_mask->points;
3058 int psz = points.size();
3059 if( psz < 3 ) continue;
3060 int l = mwindow->cwindow->gui->affected_point;
3061 if( l > psz ) l = psz;
3062 int m = typ ? psz : l+1;
3063 for( int i=typ ? 0 : l; i<m; ++i ) {
3064 int i0 = i-1, i1 = i+1;
3065 if( i0 < 0 ) i0 = psz-1;
3066 if( i1 >= psz ) i1 = 0;
3067 MaskPoint *p0 = points[i0];
3068 MaskPoint *p = points[i];
3069 MaskPoint *p1 = points[i1];
3070 float dx = !on ? 0 : p1->x - p0->x;
3071 float dy = !on ? 0 : p1->y - p0->y;
3072 p->control_x1 = -dx/4; p->control_y1 = -dy/4;
3073 p->control_x2 = dx/4; p->control_y2 = dy/4;
3076 #ifdef USE_KEYFRAME_SPANNING
3077 autos->update_parameter(keyframe);
3082 mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
3086 int CWindowMaskGUI::save_mask(const char *nm)
3088 int k = mwindow->edl->session->cwindow_mask;
3094 get_keyframe(track, autos, keyframe, mask, point, 0);
3095 if( !track ) return 0;
3096 SubMask *sub_mask = keyframe->get_submask(k);
3097 ArrayList<SubMask *> masks;
3099 int i = masks.size();
3101 if( strcmp(masks[i]->name, nm) ) continue;
3102 masks.remove_object_number(i);
3104 mask = new SubMask(0, -1);
3105 strncpy(mask->name, nm, sizeof(mask->name)-1);
3106 mask->copy_from(*sub_mask, 0);
3109 masks.remove_all_objects();
3113 int CWindowMaskGUI::del_mask(const char *nm)
3115 ArrayList<SubMask *> masks;
3117 int i = masks.size();
3119 if( strcmp(masks[i]->name, nm) ) continue;
3120 masks.remove_object_number(i);
3123 masks.remove_all_objects();
3127 int CWindowMaskGUI::center_mask()
3129 int k = mwindow->edl->session->cwindow_mask;
3135 #ifdef USE_KEYFRAME_SPANNING
3140 get_keyframe(track, autos, keyframe,
3141 mask, point, create_it);
3142 if( !track ) return 0;
3143 mwindow->undo->update_undo_before(_("mask center"), this);
3145 // Get existing keyframe
3146 #ifdef USE_KEYFRAME_SPANNING
3147 MaskAuto temp_keyframe(mwindow->edl, autos);
3148 temp_keyframe.copy_data(keyframe);
3149 keyframe = &temp_keyframe;
3151 SubMask *sub_mask = keyframe->get_submask(k);
3152 MaskPoints &points = sub_mask->points;
3153 int psz = points.size();
3155 float cx = 0, cy = 0;
3156 for( int i=0; i<psz; ++i ) {
3157 MaskPoint *p = points[i];
3158 cx += p->x; cy += p->y;
3160 cx /= psz; cy /= psz;
3161 cx -= mwindow->edl->session->output_w / 2.f;
3162 cy -= mwindow->edl->session->output_h / 2.f;
3163 for( int i=0; i<psz; ++i ) {
3164 MaskPoint *p = points[i];
3165 p->x -= cx; p->y -= cy;
3168 #ifdef USE_KEYFRAME_SPANNING
3169 autos->update_parameter(keyframe);
3172 mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3176 int CWindowMaskGUI::normal_mask()
3178 int k = mwindow->edl->session->cwindow_mask;
3184 #ifdef USE_KEYFRAME_SPANNING
3189 // Get existing keyframe
3190 get_keyframe(track, autos, keyframe,
3191 mask, point, create_it);
3192 if( !track ) return 0;
3193 mwindow->undo->update_undo_before(_("mask normal"), this);
3195 #ifdef USE_KEYFRAME_SPANNING
3196 MaskAuto temp_keyframe(mwindow->edl, autos);
3197 temp_keyframe.copy_data(keyframe);
3198 keyframe = &temp_keyframe;
3200 SubMask *sub_mask = keyframe->get_submask(k);
3201 MaskPoints &points = sub_mask->points;
3202 int psz = points.size();
3203 float cx = 0, cy = 0;
3206 for( int i=0; i<psz; ++i ) {
3207 MaskPoint *p = points[i];
3208 cx += p->x; cy += p->y;
3210 cx /= psz; cy /= psz;
3211 for( int i=0; i<psz; ++i ) {
3212 MaskPoint *p = points[i];
3213 float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3214 double d = sqrt(dx*dx + dy*dy);
3215 if( dr < d ) dr = d;
3219 float out_w = mwindow->edl->session->output_w;
3220 float out_h = mwindow->edl->session->output_h;
3221 float r = bmax(out_w, out_h);
3222 float s = r / (4 * dr * sqrt(2.));
3223 for( int i=0; i<psz; ++i ) {
3224 MaskPoint *p = points[i];
3225 float x = p->x, y = p->y;
3226 p->x = (x-cx) * s + cx;
3227 p->y = (y-cy) * s + cy;
3228 p->control_x1 *= s; p->control_y1 *= s;
3229 p->control_x2 *= s; p->control_y2 *= s;
3232 #ifdef USE_KEYFRAME_SPANNING
3233 autos->update_parameter(keyframe);
3237 mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3242 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3243 : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3245 this->mwindow = mwindow;
3250 CWindowMaskLoadList::~CWindowMaskLoadList()
3255 int CWindowMaskLoadList::handle_event()
3262 #ifdef USE_KEYFRAME_SPANNING
3268 mwindow->undo->update_undo_before(_("mask shape"), this);
3270 // Get existing keyframe
3271 gui->get_keyframe(track, autos, keyframe,
3272 mask, point, create_it);
3273 CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3274 if( track && item ) {
3275 #ifdef USE_KEYFRAME_SPANNING
3276 MaskAuto temp_keyframe(mwindow->edl, autos);
3277 temp_keyframe.copy_data(keyframe);
3278 keyframe = &temp_keyframe;
3279 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3281 ArrayList<SubMask *> masks;
3282 gui->load_masks(masks);
3283 mask->copy_from(*masks[item->id], 0);
3284 masks.remove_all_objects();
3285 #ifdef USE_KEYFRAME_SPANNING
3286 autos->update_parameter(keyframe);
3289 gui->update_preview(1);
3291 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3295 void CWindowMaskLoadList::create_objects()
3297 shape_items.remove_all_objects();
3298 ArrayList<SubMask *> masks;
3299 gui->load_masks(masks);
3300 for( int i=0; i<masks.size(); ++i )
3301 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3302 masks.remove_all_objects();
3303 update(&shape_items, 0, 0, 1);
3306 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3307 CWindowMaskGUI *gui, int x, int y, int w)
3308 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3310 this->mwindow = mwindow;
3312 set_tooltip(_("Load preset"));
3315 int CWindowMaskLoad::handle_event()
3317 gui->mask_load_list->create_objects();
3319 get_abs_cursor(px, py);
3320 return gui->mask_load_list->activate(px, py, 120,160);
3324 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3325 CWindowMaskGUI *gui, int x, int y, int w)
3326 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3328 this->mwindow = mwindow;
3330 set_tooltip(_("Save preset"));
3333 CWindowMaskSave::~CWindowMaskSave()
3337 int CWindowMaskSave::handle_event()
3344 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3347 gui->get_abs_cursor(sx, sy);
3348 if( !gui->preset_dialog )
3349 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3350 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3355 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3358 this->mwindow = mwindow;
3363 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3368 void CWindowMaskPresetDialog::handle_close_event(int result)
3373 void CWindowMaskPresetDialog::handle_done_event(int result)
3375 if( result ) return;
3376 const char *nm = pgui->preset_text->get_text();
3383 BC_Window* CWindowMaskPresetDialog::new_gui()
3385 pgui = new CWindowMaskPresetGUI(this, sx, sy,
3386 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3387 _(PROGRAM_NAME ": Delete Mask"));
3388 pgui->create_objects();
3392 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3395 this->sx = sx; this->sy = sy;
3396 this->keyframe = keyframe;
3400 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3401 int x, int y, const char *title)
3402 : BC_Window(title, x, y, 320, 100, 320, 100, 0, 0, 1)
3404 this->preset_dialog = preset_dialog;
3407 void CWindowMaskPresetGUI::create_objects()
3409 int x = 10, y = 10, pad = 8;
3410 lock_window("CWindowMaskPresetGUI::create_objects");
3412 add_subwindow(title = new BC_Title(x, y,
3413 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3414 int x1 = x + title->get_w() + pad;
3415 int x2 = get_w() - x - pad - x1 -
3416 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3417 CWindowMaskGUI *gui = preset_dialog->gui;
3418 preset_text = new CWindowMaskPresetText(this,
3419 x1, y, x2, 120, gui->mask_name->get_text());
3420 preset_text->create_objects();
3421 preset_text->set_tooltip(_("Mask name"));
3422 preset_text->update_items();
3423 add_subwindow(new BC_OKButton(this));
3424 add_subwindow(new BC_CancelButton(this));
3430 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3431 int x, int y, int w, int h, const char *text)
3432 : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3437 int CWindowMaskPresetText::handle_event()
3439 int k = get_number();
3440 if( k >= 0 && k<mask_items.size() )
3441 update(mask_items[k]->get_text());
3445 void CWindowMaskPresetText::update_items()
3447 mask_items.remove_all_objects();
3448 ArrayList<SubMask *> masks;
3449 pgui->preset_dialog->gui->load_masks(masks);
3450 for( int i=0; i<masks.size(); ++i ) {
3451 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
3452 strncpy(text, masks[i]->name, sizeof(text)-1);
3453 mask_items.append(new CWindowMaskItem(text));
3455 masks.remove_all_objects();
3456 update_list(&mask_items);
3460 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3461 CWindowMaskGUI *gui, int x, int y, int w)
3462 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3464 this->mwindow = mwindow;
3466 set_tooltip(_("Delete preset"));
3469 int CWindowMaskDelete::handle_event()
3472 gui->get_abs_cursor(sx, sy);
3473 if( !gui->preset_dialog )
3474 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3475 gui->preset_dialog->start_dialog(sx, sy, 0);
3480 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3481 CWindowMaskGUI *gui, int x, int y, int w)
3482 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3484 this->mwindow = mwindow;
3486 set_tooltip(_("center mask"));
3489 int CWindowMaskCenter::handle_event()
3491 return gui->center_mask();
3495 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3496 CWindowMaskGUI *gui, int x, int y, int w)
3497 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3499 this->mwindow = mwindow;
3501 set_tooltip(_("normalize mask"));
3504 int CWindowMaskNormal::handle_event()
3506 return gui->normal_mask();
3510 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3511 const char *images, int shape, int x, int y, const char *tip)
3512 : BC_Button(x, y, mwindow->theme->get_image_set(images))
3514 this->mwindow = mwindow;
3516 this->shape = shape;
3520 CWindowMaskShape::~CWindowMaskShape()
3524 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3526 int out_w = mwindow->edl->session->output_w;
3527 int out_h = mwindow->edl->session->output_h;
3528 float cx = out_w/2.f, cy = out_h/2.f;
3529 float r = bmax(cx, cy) / 4.f;
3530 double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3531 float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3533 MaskPoints &points = sub_mask->points;
3534 points.remove_all_objects();
3536 case MASK_SHAPE_SQUARE:
3537 points.append(pt = new MaskPoint());
3538 pt->x = cx - r; pt->y = cy - r;
3539 points.append(pt = new MaskPoint());
3540 pt->x = cx + r; pt->y = cy - r;
3541 points.append(pt = new MaskPoint());
3542 pt->x = cx + r; pt->y = cy + r;
3543 points.append(pt = new MaskPoint());
3544 pt->x = cx - r; pt->y = cy + r;
3546 case MASK_SHAPE_CIRCLE:
3547 points.append(pt = new MaskPoint());
3548 pt->x = cx - r; pt->y = cy - r;
3549 pt->control_x1 = -rc; pt->control_y1 = rc;
3550 pt->control_x2 = rc; pt->control_y2 = -rc;
3551 points.append(pt = new MaskPoint());
3552 pt->x = cx + r; pt->y = cy - r;
3553 pt->control_x1 = -rc; pt->control_y1 = -rc;
3554 pt->control_x2 = rc; pt->control_y2 = rc;
3555 points.append(pt = new MaskPoint());
3556 pt->x = cx + r; pt->y = cy + r;
3557 pt->control_x1 = rc; pt->control_y1 = -rc;
3558 pt->control_x2 = -rc; pt->control_y2 = rc;
3559 points.append(pt = new MaskPoint());
3560 pt->x = cx - r; pt->y = cy + r;
3561 pt->control_x1 = rc; pt->control_y1 = rc;
3562 pt->control_x2 = -rc; pt->control_y2 = -rc;
3564 case MASK_SHAPE_TRIANGLE:
3565 points.append(pt = new MaskPoint());
3566 pt->x = cx + 0; pt->y = cy - r*(sqrt(3.)-1.);
3567 points.append(pt = new MaskPoint());
3568 pt->x = cx + r; pt->y = cy + r;
3569 points.append(pt = new MaskPoint());
3570 pt->x = cx - r; pt->y = cy + r;
3572 case MASK_SHAPE_OVAL:
3573 points.append(pt = new MaskPoint());
3574 pt->x = cx - r; pt->y = cy - r2;
3575 pt->control_x1 = -r2; pt->control_y1 = r4;
3576 pt->control_x2 = r2; pt->control_y2 = -r4;
3577 points.append(pt = new MaskPoint());
3578 pt->x = cx + r; pt->y = cy - r2;
3579 pt->control_x1 = -r2; pt->control_y1 = -r4;
3580 pt->control_x2 = r2; pt->control_y2 = r4;
3581 points.append(pt = new MaskPoint());
3582 pt->x = cx + r; pt->y = cy + r2;
3583 pt->control_x1 = r2; pt->control_y1 = -r4;
3584 pt->control_x2 = -r2; pt->control_y2 = r4;
3585 points.append(pt = new MaskPoint());
3586 pt->x = cx - r; pt->y = cy + r2;
3587 pt->control_x1 = r2; pt->control_y1 = r4;
3588 pt->control_x2 = -r2; pt->control_y2 = -r4;
3593 int CWindowMaskShape::handle_event()
3600 #ifdef USE_KEYFRAME_SPANNING
3606 mwindow->undo->update_undo_before(_("mask shape"), this);
3608 // Get existing keyframe
3609 gui->get_keyframe(track, autos, keyframe,
3610 mask, point, create_it);
3612 #ifdef USE_KEYFRAME_SPANNING
3613 MaskAuto temp_keyframe(mwindow->edl, autos);
3614 temp_keyframe.copy_data(keyframe);
3615 keyframe = &temp_keyframe;
3616 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3619 builtin_shape(shape, mask);
3620 #ifdef USE_KEYFRAME_SPANNING
3621 autos->update_parameter(keyframe);
3624 gui->update_preview(1);
3627 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3631 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3633 char path[BCTEXTLEN];
3634 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3636 fs.complete_path(path);
3638 file.read_from_file(path, 1);
3640 masks.remove_all_objects();
3642 while( !(result = file.read_tag()) ) {
3643 if( file.tag.title_is("MASK") ) {
3644 SubMask *sub_mask = new SubMask(0, -1);
3645 char name[BCTEXTLEN]; name[0] = 0;
3646 file.tag.get_property("NAME", name);
3647 strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3648 sub_mask->load(&file);
3649 masks.append(sub_mask);
3654 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3657 for( int i=0; i<masks.size(); ++i ) {
3658 SubMask *sub_mask = masks[i];
3659 sub_mask->copy(&file);
3661 file.terminate_string();
3663 char path[BCTEXTLEN];
3664 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3666 fs.complete_path(path);
3667 file.write_to_file(path);
3671 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3672 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
3676 CWindowRulerGUI::~CWindowRulerGUI()
3680 void CWindowRulerGUI::create_objects()
3682 int x = 10, y = 10, x1 = 100;
3685 lock_window("CWindowRulerGUI::create_objects");
3686 add_subwindow(title = new BC_Title(x, y, _("Current:")));
3687 add_subwindow(current = new BC_TextBox(x1, y, 200, 1, ""));
3688 y += title->get_h() + 5;
3689 add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3690 add_subwindow(point1 = new BC_TextBox(x1, y, 200, 1, ""));
3691 y += title->get_h() + 5;
3692 add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3693 add_subwindow(point2 = new BC_TextBox(x1, y, 200, 1, ""));
3694 y += title->get_h() + 5;
3695 add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3696 add_subwindow(deltas = new BC_TextBox(x1, y, 200, 1, ""));
3697 y += title->get_h() + 5;
3698 add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3699 add_subwindow(distance = new BC_TextBox(x1, y, 200, 1, ""));
3700 y += title->get_h() + 5;
3701 add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3702 add_subwindow(angle = new BC_TextBox(x1, y, 200, 1, ""));
3703 y += title->get_h() + 10;
3704 char string[BCTEXTLEN];
3706 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3707 0xc2, 0xb0); // degrees utf
3708 add_subwindow(title = new BC_Title(x,
3711 y += title->get_h() + 10;
3712 sprintf(string, _("Press Alt to translate the ruler."));
3713 add_subwindow(title = new BC_Title(x,
3720 void CWindowRulerGUI::update()
3722 char string[BCTEXTLEN];
3723 int cx = mwindow->session->cwindow_output_x;
3724 int cy = mwindow->session->cwindow_output_y;
3725 sprintf(string, "%d, %d", cx, cy);
3726 current->update(string);
3727 double x1 = mwindow->edl->session->ruler_x1;
3728 double y1 = mwindow->edl->session->ruler_y1;
3729 sprintf(string, "%.0f, %.0f", x1, y1);
3730 point1->update(string);
3731 double x2 = mwindow->edl->session->ruler_x2;
3732 double y2 = mwindow->edl->session->ruler_y2;
3733 sprintf(string, "%.0f, %.0f", x2, y2);
3734 point2->update(string);
3735 double dx = x2 - x1, dy = y2 - y1;
3736 sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3737 deltas->update(string);
3738 double d = sqrt(dx*dx + dy*dy);
3739 sprintf(string, _("%0.01f pixels"), d);
3740 distance->update(string);
3741 double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3742 sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3743 angle->update(string);
3746 void CWindowRulerGUI::handle_event()