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,
266 CWindowTool *thread, const char *title, int w, int h)
268 mwindow->session->ctool_x, mwindow->session->ctool_y,
271 this->mwindow = mwindow;
272 this->thread = thread;
273 current_operation = 0;
276 CWindowToolGUI::~CWindowToolGUI()
280 int CWindowToolGUI::close_event()
284 mwindow->edl->session->tool_window = 0;
286 thread->gui->lock_window("CWindowToolGUI::close_event");
287 thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
288 thread->gui->flush();
289 thread->gui->unlock_window();
290 lock_window("CWindowToolGUI::close_event");
294 int CWindowToolGUI::keypress_event()
298 switch( get_keypress() ) {
301 return close_event();
314 resend_event(thread->gui);
321 int CWindowToolGUI::translation_event()
323 mwindow->session->ctool_x = get_x();
324 mwindow->session->ctool_y = get_y();
329 void CWindowToolGUI::update_preview(int changed_edl)
332 draw_preview(changed_edl);
333 lock_window("CWindowToolGUI::update_preview");
336 void CWindowToolGUI::draw_preview(int changed_edl)
338 CWindowGUI *cgui = mwindow->cwindow->gui;
339 cgui->lock_window("CWindowToolGUI::draw_preview");
340 int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
341 cgui->sync_parameters(change_type, 0, 1);
342 cgui->unlock_window();
346 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
347 : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, xS(70), 3)
350 set_log_floatincrement(log_increment);
353 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
354 : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, xS(70))
358 int CWindowCoord::handle_event()
360 gui->event_caller = this;
366 CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
367 : BC_GenericButton(x, y, _("Apply"))
369 this->mwindow = mwindow;
370 this->crop_gui = crop_gui;
372 int CWindowCropApply::handle_event()
374 mwindow->crop_video(crop_gui->crop_mode->mode);
379 int CWindowCropApply::keypress_event()
381 if(get_keypress() == 0xd)
389 const char *CWindowCropOpMode::crop_ops[] = {
395 CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
396 int mode, int x, int y)
397 : BC_PopupMenu(x, y, xS(140), _(crop_ops[mode]), 1)
399 this->mwindow = mwindow;
400 this->crop_gui = crop_gui;
403 CWindowCropOpMode::~CWindowCropOpMode()
407 void CWindowCropOpMode::create_objects()
409 for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
410 add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
414 int CWindowCropOpMode::handle_event()
416 set_text(_(crop_ops[mode]));
420 CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
427 int CWindowCropOpItem::handle_event()
429 popup->set_text(get_text());
431 return popup->handle_event();
438 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
439 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Crop"), xS(330), yS(100))
444 CWindowCropGUI::~CWindowCropGUI()
448 void CWindowCropGUI::create_objects()
450 int xs5 = xS(5), xs10 = xS(10);
451 int ys5 = yS(5), ys10 = yS(10);
452 int x = xs10, y = ys10;
455 lock_window("CWindowCropGUI::create_objects");
457 int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
458 BC_Title::calculate_h(this, "X")) + ys5;
459 add_subwindow(title = new BC_Title(x, y, "X1:"));
460 column1 = MAX(column1, title->get_w());
462 add_subwindow(title = new BC_Title(x, y, _("W:")));
463 column1 = MAX(column1, title->get_w());
465 add_subwindow(new CWindowCropApply(mwindow, this, x, y));
469 x1 = new CWindowCoord(thread->tool_gui, x, y,
470 mwindow->edl->session->crop_x1);
471 x1->create_objects();
472 x1->set_boundaries((int64_t)0, (int64_t)65536);
474 width = new CWindowCoord(thread->tool_gui, x, y,
475 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
476 width->create_objects();
477 width->set_boundaries((int64_t)1, (int64_t)65536);
480 x += x1->get_w() + xs10;
483 add_subwindow(title = new BC_Title(x, y, "Y1:"));
484 column2 = MAX(column2, title->get_w());
486 add_subwindow(title = new BC_Title(x, y, _("H:")));
487 column2 = MAX(column2, title->get_w());
492 y1 = new CWindowCoord(thread->tool_gui, x, y,
493 mwindow->edl->session->crop_y1);
494 y1->create_objects();
495 y1->set_boundaries((int64_t)0, (int64_t)65536);
498 height = new CWindowCoord(thread->tool_gui, x, y,
499 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
500 height->create_objects();
501 height->set_boundaries((int64_t)1, (int64_t)65536);
504 add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
505 CROP_REFORMAT, x, y));
506 crop_mode->create_objects();
511 void CWindowCropGUI::handle_event()
514 new_x1 = atol(x1->get_text());
515 new_y1 = atol(y1->get_text());
516 if(new_x1 != mwindow->edl->session->crop_x1)
518 mwindow->edl->session->crop_x2 = new_x1 +
519 mwindow->edl->session->crop_x2 -
520 mwindow->edl->session->crop_x1;
521 mwindow->edl->session->crop_x1 = new_x1;
523 if(new_y1 != mwindow->edl->session->crop_y1)
525 mwindow->edl->session->crop_y2 = new_y1 +
526 mwindow->edl->session->crop_y2 -
527 mwindow->edl->session->crop_y1;
528 mwindow->edl->session->crop_y1 = atol(y1->get_text());
530 mwindow->edl->session->crop_x2 = atol(width->get_text()) +
531 mwindow->edl->session->crop_x1;
532 mwindow->edl->session->crop_y2 = atol(height->get_text()) +
533 mwindow->edl->session->crop_y1;
535 mwindow->cwindow->gui->canvas->redraw(1);
538 void CWindowCropGUI::update()
540 x1->update((int64_t)mwindow->edl->session->crop_x1);
541 y1->update((int64_t)mwindow->edl->session->crop_y1);
542 width->update((int64_t)mwindow->edl->session->crop_x2 -
543 mwindow->edl->session->crop_x1);
544 height->update((int64_t)mwindow->edl->session->crop_y2 -
545 mwindow->edl->session->crop_y1);
549 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
550 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), xS(220), yS(290))
554 CWindowEyedropGUI::~CWindowEyedropGUI()
558 void CWindowEyedropGUI::create_objects()
560 int xs10 = xS(10), ys10 = yS(10);
561 int margin = mwindow->theme->widget_border;
562 int x = xs10 + margin;
563 int y = ys10 + margin;
564 int x2 = xS(70), x3 = x2 + xS(60);
565 lock_window("CWindowEyedropGUI::create_objects");
566 BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
567 add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
568 y += title0->get_h() + margin;
569 add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
570 y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
572 add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
573 y += title1->get_h() + margin;
574 add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
575 y += title2->get_h() + margin;
576 add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
577 y += title3->get_h() + margin;
579 add_subwindow(title4 = new BC_Title(x, y, "Y:"));
580 y += title4->get_h() + margin;
581 add_subwindow(title5 = new BC_Title(x, y, "U:"));
582 y += title5->get_h() + margin;
583 add_subwindow(title6 = new BC_Title(x, y, "V:"));
585 add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
587 radius = new CWindowCoord(this, x2, title7->get_y(),
588 mwindow->edl->session->eyedrop_radius);
589 radius->create_objects();
590 radius->set_boundaries((int64_t)0, (int64_t)255);
592 add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
593 add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
594 add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
595 add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
597 add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
598 add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
599 add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
600 add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
602 y = title6->get_y() + this->v->get_h() + 2*margin;
603 add_subwindow(sample = new BC_SubWindow(x, y, xS(50), yS(50)));
604 y += sample->get_h() + margin;
605 add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
610 void CWindowEyedropGUI::update()
612 char string[BCTEXTLEN];
613 sprintf(string, "%d, %d",
614 thread->gui->eyedrop_x,
615 thread->gui->eyedrop_y);
616 current->update(string);
618 radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
620 LocalSession *local_session = mwindow->edl->local_session;
621 int use_max = local_session->use_max;
622 float r = use_max ? local_session->red_max : local_session->red;
623 float g = use_max ? local_session->green_max : local_session->green;
624 float b = use_max ? local_session->blue_max : local_session->blue;
625 this->red->update(r);
626 this->green->update(g);
627 this->blue->update(b);
629 int rx = 255*r + 0.5; bclamp(rx,0,255);
630 int gx = 255*g + 0.5; bclamp(gx,0,255);
631 int bx = 255*b + 0.5; bclamp(bx,0,255);
632 char rgb_text[BCSTRLEN];
633 sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
634 rgb_hex->update(rgb_text);
637 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
639 this->u->update(u); u += 0.5;
640 this->v->update(v); v += 0.5;
642 int yx = 255*y + 0.5; bclamp(yx,0,255);
643 int ux = 255*u + 0.5; bclamp(ux,0,255);
644 int vx = 255*v + 0.5; bclamp(vx,0,255);
645 char yuv_text[BCSTRLEN];
646 sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
647 yuv_hex->update(yuv_text);
649 int rgb = (rx << 16) | (gx << 8) | (bx << 0);
650 sample->set_color(rgb);
651 sample->draw_box(0, 0, sample->get_w(), sample->get_h());
652 sample->set_color(BLACK);
653 sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
657 void CWindowEyedropGUI::handle_event()
659 int new_radius = atoi(radius->get_text());
660 if(new_radius != mwindow->edl->session->eyedrop_radius)
662 CWindowGUI *gui = mwindow->cwindow->gui;
663 if(gui->eyedrop_visible)
665 gui->lock_window("CWindowEyedropGUI::handle_event");
668 gui->canvas->do_eyedrop(rerender, 0, 1);
671 mwindow->edl->session->eyedrop_radius = new_radius;
673 if(gui->eyedrop_visible)
677 gui->canvas->do_eyedrop(rerender, 0, 1);
678 gui->unlock_window();
685 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
687 // Configuration for all possible Keyframe Curve Mode toggles
689 FloatAuto::t_mode mode;
695 const _CVD Camera_Crv_Smooth =
699 N_("\"smooth\" Curve on current Camera Keyframes")
701 const _CVD Camera_Crv_Linear =
705 N_("\"linear\" Curve on current Camera Keyframes")
707 const _CVD Projector_Crv_Smooth =
711 N_("\"smooth\" Curve on current Projector Keyframes")
713 const _CVD Projector_Crv_Linear =
717 N_("\"linear\" Curve on current Projector Keyframes")
720 // Implementation Class für Keyframe Curve Mode buttons
722 // This button reflects the state of the "current" keyframe
723 // (the nearest keyframe on the left) for all three automation
724 // lines together. Clicking on this button (re)sets the curve
725 // mode for the three "current" keyframes simultanously, but
726 // never creates a new keyframe.
728 class CWindowCurveToggle : public BC_Toggle
731 CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
732 void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
741 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
742 : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
746 this->mwindow = mwindow;
747 set_tooltip(_(cfg.tooltip));
750 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
752 // the toggle state is only set to ON if all
753 // three automation lines have the same curve mode.
754 // For mixed states the toggle stays off.
755 set_value( x->curve_mode == this->cfg.mode &&
756 y->curve_mode == this->cfg.mode &&
757 z->curve_mode == this->cfg.mode
758 ,true // redraw to show new state
762 int CWindowCurveToggle::handle_event()
764 Track *track = mwindow->cwindow->calculate_affected_track();
766 FloatAuto *x=0, *y=0, *z=0;
767 mwindow->cwindow->calculate_affected_autos(track,
768 &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
769 if( x ) x->change_curve_mode(cfg.mode);
770 if( y ) y->change_curve_mode(cfg.mode);
771 if( z ) z->change_curve_mode(cfg.mode);
774 gui->update_preview();
781 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
782 CWindowEyedropGUI *gui, int x, int y)
783 : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
785 this->mwindow = mwindow;
789 int CWindowEyedropCheckBox::handle_event()
791 mwindow->edl->local_session->use_max = get_value();
798 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
799 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Camera"), xS(170), yS(170))
802 CWindowCameraGUI::~CWindowCameraGUI()
806 void CWindowCameraGUI::create_objects()
808 int xs10 = xS(10), xs15 = xS(15);
809 int ys10 = yS(10), ys30 = yS(30);
810 int x = xs10, y = ys10, x1;
811 Track *track = mwindow->cwindow->calculate_affected_track();
812 FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
816 lock_window("CWindowCameraGUI::create_objects");
818 mwindow->cwindow->calculate_affected_autos(track,
819 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
822 add_subwindow(title = new BC_Title(x, y, "X:"));
824 this->x = new CWindowCoord(this, x, y,
825 x_auto ? x_auto->get_value() : (float)0);
826 this->x->create_objects();
831 add_subwindow(title = new BC_Title(x, y, "Y:"));
833 this->y = new CWindowCoord(this, x, y,
834 y_auto ? y_auto->get_value() : (float)0);
835 this->y->create_objects();
838 add_subwindow(title = new BC_Title(x, y, "Z:"));
840 this->z = new CWindowCoord(this, x, y,
841 z_auto ? z_auto->get_value() : (float)1);
842 this->z->create_objects();
843 this->z->set_increment(0.01);
847 add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
848 x1 += button->get_w();
849 add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
850 x1 += button->get_w();
851 add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
852 // additional Buttons to control the curve mode of the "current" keyframe
853 x1 += button->get_w() + xs15;
854 add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
855 x1 += button->get_w() + xs10;
856 add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
858 y += button->get_h();
860 add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
861 x1 += button->get_w();
862 add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
863 x1 += button->get_w();
864 add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
865 x1 += button->get_w() + xs15;
866 add_subwindow(this->add_keyframe = new CWindowCameraAddKeyframe(mwindow, this, x1, y));
867 x1 += button->get_w() + xs10;
868 add_subwindow(this->reset = new CWindowCameraReset(mwindow, this, x1, y));
870 // fill in current auto keyframe values, set toggle states.
875 void CWindowCameraGUI::handle_event()
877 FloatAuto *x_auto = 0;
878 FloatAuto *y_auto = 0;
879 FloatAuto *z_auto = 0;
880 Track *track = mwindow->cwindow->calculate_affected_track();
883 mwindow->undo->update_undo_before(_("camera"), this);
884 if(event_caller == x)
886 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
887 track->automation->autos[AUTOMATION_CAMERA_X], 1);
890 x_auto->set_value(atof(x->get_text()));
896 if(event_caller == y)
898 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
899 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
902 y_auto->set_value(atof(y->get_text()));
908 if(event_caller == z)
910 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
911 track->automation->autos[AUTOMATION_CAMERA_Z], 1);
914 float zoom = atof(z->get_text());
915 if(zoom > 100.) zoom = 100.;
917 if(zoom < 0.01) zoom = 0.01;
918 // Doesn't allow user to enter from scratch
919 // if(zoom != atof(z->get_text()))
922 z_auto->set_value(zoom);
923 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
924 mwindow->gui->draw_overlays(1);
925 mwindow->gui->unlock_window();
931 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
935 void CWindowCameraGUI::update()
937 FloatAuto *x_auto = 0;
938 FloatAuto *y_auto = 0;
939 FloatAuto *z_auto = 0;
940 Track *track = mwindow->cwindow->calculate_affected_track();
942 mwindow->cwindow->calculate_affected_autos(track,
943 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
947 x->update(x_auto->get_value());
949 y->update(y_auto->get_value());
951 float value = z_auto->get_value();
953 thread->gui->lock_window("CWindowCameraGUI::update");
954 thread->gui->composite_panel->cpanel_zoom->update(value);
955 thread->gui->unlock_window();
958 if( x_auto && y_auto && z_auto )
960 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
961 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
968 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
969 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
972 this->mwindow = mwindow;
973 set_tooltip(_("Left justify"));
975 int CWindowCameraLeft::handle_event()
977 FloatAuto *x_auto = 0;
978 FloatAuto *z_auto = 0;
979 Track *track = mwindow->cwindow->calculate_affected_track();
981 mwindow->cwindow->calculate_affected_autos(track,
982 &x_auto, 0, &z_auto, 1, 1, 0, 0);
988 track->get_source_dimensions(
989 mwindow->edl->local_session->get_selectionstart(1),
994 mwindow->undo->update_undo_before(_("camera"), 0);
996 (double)track->track_w / z_auto->get_value() / 2 -
998 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1000 gui->update_preview();
1008 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1009 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1012 this->mwindow = mwindow;
1013 set_tooltip(_("Center horizontal"));
1015 int CWindowCameraCenter::handle_event()
1017 FloatAuto *x_auto = 0;
1018 Track *track = mwindow->cwindow->calculate_affected_track();
1020 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1021 track->automation->autos[AUTOMATION_CAMERA_X], 1);
1025 mwindow->undo->update_undo_before(_("camera"), 0);
1026 x_auto->set_value(0);
1028 gui->update_preview();
1029 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1036 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1037 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1040 this->mwindow = mwindow;
1041 set_tooltip(_("Right justify"));
1043 int CWindowCameraRight::handle_event()
1045 FloatAuto *x_auto = 0;
1046 FloatAuto *z_auto = 0;
1047 Track *track = mwindow->cwindow->calculate_affected_track();
1049 mwindow->cwindow->calculate_affected_autos(track,
1050 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1053 if(x_auto && z_auto)
1056 track->get_source_dimensions(
1057 mwindow->edl->local_session->get_selectionstart(1),
1062 mwindow->undo->update_undo_before(_("camera"), 0);
1063 x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1066 gui->update_preview();
1067 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1075 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1076 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1079 this->mwindow = mwindow;
1080 set_tooltip(_("Top justify"));
1082 int CWindowCameraTop::handle_event()
1084 FloatAuto *y_auto = 0;
1085 FloatAuto *z_auto = 0;
1086 Track *track = mwindow->cwindow->calculate_affected_track();
1088 mwindow->cwindow->calculate_affected_autos(track,
1089 0, &y_auto, &z_auto, 1, 0, 1, 0);
1092 if(y_auto && z_auto)
1095 track->get_source_dimensions(
1096 mwindow->edl->local_session->get_selectionstart(1),
1101 mwindow->undo->update_undo_before(_("camera"), 0);
1102 y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1105 gui->update_preview();
1106 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1114 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1115 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1118 this->mwindow = mwindow;
1119 set_tooltip(_("Center vertical"));
1121 int CWindowCameraMiddle::handle_event()
1123 FloatAuto *y_auto = 0;
1124 Track *track = mwindow->cwindow->calculate_affected_track();
1126 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1127 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1131 mwindow->undo->update_undo_before(_("camera"), 0);
1132 y_auto->set_value(0);
1134 gui->update_preview();
1135 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1142 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1143 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1146 this->mwindow = mwindow;
1147 set_tooltip(_("Bottom justify"));
1149 int CWindowCameraBottom::handle_event()
1151 FloatAuto *y_auto = 0;
1152 FloatAuto *z_auto = 0;
1153 Track *track = mwindow->cwindow->calculate_affected_track();
1155 mwindow->cwindow->calculate_affected_autos(track,
1156 0, &y_auto, &z_auto, 1, 0, 1, 0);
1159 if(y_auto && z_auto)
1162 track->get_source_dimensions(
1163 mwindow->edl->local_session->get_selectionstart(1),
1168 mwindow->undo->update_undo_before(_("camera"), 0);
1169 y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1172 gui->update_preview();
1173 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1180 CWindowCameraAddKeyframe::CWindowCameraAddKeyframe(MWindow *mwindow,
1181 CWindowToolGUI *gui, int x, int y)
1182 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1184 this->mwindow = mwindow;
1186 set_tooltip(_("Add Keyframe: Shift-F11"));
1189 int CWindowCameraAddKeyframe::handle_event()
1191 return gui->press(&CWindowCanvas::camera_keyframe);
1194 CWindowCameraReset::CWindowCameraReset(MWindow *mwindow,
1195 CWindowToolGUI *gui, int x, int y)
1196 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1198 this->mwindow = mwindow;
1200 set_tooltip(_("Reset Camera: F11"));
1203 int CWindowCameraReset::handle_event()
1205 return gui->press(&CWindowCanvas::reset_camera);
1209 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1210 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Projector"), xS(170), yS(170))
1213 CWindowProjectorGUI::~CWindowProjectorGUI()
1216 void CWindowProjectorGUI::create_objects()
1218 int xs10 = xS(10), xs15 = xS(15);
1220 int x = xs10, y = yS(10);
1221 Track *track = mwindow->cwindow->calculate_affected_track();
1222 FloatAuto *x_auto = 0;
1223 FloatAuto *y_auto = 0;
1224 FloatAuto *z_auto = 0;
1228 lock_window("CWindowProjectorGUI::create_objects");
1230 mwindow->cwindow->calculate_affected_autos(track,
1231 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1234 add_subwindow(title = new BC_Title(x, y, "X:"));
1235 x += title->get_w();
1236 this->x = new CWindowCoord(this, x, y,
1237 x_auto ? x_auto->get_value() : (float)0);
1238 this->x->create_objects();
1241 add_subwindow(title = new BC_Title(x, y, "Y:"));
1242 x += title->get_w();
1243 this->y = new CWindowCoord(this, x, y,
1244 y_auto ? y_auto->get_value() : (float)0);
1245 this->y->create_objects();
1248 add_subwindow(title = new BC_Title(x, y, "Z:"));
1249 x += title->get_w();
1250 this->z = new CWindowCoord(this, x, y,
1251 z_auto ? z_auto->get_value() : (float)1);
1252 this->z->create_objects();
1253 this->z->set_increment(0.01);
1257 add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1258 x1 += button->get_w();
1259 add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1260 x1 += button->get_w();
1261 add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1262 // additional Buttons to control the curve mode of the "current" keyframe
1263 x1 += button->get_w() + xs15;
1264 add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1265 x1 += button->get_w() + xs10;
1266 add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1268 y += button->get_h();
1270 add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1271 x1 += button->get_w();
1272 add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1273 x1 += button->get_w();
1274 add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1275 x1 += button->get_w() + xs15;
1276 add_subwindow(this->add_keyframe = new CWindowProjectorAddKeyframe(mwindow, this, x1, y));
1277 x1 += button->get_w() + xs10;
1278 add_subwindow(this->reset = new CWindowProjectorReset(mwindow, this, x1, y));
1280 // fill in current auto keyframe values, set toggle states.
1285 void CWindowProjectorGUI::handle_event()
1287 FloatAuto *x_auto = 0;
1288 FloatAuto *y_auto = 0;
1289 FloatAuto *z_auto = 0;
1290 Track *track = mwindow->cwindow->calculate_affected_track();
1294 mwindow->undo->update_undo_before(_("projector"), this);
1295 if(event_caller == x)
1297 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1298 track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
1301 x_auto->set_value(atof(x->get_text()));
1307 if(event_caller == y)
1309 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1310 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1313 y_auto->set_value(atof(y->get_text()));
1319 if(event_caller == z)
1321 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1322 track->automation->autos[AUTOMATION_PROJECTOR_Z], 1);
1325 float zoom = atof(z->get_text());
1326 if(zoom > 100.) zoom = 100.;
1327 else if(zoom < 0.01) zoom = 0.01;
1328 // if (zoom != atof(z->get_text()))
1330 z_auto->set_value(zoom);
1332 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1333 mwindow->gui->draw_overlays(1);
1334 mwindow->gui->unlock_window();
1340 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1344 void CWindowProjectorGUI::update()
1346 FloatAuto *x_auto = 0;
1347 FloatAuto *y_auto = 0;
1348 FloatAuto *z_auto = 0;
1349 Track *track = mwindow->cwindow->calculate_affected_track();
1351 mwindow->cwindow->calculate_affected_autos(track,
1352 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1356 x->update(x_auto->get_value());
1358 y->update(y_auto->get_value());
1360 float value = z_auto->get_value();
1362 thread->gui->lock_window("CWindowProjectorGUI::update");
1363 thread->gui->composite_panel->cpanel_zoom->update(value);
1364 thread->gui->unlock_window();
1367 if( x_auto && y_auto && z_auto )
1369 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1370 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1374 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1375 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1378 this->mwindow = mwindow;
1379 set_tooltip(_("Left justify"));
1381 int CWindowProjectorLeft::handle_event()
1383 FloatAuto *x_auto = 0;
1384 FloatAuto *z_auto = 0;
1385 Track *track = mwindow->cwindow->calculate_affected_track();
1387 mwindow->cwindow->calculate_affected_autos(track,
1388 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1390 if(x_auto && z_auto)
1392 mwindow->undo->update_undo_before(_("projector"), 0);
1393 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1394 (double)mwindow->edl->session->output_w / 2 );
1396 gui->update_preview();
1397 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1404 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1405 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1408 this->mwindow = mwindow;
1409 set_tooltip(_("Center horizontal"));
1411 int CWindowProjectorCenter::handle_event()
1413 FloatAuto *x_auto = 0;
1414 Track *track = mwindow->cwindow->calculate_affected_track();
1416 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1417 track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
1421 mwindow->undo->update_undo_before(_("projector"), 0);
1422 x_auto->set_value(0);
1424 gui->update_preview();
1425 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1432 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1433 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1436 this->mwindow = mwindow;
1437 set_tooltip(_("Right justify"));
1439 int CWindowProjectorRight::handle_event()
1441 FloatAuto *x_auto = 0;
1442 FloatAuto *z_auto = 0;
1443 Track *track = mwindow->cwindow->calculate_affected_track();
1445 mwindow->cwindow->calculate_affected_autos(track,
1446 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1449 if(x_auto && z_auto)
1451 mwindow->undo->update_undo_before(_("projector"), 0);
1452 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1453 (double)mwindow->edl->session->output_w / 2));
1455 gui->update_preview();
1456 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1463 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1464 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1467 this->mwindow = mwindow;
1468 set_tooltip(_("Top justify"));
1470 int CWindowProjectorTop::handle_event()
1472 FloatAuto *y_auto = 0;
1473 FloatAuto *z_auto = 0;
1474 Track *track = mwindow->cwindow->calculate_affected_track();
1476 mwindow->cwindow->calculate_affected_autos(track,
1477 0, &y_auto, &z_auto, 0, 0, 1, 0);
1480 if(y_auto && z_auto)
1482 mwindow->undo->update_undo_before(_("projector"), 0);
1483 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1484 (double)mwindow->edl->session->output_h / 2 );
1486 gui->update_preview();
1487 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1494 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1495 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1498 this->mwindow = mwindow;
1499 set_tooltip(_("Center vertical"));
1501 int CWindowProjectorMiddle::handle_event()
1503 FloatAuto *y_auto = 0;
1504 Track *track = mwindow->cwindow->calculate_affected_track();
1506 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1507 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1511 mwindow->undo->update_undo_before(_("projector"), 0);
1512 y_auto->set_value(0);
1514 gui->update_preview();
1515 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1522 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1523 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1526 this->mwindow = mwindow;
1527 set_tooltip(_("Bottom justify"));
1529 int CWindowProjectorBottom::handle_event()
1531 FloatAuto *y_auto = 0;
1532 FloatAuto *z_auto = 0;
1533 Track *track = mwindow->cwindow->calculate_affected_track();
1535 mwindow->cwindow->calculate_affected_autos(track,
1536 0, &y_auto, &z_auto, 0, 0, 1, 0);
1539 if(y_auto && z_auto)
1541 mwindow->undo->update_undo_before(_("projector"), 0);
1542 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1543 (double)mwindow->edl->session->output_h / 2));
1545 gui->update_preview();
1546 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1552 CWindowProjectorAddKeyframe::CWindowProjectorAddKeyframe(MWindow *mwindow,
1553 CWindowToolGUI *gui, int x, int y)
1554 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1556 this->mwindow = mwindow;
1558 set_tooltip(_("Add Keyframe: Shift-F12"));
1561 int CWindowProjectorAddKeyframe::handle_event()
1563 return gui->press(&CWindowCanvas::projector_keyframe);
1566 CWindowProjectorReset::CWindowProjectorReset(MWindow *mwindow,
1567 CWindowToolGUI *gui, int x, int y)
1568 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1570 this->mwindow = mwindow;
1572 set_tooltip(_("Reset Projector: F12"));
1575 int CWindowProjectorReset::handle_event()
1577 return gui->press(&CWindowCanvas::reset_projector);
1580 int CWindowToolGUI::press(void (CWindowCanvas::*fn)())
1583 CWindowGUI *cw_gui = thread->gui;
1584 cw_gui->lock_window("CWindowGUI::press");
1585 (cw_gui->canvas->*fn)();
1586 cw_gui->unlock_window();
1587 lock_window("CWindowToolGUI::press");
1591 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1592 int x, int y, int w, const char *text)
1593 : BC_PopupTextBox(gui, 0, text, x, y, w, yS(120))
1595 this->mwindow = mwindow;
1599 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1603 int CWindowMaskOnTrack::handle_event()
1605 CWindowMaskItem *track_item = 0;
1606 int k = get_number(), track_id = -1;
1607 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1609 track_item = (CWindowMaskItem *)track_items[k];
1610 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1611 if( track && track->record ) track_id = track->get_id();
1614 track_id = mwindow->cwindow->mask_track_id;
1615 set_back_color(track_id >= 0 ?
1616 gui->get_resources()->text_background :
1617 gui->get_resources()->text_background_disarmed);
1618 if( mwindow->cwindow->mask_track_id != track_id )
1619 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1620 mwindow->cwindow->mask_track_id = track_id;
1621 mwindow->edl->local_session->solo_track_id = -1;
1622 gui->mask_solo_track->update(0);
1624 gui->update_preview(1);
1628 void CWindowMaskOnTrack::update_items()
1630 track_items.remove_all_objects();
1631 int high_color = gui->get_resources()->button_highlighted;
1632 for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1633 if( track->data_type != TRACK_VIDEO ) continue;
1634 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1635 int color = !track->record ? RED : mask_autos->first ? high_color : -1;
1636 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1637 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1638 if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1639 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1641 update_list(&track_items);
1644 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1648 this->mwindow = mwindow;
1651 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1655 int CWindowMaskTrackTumbler::handle_up_event()
1660 int CWindowMaskTrackTumbler::handle_down_event()
1662 return do_event(-1);
1665 int CWindowMaskTrackTumbler::do_event(int dir)
1667 CWindowMaskItem *track_item = 0;
1668 CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1669 int n = gui->mask_on_track->track_items.size();
1670 int id = mwindow->cwindow->mask_track_id;
1673 while( --k >= 0 && items[k]->id != id );
1677 track_item = items[k];
1680 track_item = items[0];
1682 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1683 int track_id = track_item && track && track->record ? track_item->id : -1;
1684 gui->mask_on_track->set_back_color(track_id >= 0 ?
1685 gui->get_resources()->text_background :
1686 gui->get_resources()->text_background_disarmed);
1687 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1688 mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1689 mwindow->edl->local_session->solo_track_id = -1;
1690 gui->mask_solo_track->update(0);
1692 gui->update_preview(1);
1697 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1698 int x, int y, const char *text)
1699 : BC_PopupTextBox(gui, 0, text, x, y, xS(100), yS(160))
1701 this->mwindow = mwindow;
1705 CWindowMaskName::~CWindowMaskName()
1709 int CWindowMaskName::handle_event()
1716 //printf("CWindowMaskGUI::update 1\n");
1717 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1719 int k = get_number();
1720 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1721 else mwindow->edl->session->cwindow_mask = k;
1722 if( k >= 0 && k < mask_items.size() ) {
1723 mask_items[k]->set_text(get_text());
1724 update_list(&mask_items);
1726 #ifdef USE_KEYFRAME_SPANNING
1727 MaskAuto temp_keyframe(mwindow->edl, autos);
1728 temp_keyframe.copy_data(keyframe);
1729 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1730 memset(submask->name, 0, sizeof(submask->name));
1731 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1732 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1734 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1735 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1736 memset(submask->name, 0, sizeof(submask->name));
1737 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1738 current = current == (MaskAuto*)autos->default_auto ?
1739 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1743 gui->update_preview();
1748 void CWindowMaskName::update_items(MaskAuto *keyframe)
1750 mask_items.remove_all_objects();
1751 int sz = !keyframe ? 0 : keyframe->masks.size();
1752 for( int i=0; i<SUBMASKS; ++i ) {
1753 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
1755 SubMask *sub_mask = keyframe->masks.get(i);
1756 strncpy(text, sub_mask->name, sizeof(text)-1);
1759 sprintf(text, "%d", i);
1760 mask_items.append(new CWindowMaskItem(text));
1762 update_list(&mask_items);
1766 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1767 int x, int y, int no, int v)
1768 : BC_CheckBox(x, y, v)
1770 this->mwindow = mwindow;
1775 CWindowMaskButton::~CWindowMaskButton()
1779 int CWindowMaskButton::handle_event()
1781 mwindow->edl->session->cwindow_mask = no;
1782 gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1784 gui->update_preview();
1788 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1792 this->mwindow = mwindow;
1796 CWindowMaskThumbler::~CWindowMaskThumbler()
1800 int CWindowMaskThumbler::handle_up_event()
1805 int CWindowMaskThumbler::handle_down_event()
1807 return do_event(-1);
1810 int CWindowMaskThumbler::do_event(int dir)
1812 int k = mwindow->edl->session->cwindow_mask;
1813 if( (k+=dir) >= SUBMASKS ) k = 0;
1814 else if( k < 0 ) k = SUBMASKS-1;
1815 mwindow->edl->session->cwindow_mask = k;
1816 gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1818 gui->update_preview();
1822 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1823 int x, int y, int no, int v)
1824 : BC_CheckBox(x, y, v)
1826 this->mwindow = mwindow;
1831 CWindowMaskEnable::~CWindowMaskEnable()
1835 int CWindowMaskEnable::handle_event()
1837 Track *track = mwindow->cwindow->calculate_mask_track();
1839 mwindow->undo->update_undo_before(_("mask enable"), this);
1842 track->masks |= bit;
1844 track->masks &= ~bit;
1846 gui->update_preview(1);
1847 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1852 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1853 CWindowMaskGUI *gui, int x, int y)
1854 : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1856 this->mwindow = mwindow;
1858 set_tooltip(_("Show/Hide mask"));
1861 int CWindowMaskUnclear::handle_event()
1863 Track *track = mwindow->cwindow->calculate_mask_track();
1865 mwindow->undo->update_undo_before(_("mask enables"), this);
1866 int m = (1<<SUBMASKS)-1;
1867 if( track->masks == m )
1871 for( int i=0; i<SUBMASKS; ++i )
1872 gui->mask_enables[i]->update((track->masks>>i) & 1);
1873 gui->update_preview(1);
1874 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
1879 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
1880 CWindowMaskGUI *gui, int x, int y, int v)
1881 : BC_CheckBox(x, y, v, _("Solo"))
1883 this->mwindow = mwindow;
1885 set_tooltip(_("Solo video track"));
1888 int CWindowMaskSoloTrack::handle_event()
1890 mwindow->edl->local_session->solo_track_id =
1891 get_value() ? mwindow->cwindow->mask_track_id : -1;
1892 gui->update_preview(1);
1896 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
1899 calculate_extents(gui, &w, &h, _("Solo"));
1903 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
1904 CWindowMaskGUI *gui, int x, int y)
1905 : BC_GenericButton(x, y, _("Delete"))
1907 this->mwindow = mwindow;
1909 set_tooltip(_("Delete mask"));
1912 int CWindowMaskDelMask::handle_event()
1921 // Get existing keyframe
1922 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1925 mwindow->undo->update_undo_before(_("mask delete"), 0);
1927 #ifdef USE_KEYFRAME_SPANNING
1928 // Create temp keyframe
1929 MaskAuto temp_keyframe(mwindow->edl, autos);
1930 temp_keyframe.copy_data(keyframe);
1931 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1932 submask->points.remove_all_objects();
1934 // Commit change to span of keyframes
1935 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1937 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1938 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1939 submask->points.remove_all_objects();
1940 current = current == (MaskAuto*)autos->default_auto ?
1941 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1945 if( mwindow->cwindow->gui->affected_point >= total_points )
1946 mwindow->cwindow->gui->affected_point =
1947 total_points > 0 ? total_points-1 : 0;
1950 gui->update_preview();
1951 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1957 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
1958 CWindowMaskGUI *gui, int x, int y)
1959 : BC_GenericButton(x, y, _("Delete"))
1961 this->mwindow = mwindow;
1963 set_tooltip(_("Delete point"));
1966 int CWindowMaskDelPoint::handle_event()
1975 // Get existing keyframe
1976 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1978 mwindow->undo->update_undo_before(_("point delete"), 0);
1980 #ifdef USE_KEYFRAME_SPANNING
1981 // Create temp keyframe
1982 MaskAuto temp_keyframe(mwindow->edl, autos);
1983 temp_keyframe.copy_data(keyframe);
1985 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1986 int i = mwindow->cwindow->gui->affected_point;
1987 for( ; i<submask->points.total-1; ++i )
1988 *submask->points.values[i] = *submask->points.values[i+1];
1989 if( submask->points.total > 0 ) {
1990 point = submask->points.values[submask->points.total-1];
1991 submask->points.remove_object(point);
1993 total_points = submask->points.total;
1995 // Commit change to span of keyframes
1996 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1999 MaskAuto *current = (MaskAuto*)autos->default_auto;
2001 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2002 int i = mwindow->cwindow->gui->affected_point;
2003 for( ; i<submask->points.total-1; ++i )
2004 *submask->points.values[i] = *submask->points.values[i+1];
2005 if( submask->points.total > 0 ) {
2006 point = submask->points.values[submask->points.total-1];
2007 submask->points.remove_object(point);
2009 total_points = submask->points.total;
2010 current = current == (MaskAuto*)autos->default_auto ?
2011 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2014 if( mwindow->cwindow->gui->affected_point >= total_points )
2015 mwindow->cwindow->gui->affected_point =
2016 total_points > 0 ? total_points-1 : 0;
2019 gui->update_preview();
2020 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
2027 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
2028 CWindowMaskGUI *gui, int x, int y)
2029 : BC_TumbleTextBox(gui,
2030 (int64_t)mwindow->cwindow->gui->affected_point,
2031 (int64_t)0, INT64_MAX, x, y, xS(70))
2033 this->mwindow = mwindow;
2037 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
2041 int CWindowMaskAffectedPoint::handle_event()
2043 int total_points = 0;
2044 int affected_point = atol(get_text());
2045 Track *track = mwindow->cwindow->calculate_mask_track();
2047 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2048 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
2050 SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2051 total_points = mask->points.size();
2054 int active_point = affected_point;
2055 if( affected_point >= total_points )
2056 affected_point = total_points - 1;
2057 if( affected_point < 0 )
2059 if( active_point != affected_point )
2060 update((int64_t)affected_point);
2061 mwindow->cwindow->gui->affected_point = affected_point;
2063 gui->update_preview();
2068 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2069 : BC_CheckBox(x, y, gui->focused, _("Focus"))
2071 this->mwindow = mwindow;
2073 set_tooltip(_("Center for rotate/scale"));
2076 CWindowMaskFocus::~CWindowMaskFocus()
2080 int CWindowMaskFocus::handle_event()
2082 gui->focused = get_value();
2084 gui->update_preview();
2088 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
2091 calculate_extents(gui, &w, &h, _("Focus"));
2095 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
2096 int x, int y, VFrame **data, int v, int id, const char *tip)
2097 : BC_Toggle(x, y, data, v)
2100 this->mwindow = mwindow;
2105 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2109 int CWindowMaskScaleXY::handle_event()
2111 gui->scale_mode = id;
2112 gui->mask_scale_x->update(id == MASK_SCALE_X);
2113 gui->mask_scale_y->update(id == MASK_SCALE_Y);
2114 gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2118 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2119 : BC_CheckBox(x, y, 0, _("Help"))
2121 this->mwindow = mwindow;
2123 set_tooltip(_("Show help text"));
2126 CWindowMaskHelp::~CWindowMaskHelp()
2130 int CWindowMaskHelp::handle_event()
2132 gui->helped = get_value();
2133 gui->resize_window(gui->get_w(),
2134 gui->helped ? gui->help_h : gui->help_y);
2139 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2140 : BC_CheckBox(x, y, gui->markers, _("Markers"))
2142 this->mwindow = mwindow;
2144 set_tooltip("Display points");
2147 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2151 int CWindowMaskDrawMarkers::handle_event()
2153 gui->markers = get_value();
2155 gui->update_preview();
2159 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2160 : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2162 this->mwindow = mwindow;
2164 set_tooltip("Display mask outline");
2167 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2171 int CWindowMaskDrawBoundary::handle_event()
2173 gui->boundary = get_value();
2175 gui->update_preview();
2180 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2181 : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, xS(64), 2)
2183 this->mwindow = mwindow;
2186 CWindowMaskFeather::~CWindowMaskFeather()
2190 int CWindowMaskFeather::update(float v)
2192 gui->feather_slider->update(v);
2193 return BC_TumbleTextBox::update(v);
2196 int CWindowMaskFeather::update_value(float v)
2203 #ifdef USE_KEYFRAME_SPANNING
2209 mwindow->undo->update_undo_before(_("mask feather"), this);
2211 // Get existing keyframe
2212 gui->get_keyframe(track, autos, keyframe,
2213 mask, point, create_it);
2215 int gang = gui->gang_feather->get_value();
2216 #ifdef USE_KEYFRAME_SPANNING
2217 MaskAuto temp_keyframe(mwindow->edl, autos);
2218 temp_keyframe.copy_data(keyframe);
2219 keyframe = &temp_keyframe;
2221 float change = v - mask->feather;
2222 int k = mwindow->edl->session->cwindow_mask;
2223 int n = gang ? keyframe->masks.size() : k+1;
2224 for( int i=gang? 0 : k; i<n; ++i ) {
2225 if( !gui->mask_enables[i]->get_value() ) continue;
2226 SubMask *sub_mask = keyframe->get_submask(i);
2227 float feather = sub_mask->feather + change;
2228 sub_mask->feather = feather;
2230 #ifdef USE_KEYFRAME_SPANNING
2231 autos->update_parameter(keyframe);
2233 gui->update_preview();
2236 mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2240 int CWindowMaskFeather::handle_event()
2242 float v = atof(get_text());
2243 if( fabsf(v) > MAX_FEATHER )
2244 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2245 gui->feather_slider->update(v);
2246 return gui->feather->update_value(v);
2249 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2250 CWindowMaskGUI *gui, int x, int y, int w, float v)
2251 : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2253 this->mwindow = mwindow;
2255 set_precision(0.01);
2256 timer = new Timer();
2262 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2267 int CWindowMaskFeatherSlider::handle_event()
2270 float v = get_value();
2271 if( fabsf(v) > MAX_FEATHER )
2272 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2273 if( stick && timer->get_difference() >= 250 )
2274 stick = 0; // no events for .25 sec
2275 if( stick && (last_v * (v-last_v)) < 0 )
2276 stick = 0; // dv changed direction
2285 if( max > MAX_FEATHER ) max = MAX_FEATHER;
2286 update(get_w(), v=last_v, -max-5, max+5);
2287 button_release_event();
2290 else if( v > max ) { v = max; sticky = 24; }
2291 else if( v < -max ) { v = -max; sticky = 24; }
2292 else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0; sticky = 16; }
2293 if( sticky ) { update(v); stick = sticky; timer->update(); }
2295 gui->feather->BC_TumbleTextBox::update(v);
2296 return gui->feather->update_value(v);
2299 int CWindowMaskFeatherSlider::update(float v)
2301 float vv = fabsf(v);
2302 if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2303 while( max < vv ) max *= 1.25;
2304 return update(get_w(), v, -max-5, max+5);
2306 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2308 return BC_FSlider::update(r, v, mn, mx);
2311 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2312 : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, xS(64), 2)
2314 this->mwindow = mwindow;
2317 CWindowMaskFade::~CWindowMaskFade()
2321 int CWindowMaskFade::update(float v)
2323 gui->fade_slider->update(v);
2324 return BC_TumbleTextBox::update(v);
2327 int CWindowMaskFade::update_value(float v)
2334 #ifdef USE_KEYFRAME_SPANNING
2340 mwindow->undo->update_undo_before(_("mask fade"), this);
2342 // Get existing keyframe
2343 gui->get_keyframe(track, autos, keyframe,
2344 mask, point, create_it);
2346 int gang = gui->gang_fader->get_value();
2347 #ifdef USE_KEYFRAME_SPANNING
2348 MaskAuto temp_keyframe(mwindow->edl, autos);
2349 temp_keyframe.copy_data(keyframe);
2350 keyframe = &temp_keyframe;
2352 float change = v - mask->fader;
2353 int k = mwindow->edl->session->cwindow_mask;
2354 int n = gang ? keyframe->masks.size() : k+1;
2355 for( int i=gang? 0 : k; i<n; ++i ) {
2356 if( !gui->mask_enables[i]->get_value() ) continue;
2357 SubMask *sub_mask = keyframe->get_submask(i);
2358 float fader = sub_mask->fader + change;
2359 bclamp(fader, -100.f, 100.f);
2360 sub_mask->fader = fader;
2362 #ifdef USE_KEYFRAME_SPANNING
2363 autos->update_parameter(keyframe);
2365 gui->update_preview();
2368 mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2372 int CWindowMaskFade::handle_event()
2374 float v = atof(get_text());
2375 gui->fade_slider->update(v);
2376 return gui->fade->update_value(v);
2379 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2380 int x, int y, int w)
2381 : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2383 this->mwindow = mwindow;
2385 timer = new Timer();
2390 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2395 int CWindowMaskFadeSlider::handle_event()
2397 float v = 100*get_value()/200;
2399 int64_t ms = timer->get_difference();
2400 if( ms < 250 && --stick > 0 ) {
2401 if( get_value() == 0 ) return 1;
2409 else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2416 gui->fade->BC_TumbleTextBox::update(v);
2417 return gui->fade->update_value(v);
2420 int CWindowMaskFadeSlider::update(int64_t v)
2422 return BC_ISlider::update(200*v/100);
2425 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2426 CWindowMaskGUI *gui, int x, int y)
2427 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2429 this->mwindow = mwindow;
2431 set_tooltip(_("Gang fader"));
2434 CWindowMaskGangFader::~CWindowMaskGangFader()
2438 int CWindowMaskGangFader::handle_event()
2443 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2444 CWindowMaskGUI *gui, int x, int y)
2445 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2447 this->mwindow = mwindow;
2449 set_tooltip(_("Gang rotate/scale/translate"));
2452 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2456 int CWindowMaskGangFocus::handle_event()
2461 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2462 CWindowMaskGUI *gui, int x, int y)
2463 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2465 this->mwindow = mwindow;
2467 set_tooltip(_("Gang points"));
2470 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2474 int CWindowMaskGangPoint::handle_event()
2480 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2481 const char *tip, int type, int on, int x, int y, const char *images)
2482 : BC_Button(x, y, mwindow->theme->get_image_set(images))
2484 this->mwindow = mwindow;
2491 int CWindowMaskSmoothButton::handle_event()
2493 return gui->smooth_mask(type, on);
2496 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2497 : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2502 int CWindowMaskBeforePlugins::handle_event()
2509 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2512 int v = get_value();
2513 #ifdef USE_KEYFRAME_SPANNING
2514 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2515 temp_keyframe.copy_data(keyframe);
2516 temp_keyframe.apply_before_plugins = v;
2517 autos->update_parameter(&temp_keyframe);
2519 keyframe->apply_before_plugins = v;
2521 gui->update_preview();
2527 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2528 : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2533 int CWindowDisableOpenGLMasking::handle_event()
2540 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2543 int v = get_value();
2544 #ifdef USE_KEYFRAME_SPANNING
2545 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2546 temp_keyframe.copy_data(keyframe);
2547 temp_keyframe.disable_opengl_masking = v;
2548 autos->update_parameter(&temp_keyframe);
2550 keyframe->disable_opengl_masking = v;
2552 gui->update_preview();
2558 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2559 CWindowMaskGUI *gui, int x, int y)
2560 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2562 this->mwindow = mwindow;
2564 set_tooltip(_("Delete all masks"));
2567 CWindowMaskClrMask::~CWindowMaskClrMask()
2571 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2573 VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2574 return vfrm->get_w();
2577 int CWindowMaskClrMask::handle_event()
2585 // Get existing keyframe
2586 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2589 mwindow->undo->update_undo_before(_("del masks"), 0);
2590 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2591 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2595 gui->update_preview(1);
2599 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2600 CWindowMaskGUI *gui, int x, int y)
2601 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2603 this->mwindow = mwindow;
2605 set_tooltip(_("Gang feather"));
2608 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2612 int CWindowMaskGangFeather::handle_event()
2617 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2618 : CWindowToolGUI(mwindow, thread,
2619 _(PROGRAM_NAME ": Mask"), xS(440), yS(700))
2621 this->mwindow = mwindow;
2622 this->thread = thread;
2632 CWindowMaskGUI::~CWindowMaskGUI()
2634 lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2636 delete active_point;
2640 delete preset_dialog;
2643 void CWindowMaskGUI::create_objects()
2646 Theme *theme = mwindow->theme;
2647 int xs10 = xS(10), ys10 = yS(10);
2648 int x = xs10, y = ys10;
2649 int margin = theme->widget_border;
2650 int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2651 int clr_x = get_w()-x - clr_w;
2653 lock_window("CWindowMaskGUI::create_objects");
2654 BC_TitleBar *title_bar;
2655 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2656 _("Masks on Track")));
2657 y += title_bar->get_h() + margin;
2659 add_subwindow(title = new BC_Title(x,y, _("Track:")));
2660 int x1 = x + xS(90), ww = clr_x-2*margin - x1;
2661 for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2663 Track *track = mwindow->cwindow->calculate_affected_track();
2664 const char *text = track ? track->title : "";
2665 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2666 mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, xS(100), text);
2667 mask_on_track->create_objects();
2668 mask_on_track->set_tooltip(_("Video track"));
2669 int x2 = x1 + mask_on_track->get_w();
2670 add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2671 mwindow->edl->local_session->solo_track_id = -1;
2672 add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2673 y += mask_on_track->get_h() + margin;
2674 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2676 y += title_bar->get_h() + margin;
2677 add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2678 mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2679 mask_name->create_objects();
2680 mask_name->set_tooltip(_("Mask name"));
2681 add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2682 add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2683 y += mask_name->get_h() + 2*margin;
2685 // add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2686 // y += bar->get_h() + 2*margin;
2688 add_subwindow(title = new BC_Title(x, y, _("Select:")));
2690 BC_CheckBox::calculate_extents(this, &bw, &bh);
2691 for( int i=0; i<SUBMASKS; ++i ) {
2692 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2693 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2694 add_subwindow(mask_buttons[i]);
2696 add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2698 for( int i=0; i<SUBMASKS; ++i ) {
2699 char text[BCSTRLEN]; sprintf(text, "%d", i);
2700 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2701 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2702 add_subwindow(mask_blabels[i]);
2704 y += mask_blabels[0]->get_h() + margin;
2705 add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2706 for( int i=0; i<SUBMASKS; ++i ) {
2707 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2708 add_subwindow(mask_enables[i]);
2710 add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2711 y += mask_enables[0]->get_h() + 2*margin;
2712 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2713 _("Preset Shapes")));
2714 y += title_bar->get_h() + margin;
2715 add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2716 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2717 add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2718 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2719 add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2720 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2721 add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2722 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2723 add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2724 add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, xS(80)));
2725 add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, xS(80)));
2726 add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, xS(80)));
2727 y += mask_load->get_h() + 2*margin;
2728 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2729 _("Position & Scale")));
2730 y += title_bar->get_h() + 2*margin;
2731 add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, xS(80)));
2732 add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, xS(80)));
2734 add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2735 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2736 add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2737 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2738 add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2739 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2740 y += mask_center->get_h() + 2*margin;
2741 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2742 _("Fade & Feather")));
2743 y += title_bar->get_h() + 2*margin;
2745 add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2746 fade = new CWindowMaskFade(mwindow, this, x1, y);
2747 fade->create_objects();
2748 x2 = x1 + fade->get_w() + 2*margin;
2749 int w2 = clr_x-2*margin - x2;
2750 add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2751 add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2752 y += fade->get_h() + margin;
2753 add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2754 feather = new CWindowMaskFeather(mwindow, this, x1, y);
2755 feather->create_objects();
2756 w2 = clr_x - 2*margin - x2;
2757 feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2758 add_subwindow(feather_slider);
2759 add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2760 y += feather->get_h() + 2*margin;
2761 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2763 y += title_bar->get_h() + margin;
2765 add_subwindow(title = new BC_Title(x, y, _("Point:")));
2766 active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2767 active_point->create_objects();
2768 // typ=0, this mask, this point
2769 add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2770 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2771 add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2772 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2773 add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2774 add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2775 y += active_point->get_h() + margin;
2776 add_subwindow(title = new BC_Title(x, y, "X:"));
2777 this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2778 this->x->create_objects();
2779 // typ>0, this mask, all points
2780 add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2781 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2782 add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2783 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2784 add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2785 y += this->x->get_h() + margin;
2786 add_subwindow(title = new BC_Title(x, y, "Y:"));
2787 this->y = new CWindowCoord(this, x1, y, (float)0.0);
2788 this->y->create_objects();
2789 // typ<0, all masks, all points
2790 add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2791 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2792 add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2793 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2794 add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2795 y += this->y->get_h() + 2*margin;
2796 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2798 y += title_bar->get_h() + margin;
2800 add_subwindow(title = new BC_Title(x, y, "X:"));
2801 float cx = mwindow->edl->session->output_w / 2.f;
2802 focus_x = new CWindowCoord(this, x1, y, cx);
2803 focus_x->create_objects();
2804 add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2805 add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2806 y += focus_x->get_h() + margin;
2807 add_subwindow(title = new BC_Title(x, y, "Y:"));
2808 float cy = mwindow->edl->session->output_h / 2.f;
2809 focus_y = new CWindowCoord(this, x1, y, cy);
2810 focus_y->create_objects();
2811 y += focus_y->get_h() + 2*margin;
2812 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2813 y += bar->get_h() + margin;
2814 add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, x, y));
2815 y += this->apply_before_plugins->get_h();
2816 add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, x, y));
2817 add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2818 y += this->disable_opengl_masking->get_h() + 2*margin;
2820 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2821 y += bar->get_h() + 2*margin;
2822 add_subwindow(title = new BC_Title(x, y, _(
2823 "Shift+LMB: move an end point\n"
2824 "Ctrl+LMB: move a control point\n"
2825 "Alt+LMB: to drag translate the mask\n"
2826 "Shift+MMB: Set Pivot Point at pointer\n"
2827 "Wheel: rotate around Pivot Point\n"
2828 "Shift+Wheel: scale around Pivot Point\n"
2829 "Ctrl+Wheel: rotate/scale around pointer")));
2830 help_h = y + title->get_h() + 2*margin;
2832 resize_window(get_w(), help_y);
2836 int CWindowMaskGUI::close_event()
2839 return CWindowToolGUI::close_event();
2842 void CWindowMaskGUI::done_event()
2844 if( mwindow->in_destructor ) return;
2845 int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2846 if( solo_track_id >= 0 ) {
2852 void CWindowMaskGUI::get_keyframe(Track* &track,
2853 MaskAutos* &autos, MaskAuto* &keyframe,
2854 SubMask* &mask, MaskPoint* &point, int create_it)
2859 track = mwindow->cwindow->calculate_mask_track();
2861 track = mwindow->cwindow->calculate_affected_track();
2864 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2865 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2870 mask = !keyframe ? 0 :
2871 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2875 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
2876 mwindow->cwindow->gui->affected_point >= 0 ) {
2877 point = mask->points.values[mwindow->cwindow->gui->affected_point];
2882 void CWindowMaskGUI::update()
2889 //printf("CWindowMaskGUI::update 1\n");
2890 get_keyframe(track, autos, keyframe, mask, point, 0);
2891 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2892 mask_on_track->set_back_color(!track || track->record ?
2893 get_resources()->text_background :
2894 get_resources()->text_background_disarmed);
2895 mask_on_track->update_items();
2896 mask_on_track->update(!track ? "" : track->title);
2897 mask_name->update_items(keyframe);
2898 const char *text = "";
2899 int sz = !keyframe ? 0 : keyframe->masks.size();
2900 int k = mwindow->edl->session->cwindow_mask;
2901 if( k >= 0 && k < sz )
2902 text = keyframe->masks[k]->name;
2904 k = mwindow->edl->session->cwindow_mask = 0;
2905 mask_name->update(text);
2906 update_buttons(keyframe, k);
2908 x->update(point->x);
2909 y->update(point->y);
2912 double position = mwindow->edl->local_session->get_selectionstart(1);
2913 int64_t position_i = track->to_units(position, 0);
2914 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
2915 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
2916 int show_mask = track->masks;
2917 for( int i=0; i<SUBMASKS; ++i )
2918 mask_enables[i]->update((show_mask>>i) & 1);
2921 apply_before_plugins->update(keyframe->apply_before_plugins);
2922 disable_opengl_masking->update(keyframe->disable_opengl_masking);
2924 active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2927 void CWindowMaskGUI::handle_event()
2930 if( event_caller == this->focus_x ||
2931 event_caller == this->focus_y ) {
2934 else if( event_caller == this->x ||
2935 event_caller == this->y ) {
2941 get_keyframe(track, autos, keyframe, mask, point, 0);
2943 mwindow->undo->update_undo_before(_("mask point"), this);
2946 float px = atof(x->get_text());
2947 float py = atof(y->get_text());
2948 float dx = px - point->x, dy = py - point->y;
2949 #ifdef USE_KEYFRAME_SPANNING
2950 // Create temp keyframe
2951 MaskAuto temp_keyframe(mwindow->edl, autos);
2952 temp_keyframe.copy_data(keyframe);
2953 // Get affected point in temp keyframe
2954 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2956 MaskPoints &points = mask->points;
2957 int gang = gang_point->get_value();
2958 int k = mwindow->cwindow->gui->affected_point;
2959 int n = gang ? points.size() : k+1;
2960 for( int i=gang? 0 : k; i<n; ++i ) {
2961 if( i < 0 || i >= points.size() ) continue;
2962 MaskPoint *point = points[i];
2963 point->x += dx; point->y += dy;
2965 #ifdef USE_KEYFRAME_SPANNING
2966 // Commit to spanned keyframes
2967 autos->update_parameter(&temp_keyframe);
2970 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2978 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
2980 CWindowGUI *cgui = mwindow->cwindow->gui;
2981 cgui->unlock_window();
2982 lock_window("CWindowMaskGUI::set_focused");
2984 focus->update(focused = v);
2985 focus_x->update(cx);
2986 focus_y->update(cy);
2988 cgui->lock_window("CWindowCanvas::set_focused");
2991 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
2993 int text_color = get_resources()->default_text_color;
2994 int high_color = get_resources()->button_highlighted;
2995 for( int i=0; i<SUBMASKS; ++i ) {
2996 int color = text_color;
2998 SubMask *submask = keyframe->get_submask(i);
2999 if( submask && submask->points.size() )
3002 mask_blabels[i]->set_color(color);
3003 mask_buttons[i]->update(i==k ? 1 : 0);
3007 // typ=0, this mask, this point
3008 // typ>0, this mask, all points
3009 // typ<0, all masks, all points
3010 // dxy= on? pt[+1]-pt[-1] : dxy=0
3011 int CWindowMaskGUI::smooth_mask(int typ, int on)
3018 #ifdef USE_KEYFRAME_SPANNING
3024 mwindow->undo->update_undo_before(_("mask smooth"), this);
3026 // Get existing keyframe
3027 get_keyframe(track, autos, keyframe,
3028 mask, point, create_it);
3030 #ifdef USE_KEYFRAME_SPANNING
3031 MaskAuto temp_keyframe(mwindow->edl, autos);
3032 temp_keyframe.copy_data(keyframe);
3033 keyframe = &temp_keyframe;
3035 int k = mwindow->edl->session->cwindow_mask;
3036 int n = typ>=0 ? k+1 : keyframe->masks.size();
3037 for( int j=typ<0? 0 : k; j<n; ++j ) {
3038 if( !mask_enables[j]->get_value() ) continue;
3039 SubMask *sub_mask = keyframe->get_submask(j);
3040 MaskPoints &points = sub_mask->points;
3041 int psz = points.size();
3042 if( psz < 3 ) continue;
3043 int l = mwindow->cwindow->gui->affected_point;
3044 if( l > psz ) l = psz;
3045 int m = typ ? psz : l+1;
3046 for( int i=typ ? 0 : l; i<m; ++i ) {
3047 int i0 = i-1, i1 = i+1;
3048 if( i0 < 0 ) i0 = psz-1;
3049 if( i1 >= psz ) i1 = 0;
3050 MaskPoint *p0 = points[i0];
3051 MaskPoint *p = points[i];
3052 MaskPoint *p1 = points[i1];
3053 float dx = !on ? 0 : p1->x - p0->x;
3054 float dy = !on ? 0 : p1->y - p0->y;
3055 p->control_x1 = -dx/4; p->control_y1 = -dy/4;
3056 p->control_x2 = dx/4; p->control_y2 = dy/4;
3059 #ifdef USE_KEYFRAME_SPANNING
3060 autos->update_parameter(keyframe);
3065 mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
3069 int CWindowMaskGUI::save_mask(const char *nm)
3071 int k = mwindow->edl->session->cwindow_mask;
3077 get_keyframe(track, autos, keyframe, mask, point, 0);
3078 if( !track ) return 0;
3079 SubMask *sub_mask = keyframe->get_submask(k);
3080 ArrayList<SubMask *> masks;
3082 int i = masks.size();
3084 if( strcmp(masks[i]->name, nm) ) continue;
3085 masks.remove_object_number(i);
3087 mask = new SubMask(0, -1);
3088 strncpy(mask->name, nm, sizeof(mask->name)-1);
3089 mask->copy_from(*sub_mask, 0);
3092 masks.remove_all_objects();
3096 int CWindowMaskGUI::del_mask(const char *nm)
3098 ArrayList<SubMask *> masks;
3100 int i = masks.size();
3102 if( strcmp(masks[i]->name, nm) ) continue;
3103 masks.remove_object_number(i);
3106 masks.remove_all_objects();
3110 int CWindowMaskGUI::center_mask()
3112 int k = mwindow->edl->session->cwindow_mask;
3118 #ifdef USE_KEYFRAME_SPANNING
3123 get_keyframe(track, autos, keyframe,
3124 mask, point, create_it);
3125 if( !track ) return 0;
3126 mwindow->undo->update_undo_before(_("mask center"), this);
3128 // Get existing keyframe
3129 #ifdef USE_KEYFRAME_SPANNING
3130 MaskAuto temp_keyframe(mwindow->edl, autos);
3131 temp_keyframe.copy_data(keyframe);
3132 keyframe = &temp_keyframe;
3134 SubMask *sub_mask = keyframe->get_submask(k);
3135 MaskPoints &points = sub_mask->points;
3136 int psz = points.size();
3138 float cx = 0, cy = 0;
3139 for( int i=0; i<psz; ++i ) {
3140 MaskPoint *p = points[i];
3141 cx += p->x; cy += p->y;
3143 cx /= psz; cy /= psz;
3144 cx -= mwindow->edl->session->output_w / 2.f;
3145 cy -= mwindow->edl->session->output_h / 2.f;
3146 for( int i=0; i<psz; ++i ) {
3147 MaskPoint *p = points[i];
3148 p->x -= cx; p->y -= cy;
3151 #ifdef USE_KEYFRAME_SPANNING
3152 autos->update_parameter(keyframe);
3155 mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3159 int CWindowMaskGUI::normal_mask()
3161 int k = mwindow->edl->session->cwindow_mask;
3167 #ifdef USE_KEYFRAME_SPANNING
3172 // Get existing keyframe
3173 get_keyframe(track, autos, keyframe,
3174 mask, point, create_it);
3175 if( !track ) return 0;
3176 mwindow->undo->update_undo_before(_("mask normal"), this);
3178 #ifdef USE_KEYFRAME_SPANNING
3179 MaskAuto temp_keyframe(mwindow->edl, autos);
3180 temp_keyframe.copy_data(keyframe);
3181 keyframe = &temp_keyframe;
3183 SubMask *sub_mask = keyframe->get_submask(k);
3184 MaskPoints &points = sub_mask->points;
3185 int psz = points.size();
3186 float cx = 0, cy = 0;
3189 for( int i=0; i<psz; ++i ) {
3190 MaskPoint *p = points[i];
3191 cx += p->x; cy += p->y;
3193 cx /= psz; cy /= psz;
3194 for( int i=0; i<psz; ++i ) {
3195 MaskPoint *p = points[i];
3196 float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3197 double d = sqrt(dx*dx + dy*dy);
3198 if( dr < d ) dr = d;
3202 float out_w = mwindow->edl->session->output_w;
3203 float out_h = mwindow->edl->session->output_h;
3204 float r = bmax(out_w, out_h);
3205 float s = r / (4 * dr * sqrt(2.));
3206 for( int i=0; i<psz; ++i ) {
3207 MaskPoint *p = points[i];
3208 float x = p->x, y = p->y;
3209 p->x = (x-cx) * s + cx;
3210 p->y = (y-cy) * s + cy;
3211 p->control_x1 *= s; p->control_y1 *= s;
3212 p->control_x2 *= s; p->control_y2 *= s;
3215 #ifdef USE_KEYFRAME_SPANNING
3216 autos->update_parameter(keyframe);
3220 mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3225 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3226 : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3228 this->mwindow = mwindow;
3233 CWindowMaskLoadList::~CWindowMaskLoadList()
3238 int CWindowMaskLoadList::handle_event()
3245 #ifdef USE_KEYFRAME_SPANNING
3251 mwindow->undo->update_undo_before(_("mask shape"), this);
3253 // Get existing keyframe
3254 gui->get_keyframe(track, autos, keyframe,
3255 mask, point, create_it);
3256 CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3257 if( track && item ) {
3258 #ifdef USE_KEYFRAME_SPANNING
3259 MaskAuto temp_keyframe(mwindow->edl, autos);
3260 temp_keyframe.copy_data(keyframe);
3261 keyframe = &temp_keyframe;
3262 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3264 ArrayList<SubMask *> masks;
3265 gui->load_masks(masks);
3266 mask->copy_from(*masks[item->id], 0);
3267 masks.remove_all_objects();
3268 #ifdef USE_KEYFRAME_SPANNING
3269 autos->update_parameter(keyframe);
3272 gui->update_preview(1);
3274 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3278 void CWindowMaskLoadList::create_objects()
3280 shape_items.remove_all_objects();
3281 ArrayList<SubMask *> masks;
3282 gui->load_masks(masks);
3283 for( int i=0; i<masks.size(); ++i )
3284 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3285 masks.remove_all_objects();
3286 update(&shape_items, 0, 0, 1);
3289 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3290 CWindowMaskGUI *gui, int x, int y, int w)
3291 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3293 this->mwindow = mwindow;
3295 set_tooltip(_("Load preset"));
3298 int CWindowMaskLoad::handle_event()
3300 gui->mask_load_list->create_objects();
3302 get_abs_cursor(px, py);
3303 return gui->mask_load_list->activate(px, py, xS(120),yS(160));
3307 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3308 CWindowMaskGUI *gui, int x, int y, int w)
3309 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3311 this->mwindow = mwindow;
3313 set_tooltip(_("Save preset"));
3316 CWindowMaskSave::~CWindowMaskSave()
3320 int CWindowMaskSave::handle_event()
3327 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3330 gui->get_abs_cursor(sx, sy);
3331 if( !gui->preset_dialog )
3332 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3333 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3338 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3341 this->mwindow = mwindow;
3346 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3351 void CWindowMaskPresetDialog::handle_close_event(int result)
3356 void CWindowMaskPresetDialog::handle_done_event(int result)
3358 if( result ) return;
3359 const char *nm = pgui->preset_text->get_text();
3366 BC_Window* CWindowMaskPresetDialog::new_gui()
3368 pgui = new CWindowMaskPresetGUI(this, sx, sy,
3369 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3370 _(PROGRAM_NAME ": Delete Mask"));
3371 pgui->create_objects();
3375 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3378 this->sx = sx; this->sy = sy;
3379 this->keyframe = keyframe;
3383 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3384 int x, int y, const char *title)
3385 : BC_Window(title, x, y, xS(320), yS(100), xS(320), yS(100), 0, 0, 1)
3387 this->preset_dialog = preset_dialog;
3390 void CWindowMaskPresetGUI::create_objects()
3392 int xs8 = xS(8), xs10 = xS(10);
3394 int x = xs10, y = ys10;
3395 lock_window("CWindowMaskPresetGUI::create_objects");
3397 add_subwindow(title = new BC_Title(x, y,
3398 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3399 int x1 = x + title->get_w() + xs8;
3400 int x2 = get_w() - x - xs8 - x1 -
3401 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3402 CWindowMaskGUI *gui = preset_dialog->gui;
3403 preset_text = new CWindowMaskPresetText(this,
3404 x1, y, x2, yS(120), gui->mask_name->get_text());
3405 preset_text->create_objects();
3406 preset_text->set_tooltip(_("Mask name"));
3407 preset_text->update_items();
3408 add_subwindow(new BC_OKButton(this));
3409 add_subwindow(new BC_CancelButton(this));
3415 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3416 int x, int y, int w, int h, const char *text)
3417 : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3422 int CWindowMaskPresetText::handle_event()
3424 int k = get_number();
3425 if( k >= 0 && k<mask_items.size() )
3426 update(mask_items[k]->get_text());
3430 void CWindowMaskPresetText::update_items()
3432 mask_items.remove_all_objects();
3433 ArrayList<SubMask *> masks;
3434 pgui->preset_dialog->gui->load_masks(masks);
3435 for( int i=0; i<masks.size(); ++i ) {
3436 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
3437 strncpy(text, masks[i]->name, sizeof(text)-1);
3438 mask_items.append(new CWindowMaskItem(text));
3440 masks.remove_all_objects();
3441 update_list(&mask_items);
3445 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3446 CWindowMaskGUI *gui, int x, int y, int w)
3447 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3449 this->mwindow = mwindow;
3451 set_tooltip(_("Delete preset"));
3454 int CWindowMaskDelete::handle_event()
3457 gui->get_abs_cursor(sx, sy);
3458 if( !gui->preset_dialog )
3459 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3460 gui->preset_dialog->start_dialog(sx, sy, 0);
3465 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3466 CWindowMaskGUI *gui, int x, int y, int w)
3467 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3469 this->mwindow = mwindow;
3471 set_tooltip(_("center mask"));
3474 int CWindowMaskCenter::handle_event()
3476 return gui->center_mask();
3480 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3481 CWindowMaskGUI *gui, int x, int y, int w)
3482 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3484 this->mwindow = mwindow;
3486 set_tooltip(_("normalize mask"));
3489 int CWindowMaskNormal::handle_event()
3491 return gui->normal_mask();
3495 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3496 const char *images, int shape, int x, int y, const char *tip)
3497 : BC_Button(x, y, mwindow->theme->get_image_set(images))
3499 this->mwindow = mwindow;
3501 this->shape = shape;
3505 CWindowMaskShape::~CWindowMaskShape()
3509 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3511 int out_w = mwindow->edl->session->output_w;
3512 int out_h = mwindow->edl->session->output_h;
3513 float cx = out_w/2.f, cy = out_h/2.f;
3514 float r = bmax(cx, cy) / 4.f;
3515 double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3516 float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3518 MaskPoints &points = sub_mask->points;
3519 points.remove_all_objects();
3521 case MASK_SHAPE_SQUARE:
3522 points.append(pt = new MaskPoint());
3523 pt->x = cx - r; pt->y = cy - r;
3524 points.append(pt = new MaskPoint());
3525 pt->x = cx + r; pt->y = cy - r;
3526 points.append(pt = new MaskPoint());
3527 pt->x = cx + r; pt->y = cy + r;
3528 points.append(pt = new MaskPoint());
3529 pt->x = cx - r; pt->y = cy + r;
3531 case MASK_SHAPE_CIRCLE:
3532 points.append(pt = new MaskPoint());
3533 pt->x = cx - r; pt->y = cy - r;
3534 pt->control_x1 = -rc; pt->control_y1 = rc;
3535 pt->control_x2 = rc; pt->control_y2 = -rc;
3536 points.append(pt = new MaskPoint());
3537 pt->x = cx + r; pt->y = cy - r;
3538 pt->control_x1 = -rc; pt->control_y1 = -rc;
3539 pt->control_x2 = rc; pt->control_y2 = rc;
3540 points.append(pt = new MaskPoint());
3541 pt->x = cx + r; pt->y = cy + r;
3542 pt->control_x1 = rc; pt->control_y1 = -rc;
3543 pt->control_x2 = -rc; pt->control_y2 = rc;
3544 points.append(pt = new MaskPoint());
3545 pt->x = cx - r; pt->y = cy + r;
3546 pt->control_x1 = rc; pt->control_y1 = rc;
3547 pt->control_x2 = -rc; pt->control_y2 = -rc;
3549 case MASK_SHAPE_TRIANGLE:
3550 points.append(pt = new MaskPoint());
3551 pt->x = cx + 0; pt->y = cy - r*(sqrt(3.)-1.);
3552 points.append(pt = new MaskPoint());
3553 pt->x = cx + r; pt->y = cy + r;
3554 points.append(pt = new MaskPoint());
3555 pt->x = cx - r; pt->y = cy + r;
3557 case MASK_SHAPE_OVAL:
3558 points.append(pt = new MaskPoint());
3559 pt->x = cx - r; pt->y = cy - r2;
3560 pt->control_x1 = -r2; pt->control_y1 = r4;
3561 pt->control_x2 = r2; pt->control_y2 = -r4;
3562 points.append(pt = new MaskPoint());
3563 pt->x = cx + r; pt->y = cy - r2;
3564 pt->control_x1 = -r2; pt->control_y1 = -r4;
3565 pt->control_x2 = r2; pt->control_y2 = r4;
3566 points.append(pt = new MaskPoint());
3567 pt->x = cx + r; pt->y = cy + r2;
3568 pt->control_x1 = r2; pt->control_y1 = -r4;
3569 pt->control_x2 = -r2; pt->control_y2 = r4;
3570 points.append(pt = new MaskPoint());
3571 pt->x = cx - r; pt->y = cy + r2;
3572 pt->control_x1 = r2; pt->control_y1 = r4;
3573 pt->control_x2 = -r2; pt->control_y2 = -r4;
3578 int CWindowMaskShape::handle_event()
3585 #ifdef USE_KEYFRAME_SPANNING
3591 mwindow->undo->update_undo_before(_("mask shape"), this);
3593 // Get existing keyframe
3594 gui->get_keyframe(track, autos, keyframe,
3595 mask, point, create_it);
3597 #ifdef USE_KEYFRAME_SPANNING
3598 MaskAuto temp_keyframe(mwindow->edl, autos);
3599 temp_keyframe.copy_data(keyframe);
3600 keyframe = &temp_keyframe;
3601 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3604 builtin_shape(shape, mask);
3605 #ifdef USE_KEYFRAME_SPANNING
3606 autos->update_parameter(keyframe);
3609 gui->update_preview(1);
3612 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3616 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3618 char path[BCTEXTLEN];
3619 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3621 fs.complete_path(path);
3623 file.read_from_file(path, 1);
3625 masks.remove_all_objects();
3627 while( !(result = file.read_tag()) ) {
3628 if( file.tag.title_is("MASK") ) {
3629 SubMask *sub_mask = new SubMask(0, -1);
3630 char name[BCTEXTLEN]; name[0] = 0;
3631 file.tag.get_property("NAME", name);
3632 strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3633 sub_mask->load(&file);
3634 masks.append(sub_mask);
3639 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3642 for( int i=0; i<masks.size(); ++i ) {
3643 SubMask *sub_mask = masks[i];
3644 sub_mask->copy(&file);
3646 file.terminate_string();
3648 char path[BCTEXTLEN];
3649 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3651 fs.complete_path(path);
3652 file.write_to_file(path);
3656 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3657 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), xS(320), yS(240))
3661 CWindowRulerGUI::~CWindowRulerGUI()
3665 void CWindowRulerGUI::create_objects()
3667 int xs10 = xS(10), xs200 = xS(200);
3668 int ys5 = yS(5), ys10 = yS(10);
3669 int x = xs10, y = ys10, x1 = xS(100);
3672 lock_window("CWindowRulerGUI::create_objects");
3673 add_subwindow(title = new BC_Title(x, y, _("Current:")));
3674 add_subwindow(current = new BC_TextBox(x1, y, xs200, 1, ""));
3675 y += title->get_h() + ys5;
3676 add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3677 add_subwindow(point1 = new BC_TextBox(x1, y, xs200, 1, ""));
3678 y += title->get_h() + ys5;
3679 add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3680 add_subwindow(point2 = new BC_TextBox(x1, y, xs200, 1, ""));
3681 y += title->get_h() + ys5;
3682 add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3683 add_subwindow(deltas = new BC_TextBox(x1, y, xs200, 1, ""));
3684 y += title->get_h() + ys5;
3685 add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3686 add_subwindow(distance = new BC_TextBox(x1, y, xs200, 1, ""));
3687 y += title->get_h() + ys5;
3688 add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3689 add_subwindow(angle = new BC_TextBox(x1, y, xs200, 1, ""));
3690 y += title->get_h() + ys10;
3691 char string[BCTEXTLEN];
3693 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3694 0xc2, 0xb0); // degrees utf
3695 add_subwindow(title = new BC_Title(x,
3698 y += title->get_h() + ys10;
3699 sprintf(string, _("Press Alt to translate the ruler."));
3700 add_subwindow(title = new BC_Title(x,
3707 void CWindowRulerGUI::update()
3709 char string[BCTEXTLEN];
3710 int cx = mwindow->session->cwindow_output_x;
3711 int cy = mwindow->session->cwindow_output_y;
3712 sprintf(string, "%d, %d", cx, cy);
3713 current->update(string);
3714 double x1 = mwindow->edl->session->ruler_x1;
3715 double y1 = mwindow->edl->session->ruler_y1;
3716 sprintf(string, "%.0f, %.0f", x1, y1);
3717 point1->update(string);
3718 double x2 = mwindow->edl->session->ruler_x2;
3719 double y2 = mwindow->edl->session->ruler_y2;
3720 sprintf(string, "%.0f, %.0f", x2, y2);
3721 point2->update(string);
3722 double dx = x2 - x1, dy = y2 - y1;
3723 sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3724 deltas->update(string);
3725 double d = sqrt(dx*dx + dy*dy);
3726 sprintf(string, _("%0.01f pixels"), d);
3727 distance->update(string);
3728 double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3729 sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3730 angle->update(string);
3733 void CWindowRulerGUI::handle_event()