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"
40 #include "gwindowgui.h"
43 #include "localsession.h"
44 #include "mainsession.h"
47 #include "maskautos.h"
50 #include "mwindowgui.h"
54 #include "trackcanvas.h"
55 #include "transportque.h"
59 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
62 this->mwindow = mwindow;
66 current_tool = CWINDOW_NONE;
68 input_lock = new Condition(0, "CWindowTool::input_lock");
69 output_lock = new Condition(1, "CWindowTool::output_lock");
70 tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
73 CWindowTool::~CWindowTool()
84 void CWindowTool::start_tool(int operation)
86 CWindowToolGUI *new_gui = 0;
89 //printf("CWindowTool::start_tool 1\n");
90 if(current_tool != operation)
92 int previous_tool = current_tool;
93 current_tool = operation;
97 new_gui = new CWindowEyedropGUI(mwindow, this);
100 new_gui = new CWindowCropGUI(mwindow, this);
103 new_gui = new CWindowCameraGUI(mwindow, this);
105 case CWINDOW_PROJECTOR:
106 new_gui = new CWindowProjectorGUI(mwindow, this);
109 new_gui = new CWindowMaskGUI(mwindow, this);
112 new_gui = new CWindowRulerGUI(mwindow, this);
114 case CWINDOW_PROTECT:
115 mwindow->edl->session->tool_window = 0;
116 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(0);
124 //printf("CWindowTool::start_tool 1\n");
130 // Wait for previous tool GUI to finish
131 output_lock->lock("CWindowTool::start_tool");
132 this->tool_gui = new_gui;
133 tool_gui->create_objects();
134 if( previous_tool == CWINDOW_PROTECT || previous_tool == CWINDOW_NONE ) {
135 mwindow->edl->session->tool_window = 1;
136 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
138 mwindow->edl->session->tool_window = new_gui ? 1 : 0;
139 update_show_window();
141 // Signal thread to run next tool GUI
142 input_lock->unlock();
144 //printf("CWindowTool::start_tool 1\n");
149 tool_gui->lock_window("CWindowTool::start_tool");
151 tool_gui->unlock_window();
154 //printf("CWindowTool::start_tool 2\n");
159 void CWindowTool::stop_tool()
163 tool_gui->lock_window("CWindowTool::stop_tool");
164 tool_gui->set_done(0);
165 tool_gui->unlock_window();
169 void CWindowTool::show_tool()
171 if(tool_gui && mwindow->edl->session->tool_window)
173 tool_gui->lock_window("CWindowTool::show_tool");
174 tool_gui->show_window();
175 tool_gui->unlock_window();
179 void CWindowTool::hide_tool()
181 if(tool_gui && mwindow->edl->session->tool_window)
183 tool_gui->lock_window("CWindowTool::show_tool");
184 tool_gui->hide_window();
185 tool_gui->unlock_window();
189 void CWindowTool::raise_tool()
191 if(tool_gui && mwindow->edl->session->tool_window)
193 tool_gui->lock_window("CWindowTool::show_tool");
194 tool_gui->raise_window();
195 tool_gui->unlock_window();
200 void CWindowTool::run()
204 input_lock->lock("CWindowTool::run");
207 tool_gui->run_window();
208 tool_gui_lock->lock("CWindowTool::run");
211 tool_gui_lock->unlock();
213 output_lock->unlock();
217 void CWindowTool::update_show_window()
221 tool_gui->lock_window("CWindowTool::update_show_window");
223 if(mwindow->edl->session->tool_window)
226 tool_gui->show_window();
229 tool_gui->hide_window();
232 tool_gui->unlock_window();
236 void CWindowTool::raise_window()
240 gui->unlock_window();
241 tool_gui->lock_window("CWindowTool::raise_window");
242 tool_gui->raise_window();
243 tool_gui->unlock_window();
244 gui->lock_window("CWindowTool::raise_window");
248 void CWindowTool::update_values()
250 tool_gui_lock->lock("CWindowTool::update_values");
253 tool_gui->lock_window("CWindowTool::update_values");
256 tool_gui->unlock_window();
258 tool_gui_lock->unlock();
267 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
268 CWindowTool *thread, const char *title, int w, int h)
270 mwindow->session->ctool_x, mwindow->session->ctool_y,
273 this->mwindow = mwindow;
274 this->thread = thread;
275 current_operation = 0;
279 CWindowToolGUI::~CWindowToolGUI()
283 int CWindowToolGUI::close_event()
287 mwindow->edl->session->tool_window = 0;
289 thread->gui->lock_window("CWindowToolGUI::close_event");
290 thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
291 thread->gui->flush();
292 thread->gui->unlock_window();
293 lock_window("CWindowToolGUI::close_event");
297 int CWindowToolGUI::keypress_event()
301 switch( get_keypress() ) {
304 return close_event();
317 resend_event(thread->gui);
324 int CWindowToolGUI::translation_event()
326 mwindow->session->ctool_x = get_x();
327 mwindow->session->ctool_y = get_y();
331 void CWindowToolGUI::update_auto(Track *track, int idx, CWindowCoord *vp)
333 FloatAuto *float_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
334 track->automation->autos[idx], 1);
335 if( !float_auto ) return;
336 float v = float_auto->get_value(edge);
337 float t = atof(vp->get_text());
339 float_auto->bump_value(t, edge, span);
340 if( idx == AUTOMATION_PROJECTOR_Z || idx == AUTOMATION_CAMERA_Z ) {
341 mwindow->gui->lock_window("CWindowToolGUI::update_auto");
342 mwindow->gui->draw_overlays(1);
343 mwindow->gui->unlock_window();
349 void CWindowToolGUI::update_preview(int changed_edl)
352 draw_preview(changed_edl);
353 lock_window("CWindowToolGUI::update_preview");
356 void CWindowToolGUI::draw_preview(int changed_edl)
358 CWindowGUI *cgui = mwindow->cwindow->gui;
359 cgui->lock_window("CWindowToolGUI::draw_preview");
360 int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
361 cgui->sync_parameters(change_type, 0, 1);
362 cgui->unlock_window();
366 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int type)
367 : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, xS(70), 3)
375 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value, int type)
376 : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, xS(70))
384 void CWindowCoord::create_objects()
386 BC_TumbleTextBox::create_objects();
388 int x1 = get_x() + BC_TumbleTextBox::get_w() + xS(10), y1 = get_y();
389 int group = Automation::autogrouptype(type, 0);
390 float min = gui->mwindow->edl->local_session->automation_mins[group];
391 float max = gui->mwindow->edl->local_session->automation_maxs[group];
392 float v = atof(get_text());
393 gui->add_subwindow(slider = new CWindowCoordSlider(this,
394 x1, y1, xS(150), min, max, v));
395 x1 += slider->get_w() + xS(5);
396 gui->add_subwindow(range = new CWindowCoordRange(this, x1, y1));
400 void CWindowCoord::update_gui(float value)
402 BC_TumbleTextBox::update(value);
404 int group = Automation::autogrouptype(type, 0);
405 LocalSession *local_session = gui->mwindow->edl->local_session;
406 slider->update(slider->get_pointer_motion_range(), value,
407 local_session->automation_mins[group],
408 local_session->automation_maxs[group]);
409 int x1 = range->get_x() + range->get_w() + xS(5);
410 int y1 = range->get_y() - yS(2), d = xS(16);
411 gui->set_color(GWindowGUI::auto_colors[type]);
412 gui->draw_disc(x1, y1, d, d);
416 int CWindowCoord::handle_event()
419 slider->update(atof(get_text()));
420 gui->event_caller = this;
425 CWindowCoordSlider::CWindowCoordSlider(CWindowCoord *coord,
426 int x, int y, int w, float mn, float mx, float value)
427 : BC_FSlider(x, y, 0, w, w, mn, mx, value)
433 CWindowCoordSlider::~CWindowCoordSlider()
437 int CWindowCoordSlider::handle_event()
439 float value = get_value();
440 coord->update(value);
441 coord->gui->event_caller = coord;
442 coord->gui->handle_event();
446 CWindowCoordRange::CWindowCoordRange(CWindowCoord *coord, int x, int y)
451 CWindowCoordRange::~CWindowCoordRange()
455 int CWindowCoordRange::update(float scale)
457 CWindowCoordSlider *slider = coord->slider;
458 MWindow *mwindow = coord->gui->mwindow;
459 LocalSession *local_session = mwindow->edl->local_session;
460 int group = Automation::autogrouptype(coord->type, 0);
461 float min = local_session->automation_mins[group];
462 float max = local_session->automation_maxs[group];
465 case AUTOGROUPTYPE_ZOOM: min = 0.005; max = 5.0; break;
466 case AUTOGROUPTYPE_X: min = -100; max = 100; break;
467 case AUTOGROUPTYPE_Y: min = -100; max = 100; break;
471 case AUTOGROUPTYPE_ZOOM: { // exp
472 float lv = log(slider->get_value());
473 float lmin = log(min), lmax = log(max);
474 float lr = (lmax - lmin) * scale;
475 min = exp(lv - 0.5*lr);
476 max = exp(lv + 0.5*lr);
477 if( min < 0.001 ) min = 0.001;
478 if( max > 1000. ) max = 1000.;
480 case AUTOGROUPTYPE_X:
481 case AUTOGROUPTYPE_Y: { // linear
482 float dr = (max - min) * (scale-1);
483 if( (min -= dr) < -32767 ) min = -32767;
484 if( (max += dr) > 32767 ) max = 32767;
487 slider->update(slider->get_pointer_motion_range(),
488 slider->get_value(), min, max);
490 MWindowGUI *mgui = mwindow->gui;
491 mgui->lock_window("CWindowCoordRange::update");
492 local_session->zoombar_showautotype = group;
493 local_session->automation_mins[group] = min;
494 local_session->automation_maxs[group] = max;
495 mgui->zoombar->update_autozoom();
496 mgui->draw_overlays(0);
497 mgui->update_patchbay();
498 mgui->flash_canvas(1);
499 mgui->unlock_window();
500 lock_window("CWindowCoordRange::update");
504 int CWindowCoordRange::handle_up_event()
508 int CWindowCoordRange::handle_down_event()
513 CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
514 : BC_GenericButton(x, y, _("Apply"))
516 this->mwindow = mwindow;
517 this->crop_gui = crop_gui;
519 int CWindowCropApply::handle_event()
521 mwindow->crop_video(crop_gui->crop_mode->mode);
526 int CWindowCropApply::keypress_event()
528 if(get_keypress() == 0xd)
536 const char *CWindowCropOpMode::crop_ops[] = {
542 CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
543 int mode, int x, int y)
544 : BC_PopupMenu(x, y, xS(140), _(crop_ops[mode]), 1)
546 this->mwindow = mwindow;
547 this->crop_gui = crop_gui;
550 CWindowCropOpMode::~CWindowCropOpMode()
554 void CWindowCropOpMode::create_objects()
556 for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
557 add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
561 int CWindowCropOpMode::handle_event()
563 set_text(_(crop_ops[mode]));
567 CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
574 int CWindowCropOpItem::handle_event()
576 popup->set_text(get_text());
578 return popup->handle_event();
585 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
586 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Crop"), xS(330), yS(100))
591 CWindowCropGUI::~CWindowCropGUI()
595 void CWindowCropGUI::create_objects()
597 int xs5 = xS(5), xs10 = xS(10);
598 int ys5 = yS(5), ys10 = yS(10);
599 int x = xs10, y = ys10;
602 lock_window("CWindowCropGUI::create_objects");
604 int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
605 BC_Title::calculate_h(this, "X")) + ys5;
606 add_subwindow(title = new BC_Title(x, y, "X1:"));
607 column1 = MAX(column1, title->get_w());
609 add_subwindow(title = new BC_Title(x, y, _("W:")));
610 column1 = MAX(column1, title->get_w());
612 add_subwindow(new CWindowCropApply(mwindow, this, x, y));
616 x1 = new CWindowCoord(thread->tool_gui, x, y,
617 mwindow->edl->session->crop_x1);
618 x1->create_objects();
619 x1->set_boundaries((int64_t)0, (int64_t)65536);
621 width = new CWindowCoord(thread->tool_gui, x, y,
622 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
623 width->create_objects();
624 width->set_boundaries((int64_t)1, (int64_t)65536);
627 x += x1->get_w() + xs10;
630 add_subwindow(title = new BC_Title(x, y, "Y1:"));
631 column2 = MAX(column2, title->get_w());
633 add_subwindow(title = new BC_Title(x, y, _("H:")));
634 column2 = MAX(column2, title->get_w());
639 y1 = new CWindowCoord(thread->tool_gui, x, y,
640 mwindow->edl->session->crop_y1);
641 y1->create_objects();
642 y1->set_boundaries((int64_t)0, (int64_t)65536);
645 height = new CWindowCoord(thread->tool_gui, x, y,
646 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
647 height->create_objects();
648 height->set_boundaries((int64_t)1, (int64_t)65536);
651 add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
652 CROP_REFORMAT, x, y));
653 crop_mode->create_objects();
658 void CWindowCropGUI::handle_event()
661 new_x1 = atol(x1->get_text());
662 new_y1 = atol(y1->get_text());
663 if(new_x1 != mwindow->edl->session->crop_x1)
665 mwindow->edl->session->crop_x2 = new_x1 +
666 mwindow->edl->session->crop_x2 -
667 mwindow->edl->session->crop_x1;
668 mwindow->edl->session->crop_x1 = new_x1;
670 if(new_y1 != mwindow->edl->session->crop_y1)
672 mwindow->edl->session->crop_y2 = new_y1 +
673 mwindow->edl->session->crop_y2 -
674 mwindow->edl->session->crop_y1;
675 mwindow->edl->session->crop_y1 = atol(y1->get_text());
677 mwindow->edl->session->crop_x2 = atol(width->get_text()) +
678 mwindow->edl->session->crop_x1;
679 mwindow->edl->session->crop_y2 = atol(height->get_text()) +
680 mwindow->edl->session->crop_y1;
682 mwindow->cwindow->gui->canvas->redraw(1);
685 void CWindowCropGUI::update()
687 x1->update((int64_t)mwindow->edl->session->crop_x1);
688 y1->update((int64_t)mwindow->edl->session->crop_y1);
689 width->update((int64_t)mwindow->edl->session->crop_x2 -
690 mwindow->edl->session->crop_x1);
691 height->update((int64_t)mwindow->edl->session->crop_y2 -
692 mwindow->edl->session->crop_y1);
696 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
697 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), xS(220), yS(290))
701 CWindowEyedropGUI::~CWindowEyedropGUI()
705 void CWindowEyedropGUI::create_objects()
707 int xs10 = xS(10), ys10 = yS(10);
708 int margin = mwindow->theme->widget_border;
709 int x = xs10 + margin;
710 int y = ys10 + margin;
711 int x2 = xS(70), x3 = x2 + xS(60);
712 lock_window("CWindowEyedropGUI::create_objects");
713 BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
714 add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
715 y += title0->get_h() + margin;
716 add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
717 y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
719 add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
720 y += title1->get_h() + margin;
721 add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
722 y += title2->get_h() + margin;
723 add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
724 y += title3->get_h() + margin;
726 add_subwindow(title4 = new BC_Title(x, y, "Y:"));
727 y += title4->get_h() + margin;
728 add_subwindow(title5 = new BC_Title(x, y, "U:"));
729 y += title5->get_h() + margin;
730 add_subwindow(title6 = new BC_Title(x, y, "V:"));
732 add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
734 radius = new CWindowCoord(this, x2, title7->get_y(),
735 mwindow->edl->session->eyedrop_radius);
736 radius->create_objects();
737 radius->set_boundaries((int64_t)0, (int64_t)255);
739 add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
740 add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
741 add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
742 add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
744 add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
745 add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
746 add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
747 add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
749 y = title6->get_y() + this->v->get_h() + 2*margin;
750 add_subwindow(sample = new BC_SubWindow(x, y, xS(50), yS(50)));
751 y += sample->get_h() + margin;
752 add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
757 void CWindowEyedropGUI::update()
759 char string[BCTEXTLEN];
760 sprintf(string, "%d, %d",
761 thread->gui->eyedrop_x,
762 thread->gui->eyedrop_y);
763 current->update(string);
765 radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
767 LocalSession *local_session = mwindow->edl->local_session;
768 int use_max = local_session->use_max;
769 float r = use_max ? local_session->red_max : local_session->red;
770 float g = use_max ? local_session->green_max : local_session->green;
771 float b = use_max ? local_session->blue_max : local_session->blue;
772 this->red->update(r);
773 this->green->update(g);
774 this->blue->update(b);
776 int rx = 255*r + 0.5; bclamp(rx,0,255);
777 int gx = 255*g + 0.5; bclamp(gx,0,255);
778 int bx = 255*b + 0.5; bclamp(bx,0,255);
779 char rgb_text[BCSTRLEN];
780 sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
781 rgb_hex->update(rgb_text);
784 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
786 this->u->update(u += 0.5);
787 this->v->update(v += 0.5);
789 int yx = 255*y + 0.5; bclamp(yx,0,255);
790 int ux = 255*u + 0.5; bclamp(ux,0,255);
791 int vx = 255*v + 0.5; bclamp(vx,0,255);
792 char yuv_text[BCSTRLEN];
793 sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
794 yuv_hex->update(yuv_text);
796 int rgb = (rx << 16) | (gx << 8) | (bx << 0);
797 sample->set_color(rgb);
798 sample->draw_box(0, 0, sample->get_w(), sample->get_h());
799 sample->set_color(BLACK);
800 sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
804 void CWindowEyedropGUI::handle_event()
806 int new_radius = atoi(radius->get_text());
807 if(new_radius != mwindow->edl->session->eyedrop_radius)
809 CWindowGUI *gui = mwindow->cwindow->gui;
810 if(gui->eyedrop_visible)
812 gui->lock_window("CWindowEyedropGUI::handle_event");
815 gui->canvas->do_eyedrop(rerender, 0, 1);
818 mwindow->edl->session->eyedrop_radius = new_radius;
820 if(gui->eyedrop_visible)
824 gui->canvas->do_eyedrop(rerender, 0, 1);
825 gui->unlock_window();
832 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
834 // Configuration for all possible Keyframe Curve Mode toggles
836 FloatAuto::t_mode mode;
842 const _CVD Camera_Crv_Smooth = { FloatAuto::SMOOTH, true, "tan_smooth",
843 N_("\"smooth\" Curve on current Camera Keyframes") };
844 const _CVD Camera_Crv_Linear = { FloatAuto::LINEAR, true, "tan_linear",
845 N_("\"linear\" Curve on current Camera Keyframes") };
846 const _CVD Camera_Crv_Tangent = { FloatAuto::TFREE, true, "tan_tangent",
847 N_("\"tangent\" Curve on current Camera Keyframes") };
848 const _CVD Camera_Crv_Free = { FloatAuto::FREE, true, "tan_free",
849 N_("\"free\" Curve on current Camera Keyframes") };
850 const _CVD Camera_Crv_Bump = { FloatAuto::BUMP, true, "tan_bump",
851 N_("\"bump\" Curve on current Camera Keyframes") };
853 const _CVD Projector_Crv_Smooth = { FloatAuto::SMOOTH, false, "tan_smooth",
854 N_("\"smooth\" Curve on current Projector Keyframes") };
855 const _CVD Projector_Crv_Linear = { FloatAuto::LINEAR, false, "tan_linear",
856 N_("\"linear\" Curve on current Projector Keyframes") };
857 const _CVD Projector_Crv_Tangent = { FloatAuto::TFREE, false, "tan_tangent",
858 N_("\"tangent\" Curve on current Projector Keyframes") };
859 const _CVD Projector_Crv_Free = { FloatAuto::FREE, false, "tan_free",
860 N_("\"free\" Curve on current Projector Keyframes") };
861 const _CVD Projector_Crv_Bump = { FloatAuto::BUMP, false, "tan_bump",
862 N_("\"bump\" Curve on current Projector Keyframes") };
864 // Implementation Class für Keyframe Curve Mode buttons
866 // This button reflects the state of the "current" keyframe
867 // (the nearest keyframe on the left) for all three automation
868 // lines together. Clicking on this button (re)sets the curve
869 // mode for the three "current" keyframes simultanously, but
870 // never creates a new keyframe.
872 class CWindowCurveToggle : public BC_Toggle
875 CWindowCurveToggle(const _CVD &mode,
876 MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
877 void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
886 CWindowCurveToggle::CWindowCurveToggle(const _CVD &mode,
887 MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
888 : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
892 this->mwindow = mwindow;
893 set_tooltip(_(cfg.tooltip));
896 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
898 // the toggle state is only set to ON if all
899 // three automation lines have the same curve mode.
900 // For mixed states the toggle stays off.
901 set_value( x->curve_mode == this->cfg.mode &&
902 y->curve_mode == this->cfg.mode &&
903 z->curve_mode == this->cfg.mode
904 ,true // redraw to show new state
908 int CWindowCurveToggle::handle_event()
910 Track *track = mwindow->cwindow->calculate_affected_track();
912 FloatAuto *x=0, *y=0, *z=0;
913 mwindow->cwindow->calculate_affected_autos(track,
914 &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
915 if( x ) x->change_curve_mode(cfg.mode);
916 if( y ) y->change_curve_mode(cfg.mode);
917 if( z ) z->change_curve_mode(cfg.mode);
920 gui->update_preview();
927 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
928 CWindowEyedropGUI *gui, int x, int y)
929 : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
931 this->mwindow = mwindow;
935 int CWindowEyedropCheckBox::handle_event()
937 mwindow->edl->local_session->use_max = get_value();
944 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
945 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Camera"), xS(340), yS(170))
948 CWindowCameraGUI::~CWindowCameraGUI()
952 void CWindowCameraGUI::create_objects()
954 int xs10 = xS(10), xs15 = xS(15);
955 int ys10 = yS(10), ys30 = yS(30);
956 int x = xs10, y = ys10;
957 Track *track = mwindow->cwindow->calculate_affected_track();
958 FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
963 lock_window("CWindowCameraGUI::create_objects");
965 mwindow->cwindow->calculate_affected_autos(track,
966 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
969 add_subwindow(title = new BC_Title(x, y, "X:"));
970 int x1 = x + title->get_w() + xS(3);
971 float xvalue = x_auto ? x_auto->get_value() : 0;
972 this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_CAMERA_X);
973 this->x->create_objects();
974 this->x->range->set_tooltip(_("expand X range"));
976 add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
977 float yvalue = y_auto ? y_auto->get_value() : 0;
978 this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_CAMERA_Y);
979 this->y->create_objects();
980 this->y->range->set_tooltip(_("expand Y range"));
982 add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
984 float zvalue = z_auto ? z_auto->get_value() : 1;
985 this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_CAMERA_Z);
986 this->z->create_objects();
987 this->z->set_increment(0.01);
988 this->z->range->set_tooltip(_("expand Zoom range"));
992 add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
993 x1 += button->get_w();
994 add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
995 x1 += button->get_w();
996 add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
997 // additional Buttons to control the curve mode of the "current" keyframe
998 x1 += button->get_w() + xs15;
999 add_subwindow(t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
1000 x1 += t_smooth->get_w() + xs10;
1001 add_subwindow(t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
1002 x1 += t_linear->get_w() + xs10;
1003 add_subwindow(t_tangent = new CWindowCurveToggle(Camera_Crv_Tangent, mwindow, this, x1, y));
1004 x1 += t_tangent->get_w() + xs10;
1005 add_subwindow(t_free = new CWindowCurveToggle(Camera_Crv_Free, mwindow, this, x1, y));
1006 x1 += t_free->get_w() + xs10;
1007 add_subwindow(t_bump = new CWindowCurveToggle(Camera_Crv_Bump, mwindow, this, x1, y));
1009 y += button->get_h();
1011 add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
1012 x1 += button->get_w();
1013 add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
1014 x1 += button->get_w();
1015 add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
1016 x1 += button->get_w() + xs15;
1017 add_subwindow(add_keyframe = new CWindowCameraAddKeyframe(mwindow, this, x1, y));
1018 x1 += add_keyframe->get_w() + xs15;
1019 add_subwindow(auto_edge = new CWindowCurveAutoEdge(mwindow, this, x1, y));
1020 x1 += auto_edge->get_w() + xs10;
1021 add_subwindow(auto_span = new CWindowCurveAutoSpan(mwindow, this, x1, y));
1022 x1 += auto_span->get_w() + xs15;
1023 add_subwindow(reset = new CWindowCameraReset(mwindow, this, x1, y));
1025 // fill in current auto keyframe values, set toggle states.
1030 void CWindowCameraGUI::handle_event()
1032 Track *track = mwindow->cwindow->calculate_affected_track();
1033 if( !track ) return;
1034 mwindow->undo->update_undo_before(_("camera"), this);
1035 if( event_caller == x )
1036 update_auto(track, AUTOMATION_CAMERA_X, x);
1037 else if( event_caller == y )
1038 update_auto(track, AUTOMATION_CAMERA_Y, y);
1039 else if( event_caller == z )
1040 update_auto(track, AUTOMATION_CAMERA_Z, z);
1041 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1044 void CWindowCameraGUI::update()
1046 FloatAuto *x_auto = 0;
1047 FloatAuto *y_auto = 0;
1048 FloatAuto *z_auto = 0;
1049 Track *track = mwindow->cwindow->calculate_affected_track();
1050 int bg_color = get_resources()->text_background;
1051 int hi_color = bg_color ^ 0x444444;
1053 mwindow->cwindow->calculate_affected_autos(track,
1054 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
1058 int color = (edge || span) && x_auto->curve_mode == FloatAuto::BUMP ?
1059 hi_color : bg_color;
1060 x->get_textbox()->set_back_color(color);
1061 float xvalue = x_auto->get_value(edge);
1062 x->update_gui(xvalue);
1065 int color = (edge || span) && y_auto->curve_mode == FloatAuto::BUMP ?
1066 hi_color : bg_color;
1067 y->get_textbox()->set_back_color(color);
1068 float yvalue = y_auto->get_value(edge);
1069 y->update_gui(yvalue);
1072 int color = (edge || span) && z_auto->curve_mode == FloatAuto::BUMP ?
1073 hi_color : bg_color;
1074 z->get_textbox()->set_back_color(color);
1075 float zvalue = z_auto->get_value(edge);
1076 z->update_gui(zvalue);
1077 thread->gui->lock_window("CWindowCameraGUI::update");
1078 thread->gui->composite_panel->cpanel_zoom->update(zvalue);
1079 thread->gui->unlock_window();
1082 if( x_auto && y_auto && z_auto ) {
1083 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1084 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1085 t_tangent->check_toggle_state(x_auto, y_auto, z_auto);
1086 t_free->check_toggle_state(x_auto, y_auto, z_auto);
1087 t_bump->check_toggle_state(x_auto, y_auto, z_auto);
1094 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1095 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1098 this->mwindow = mwindow;
1099 set_tooltip(_("Left justify"));
1101 int CWindowCameraLeft::handle_event()
1103 FloatAuto *x_auto = 0;
1104 FloatAuto *z_auto = 0;
1105 Track *track = mwindow->cwindow->calculate_affected_track();
1107 mwindow->cwindow->calculate_affected_autos(track,
1108 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1111 if(x_auto && z_auto)
1114 track->get_source_dimensions(
1115 mwindow->edl->local_session->get_selectionstart(1),
1120 mwindow->undo->update_undo_before(_("camera"), 0);
1122 (double)track->track_w / z_auto->get_value() / 2 -
1124 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1126 gui->update_preview();
1134 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1135 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1138 this->mwindow = mwindow;
1139 set_tooltip(_("Center horizontal"));
1141 int CWindowCameraCenter::handle_event()
1143 FloatAuto *x_auto = 0;
1144 Track *track = mwindow->cwindow->calculate_affected_track();
1146 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1147 track->automation->autos[AUTOMATION_CAMERA_X], 1);
1151 mwindow->undo->update_undo_before(_("camera"), 0);
1152 x_auto->set_value(0);
1154 gui->update_preview();
1155 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1162 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1163 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1166 this->mwindow = mwindow;
1167 set_tooltip(_("Right justify"));
1169 int CWindowCameraRight::handle_event()
1171 FloatAuto *x_auto = 0;
1172 FloatAuto *z_auto = 0;
1173 Track *track = mwindow->cwindow->calculate_affected_track();
1175 mwindow->cwindow->calculate_affected_autos(track,
1176 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1179 if(x_auto && z_auto)
1182 track->get_source_dimensions(
1183 mwindow->edl->local_session->get_selectionstart(1),
1188 mwindow->undo->update_undo_before(_("camera"), 0);
1189 x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1192 gui->update_preview();
1193 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1201 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1202 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1205 this->mwindow = mwindow;
1206 set_tooltip(_("Top justify"));
1208 int CWindowCameraTop::handle_event()
1210 FloatAuto *y_auto = 0;
1211 FloatAuto *z_auto = 0;
1212 Track *track = mwindow->cwindow->calculate_affected_track();
1214 mwindow->cwindow->calculate_affected_autos(track,
1215 0, &y_auto, &z_auto, 1, 0, 1, 0);
1218 if(y_auto && z_auto)
1221 track->get_source_dimensions(
1222 mwindow->edl->local_session->get_selectionstart(1),
1227 mwindow->undo->update_undo_before(_("camera"), 0);
1228 y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1231 gui->update_preview();
1232 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1240 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1241 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1244 this->mwindow = mwindow;
1245 set_tooltip(_("Center vertical"));
1247 int CWindowCameraMiddle::handle_event()
1249 FloatAuto *y_auto = 0;
1250 Track *track = mwindow->cwindow->calculate_affected_track();
1252 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1253 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1257 mwindow->undo->update_undo_before(_("camera"), 0);
1258 y_auto->set_value(0);
1260 gui->update_preview();
1261 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1268 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1269 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1272 this->mwindow = mwindow;
1273 set_tooltip(_("Bottom justify"));
1275 int CWindowCameraBottom::handle_event()
1277 FloatAuto *y_auto = 0;
1278 FloatAuto *z_auto = 0;
1279 Track *track = mwindow->cwindow->calculate_affected_track();
1281 mwindow->cwindow->calculate_affected_autos(track,
1282 0, &y_auto, &z_auto, 1, 0, 1, 0);
1285 if(y_auto && z_auto)
1288 track->get_source_dimensions(
1289 mwindow->edl->local_session->get_selectionstart(1),
1294 mwindow->undo->update_undo_before(_("camera"), 0);
1295 y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1298 gui->update_preview();
1299 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1306 CWindowCameraAddKeyframe::CWindowCameraAddKeyframe(MWindow *mwindow,
1307 CWindowToolGUI *gui, int x, int y)
1308 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1310 this->mwindow = mwindow;
1312 set_tooltip(_("Add Keyframe: Shift-F11"));
1315 int CWindowCameraAddKeyframe::handle_event()
1317 return gui->press(&CWindowCanvas::camera_keyframe);
1320 CWindowCameraReset::CWindowCameraReset(MWindow *mwindow,
1321 CWindowToolGUI *gui, int x, int y)
1322 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1324 this->mwindow = mwindow;
1326 set_tooltip(_("Reset Camera: F11"));
1329 int CWindowCameraReset::handle_event()
1331 return gui->press(&CWindowCanvas::reset_camera);
1334 CWindowCurveAutoEdge::CWindowCurveAutoEdge(MWindow *mwindow,
1335 CWindowToolGUI *gui, int x, int y)
1336 : BC_Toggle(x, y, mwindow->theme->get_image_set("bump_edge"), gui->edge)
1338 this->mwindow = mwindow;
1340 set_tooltip(_("Bump edit edge left/right"));
1343 int CWindowCurveAutoEdge::handle_event()
1345 gui->edge = get_value();
1350 CWindowCurveAutoSpan::CWindowCurveAutoSpan(MWindow *mwindow,
1351 CWindowToolGUI *gui, int x, int y)
1352 : BC_Toggle(x, y, mwindow->theme->get_image_set("bump_span"), gui->span)
1354 this->mwindow = mwindow;
1356 set_tooltip(_("Bump spans to next/prev"));
1359 int CWindowCurveAutoSpan::handle_event()
1361 gui->span = get_value();
1367 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1368 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Projector"), xS(340), yS(170))
1371 CWindowProjectorGUI::~CWindowProjectorGUI()
1374 void CWindowProjectorGUI::create_objects()
1376 int xs10 = xS(10), xs15 = xS(15);
1378 int x = xs10, y = yS(10);
1379 Track *track = mwindow->cwindow->calculate_affected_track();
1380 FloatAuto *x_auto = 0;
1381 FloatAuto *y_auto = 0;
1382 FloatAuto *z_auto = 0;
1387 lock_window("CWindowProjectorGUI::create_objects");
1389 mwindow->cwindow->calculate_affected_autos(track,
1390 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1393 add_subwindow(title = new BC_Title(x = xs10, y, "X:"));
1394 int x1 = x + title->get_w() + xS(3);
1395 float xvalue = x_auto ? x_auto->get_value() : 0;
1396 this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_PROJECTOR_X);
1397 this->x->create_objects();
1398 this->x->range->set_tooltip(_("expand X range"));
1400 add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
1401 float yvalue = y_auto ? y_auto->get_value() : 0;
1402 this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_PROJECTOR_Y);
1403 this->y->create_objects();
1404 this->y->range->set_tooltip(_("expand Y range"));
1406 add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
1407 float zvalue = z_auto ? z_auto->get_value() : 1;
1408 this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_PROJECTOR_Z);
1409 this->z->create_objects();
1410 this->z->range->set_tooltip(_("expand Zoom range"));
1411 this->z->set_increment(0.01);
1415 add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1416 x1 += button->get_w();
1417 add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1418 x1 += button->get_w();
1419 add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1420 // additional Buttons to control the curve mode of the "current" keyframe
1421 x1 += button->get_w() + xs15;
1422 add_subwindow(t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1423 x1 += t_smooth->get_w() + xs10;
1424 add_subwindow(t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1425 x1 += t_linear->get_w() + xs15;
1426 add_subwindow(t_tangent = new CWindowCurveToggle(Projector_Crv_Tangent, mwindow, this, x1, y));
1427 x1 += t_tangent->get_w() + xs10;
1428 add_subwindow(t_free = new CWindowCurveToggle(Projector_Crv_Free, mwindow, this, x1, y));
1429 x1 += t_free->get_w() + xs10;
1430 add_subwindow(t_bump = new CWindowCurveToggle(Projector_Crv_Bump, mwindow, this, x1, y));
1432 y += button->get_h();
1434 add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1435 x1 += button->get_w();
1436 add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1437 x1 += button->get_w();
1438 add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1439 x1 += button->get_w() + xs15;
1440 add_subwindow(add_keyframe = new CWindowProjectorAddKeyframe(mwindow, this, x1, y));
1441 x1 += add_keyframe->get_w() + xs15;
1442 add_subwindow(auto_span = new CWindowCurveAutoSpan(mwindow, this, x1, y));
1443 x1 += auto_span->get_w() + xs10;
1444 add_subwindow(auto_edge = new CWindowCurveAutoEdge(mwindow, this, x1, y));
1445 x1 += auto_edge->get_w() + xs15;
1446 add_subwindow(reset = new CWindowProjectorReset(mwindow, this, x1, y));
1448 // fill in current auto keyframe values, set toggle states.
1453 void CWindowProjectorGUI::handle_event()
1455 Track *track = mwindow->cwindow->calculate_affected_track();
1456 if( !track ) return;
1457 mwindow->undo->update_undo_before(_("projector"), this);
1458 if( event_caller == x )
1459 update_auto(track, AUTOMATION_PROJECTOR_X, x);
1460 else if( event_caller == y )
1461 update_auto(track, AUTOMATION_PROJECTOR_Y, y);
1462 else if( event_caller == z )
1463 update_auto(track, AUTOMATION_PROJECTOR_Z, z);
1464 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1467 void CWindowProjectorGUI::update()
1469 FloatAuto *x_auto = 0;
1470 FloatAuto *y_auto = 0;
1471 FloatAuto *z_auto = 0;
1472 Track *track = mwindow->cwindow->calculate_affected_track();
1473 int bg_color = get_resources()->text_background;
1474 int hi_color = bg_color ^ 0x444444;
1476 mwindow->cwindow->calculate_affected_autos(track,
1477 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1481 int color = (edge || span) && x_auto->curve_mode == FloatAuto::BUMP ?
1482 hi_color : bg_color;
1483 x->get_textbox()->set_back_color(color);
1484 float xvalue = x_auto->get_value(edge);
1485 x->update_gui(xvalue);
1488 int color = (edge || span) && y_auto->curve_mode == FloatAuto::BUMP ?
1489 hi_color : bg_color;
1490 y->get_textbox()->set_back_color(color);
1491 float yvalue = y_auto->get_value(edge);
1492 y->update_gui(yvalue);
1495 int color = (edge || span) && z_auto->curve_mode == FloatAuto::BUMP ?
1496 hi_color : bg_color;
1497 z->get_textbox()->set_back_color(color);
1498 float zvalue = z_auto->get_value(edge);
1499 z->update_gui(zvalue);
1500 thread->gui->lock_window("CWindowProjectorGUI::update");
1501 thread->gui->composite_panel->cpanel_zoom->update(zvalue);
1502 thread->gui->unlock_window();
1505 if( x_auto && y_auto && z_auto ) {
1506 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1507 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1508 t_tangent->check_toggle_state(x_auto, y_auto, z_auto);
1509 t_free->check_toggle_state(x_auto, y_auto, z_auto);
1510 t_bump->check_toggle_state(x_auto, y_auto, z_auto);
1514 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1515 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1518 this->mwindow = mwindow;
1519 set_tooltip(_("Left justify"));
1521 int CWindowProjectorLeft::handle_event()
1523 FloatAuto *x_auto = 0;
1524 FloatAuto *z_auto = 0;
1525 Track *track = mwindow->cwindow->calculate_affected_track();
1527 mwindow->cwindow->calculate_affected_autos(track,
1528 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1530 if(x_auto && z_auto)
1532 mwindow->undo->update_undo_before(_("projector"), 0);
1533 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1534 (double)mwindow->edl->session->output_w / 2 );
1536 gui->update_preview();
1537 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1544 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1545 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1548 this->mwindow = mwindow;
1549 set_tooltip(_("Center horizontal"));
1551 int CWindowProjectorCenter::handle_event()
1553 FloatAuto *x_auto = 0;
1554 Track *track = mwindow->cwindow->calculate_affected_track();
1556 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1557 track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
1561 mwindow->undo->update_undo_before(_("projector"), 0);
1562 x_auto->set_value(0);
1564 gui->update_preview();
1565 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1572 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1573 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1576 this->mwindow = mwindow;
1577 set_tooltip(_("Right justify"));
1579 int CWindowProjectorRight::handle_event()
1581 FloatAuto *x_auto = 0;
1582 FloatAuto *z_auto = 0;
1583 Track *track = mwindow->cwindow->calculate_affected_track();
1585 mwindow->cwindow->calculate_affected_autos(track,
1586 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1589 if(x_auto && z_auto)
1591 mwindow->undo->update_undo_before(_("projector"), 0);
1592 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1593 (double)mwindow->edl->session->output_w / 2));
1595 gui->update_preview();
1596 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1603 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1604 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1607 this->mwindow = mwindow;
1608 set_tooltip(_("Top justify"));
1610 int CWindowProjectorTop::handle_event()
1612 FloatAuto *y_auto = 0;
1613 FloatAuto *z_auto = 0;
1614 Track *track = mwindow->cwindow->calculate_affected_track();
1616 mwindow->cwindow->calculate_affected_autos(track,
1617 0, &y_auto, &z_auto, 0, 0, 1, 0);
1620 if(y_auto && z_auto)
1622 mwindow->undo->update_undo_before(_("projector"), 0);
1623 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1624 (double)mwindow->edl->session->output_h / 2 );
1626 gui->update_preview();
1627 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1634 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1635 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1638 this->mwindow = mwindow;
1639 set_tooltip(_("Center vertical"));
1641 int CWindowProjectorMiddle::handle_event()
1643 FloatAuto *y_auto = 0;
1644 Track *track = mwindow->cwindow->calculate_affected_track();
1646 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1647 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1651 mwindow->undo->update_undo_before(_("projector"), 0);
1652 y_auto->set_value(0);
1654 gui->update_preview();
1655 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1662 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1663 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1666 this->mwindow = mwindow;
1667 set_tooltip(_("Bottom justify"));
1669 int CWindowProjectorBottom::handle_event()
1671 FloatAuto *y_auto = 0;
1672 FloatAuto *z_auto = 0;
1673 Track *track = mwindow->cwindow->calculate_affected_track();
1675 mwindow->cwindow->calculate_affected_autos(track,
1676 0, &y_auto, &z_auto, 0, 0, 1, 0);
1679 if(y_auto && z_auto)
1681 mwindow->undo->update_undo_before(_("projector"), 0);
1682 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1683 (double)mwindow->edl->session->output_h / 2));
1685 gui->update_preview();
1686 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1692 CWindowProjectorAddKeyframe::CWindowProjectorAddKeyframe(MWindow *mwindow,
1693 CWindowToolGUI *gui, int x, int y)
1694 : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1696 this->mwindow = mwindow;
1698 set_tooltip(_("Add Keyframe: Shift-F12"));
1701 int CWindowProjectorAddKeyframe::handle_event()
1703 return gui->press(&CWindowCanvas::projector_keyframe);
1706 CWindowProjectorReset::CWindowProjectorReset(MWindow *mwindow,
1707 CWindowToolGUI *gui, int x, int y)
1708 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1710 this->mwindow = mwindow;
1712 set_tooltip(_("Reset Projector: F12"));
1715 int CWindowProjectorReset::handle_event()
1717 return gui->press(&CWindowCanvas::reset_projector);
1720 int CWindowToolGUI::press(void (CWindowCanvas::*fn)())
1723 CWindowGUI *cw_gui = thread->gui;
1724 cw_gui->lock_window("CWindowGUI::press");
1725 (cw_gui->canvas->*fn)();
1726 cw_gui->unlock_window();
1727 lock_window("CWindowToolGUI::press");
1731 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1732 int x, int y, int w, const char *text)
1733 : BC_PopupTextBox(gui, 0, text, x, y, w, yS(120))
1735 this->mwindow = mwindow;
1739 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1743 int CWindowMaskOnTrack::handle_event()
1745 CWindowMaskItem *track_item = 0;
1746 int k = get_number(), track_id = -1;
1747 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1749 track_item = (CWindowMaskItem *)track_items[k];
1750 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1751 if( track && track->is_armed() ) track_id = track->get_id();
1754 track_id = mwindow->cwindow->mask_track_id;
1755 set_back_color(track_id >= 0 ?
1756 gui->get_resources()->text_background :
1757 gui->get_resources()->text_background_disarmed);
1758 if( mwindow->cwindow->mask_track_id != track_id )
1759 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1760 mwindow->cwindow->mask_track_id = track_id;
1761 mwindow->edl->local_session->solo_track_id = -1;
1762 gui->mask_solo_track->update(0);
1764 gui->update_preview(1);
1768 void CWindowMaskOnTrack::update_items()
1770 track_items.remove_all_objects();
1771 int high_color = gui->get_resources()->button_highlighted;
1772 for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1773 if( track->data_type != TRACK_VIDEO ) continue;
1774 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1775 int color = !track->is_armed() ? RED : mask_autos->first ? high_color : -1;
1776 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1777 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1778 if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1779 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1781 update_list(&track_items);
1784 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1788 this->mwindow = mwindow;
1791 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1795 int CWindowMaskTrackTumbler::handle_up_event()
1800 int CWindowMaskTrackTumbler::handle_down_event()
1802 return do_event(-1);
1805 int CWindowMaskTrackTumbler::do_event(int dir)
1807 CWindowMaskItem *track_item = 0;
1808 CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1809 int n = gui->mask_on_track->track_items.size();
1810 int id = mwindow->cwindow->mask_track_id;
1813 while( --k >= 0 && items[k]->id != id );
1817 track_item = items[k];
1820 track_item = items[0];
1822 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1823 int track_id = track_item && track && track->is_armed() ? track_item->id : -1;
1824 gui->mask_on_track->set_back_color(track_id >= 0 ?
1825 gui->get_resources()->text_background :
1826 gui->get_resources()->text_background_disarmed);
1827 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1828 mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1829 mwindow->edl->local_session->solo_track_id = -1;
1830 gui->mask_solo_track->update(0);
1832 gui->update_preview(1);
1837 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1838 int x, int y, const char *text)
1839 : BC_PopupTextBox(gui, 0, text, x, y, xS(100), yS(160))
1841 this->mwindow = mwindow;
1845 CWindowMaskName::~CWindowMaskName()
1849 int CWindowMaskName::handle_event()
1856 //printf("CWindowMaskGUI::update 1\n");
1857 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1859 int k = get_number();
1860 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1861 else mwindow->edl->session->cwindow_mask = k;
1862 if( k >= 0 && k < mask_items.size() ) {
1863 mask_items[k]->set_text(get_text());
1864 update_list(&mask_items);
1866 #ifdef USE_KEYFRAME_SPANNING
1867 MaskAuto temp_keyframe(mwindow->edl, autos);
1868 temp_keyframe.copy_data(keyframe);
1869 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1870 memset(submask->name, 0, sizeof(submask->name));
1871 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1872 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1874 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1875 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1876 memset(submask->name, 0, sizeof(submask->name));
1877 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1878 current = current == (MaskAuto*)autos->default_auto ?
1879 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1883 gui->update_preview();
1888 void CWindowMaskName::update_items(MaskAuto *keyframe)
1890 mask_items.remove_all_objects();
1891 int sz = !keyframe ? 0 : keyframe->masks.size();
1892 for( int i=0; i<SUBMASKS; ++i ) {
1893 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
1895 SubMask *sub_mask = keyframe->masks.get(i);
1896 strncpy(text, sub_mask->name, sizeof(text)-1);
1899 sprintf(text, "%d", i);
1900 mask_items.append(new CWindowMaskItem(text));
1902 update_list(&mask_items);
1906 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1907 int x, int y, int no, int v)
1908 : BC_CheckBox(x, y, v)
1910 this->mwindow = mwindow;
1915 CWindowMaskButton::~CWindowMaskButton()
1919 int CWindowMaskButton::handle_event()
1921 mwindow->edl->session->cwindow_mask = no;
1922 gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1924 gui->update_preview();
1928 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1932 this->mwindow = mwindow;
1936 CWindowMaskThumbler::~CWindowMaskThumbler()
1940 int CWindowMaskThumbler::handle_up_event()
1945 int CWindowMaskThumbler::handle_down_event()
1947 return do_event(-1);
1950 int CWindowMaskThumbler::do_event(int dir)
1952 int k = mwindow->edl->session->cwindow_mask;
1953 if( (k+=dir) >= SUBMASKS ) k = 0;
1954 else if( k < 0 ) k = SUBMASKS-1;
1955 mwindow->edl->session->cwindow_mask = k;
1956 gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1958 gui->update_preview();
1962 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1963 int x, int y, int no, int v)
1964 : BC_CheckBox(x, y, v)
1966 this->mwindow = mwindow;
1971 CWindowMaskEnable::~CWindowMaskEnable()
1975 int CWindowMaskEnable::handle_event()
1977 Track *track = mwindow->cwindow->calculate_mask_track();
1979 mwindow->undo->update_undo_before(_("mask enable"), this);
1982 track->masks |= bit;
1984 track->masks &= ~bit;
1986 gui->update_preview(1);
1987 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1992 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1993 CWindowMaskGUI *gui, int x, int y)
1994 : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1996 this->mwindow = mwindow;
1998 set_tooltip(_("Show/Hide mask"));
2001 int CWindowMaskUnclear::handle_event()
2003 Track *track = mwindow->cwindow->calculate_mask_track();
2005 mwindow->undo->update_undo_before(_("mask enables"), this);
2006 int m = (1<<SUBMASKS)-1;
2007 if( track->masks == m )
2011 for( int i=0; i<SUBMASKS; ++i )
2012 gui->mask_enables[i]->update((track->masks>>i) & 1);
2013 gui->update_preview(1);
2014 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
2019 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
2020 CWindowMaskGUI *gui, int x, int y, int v)
2021 : BC_CheckBox(x, y, v, _("Solo"))
2023 this->mwindow = mwindow;
2025 set_tooltip(_("Solo video track"));
2028 int CWindowMaskSoloTrack::handle_event()
2030 mwindow->edl->local_session->solo_track_id =
2031 get_value() ? mwindow->cwindow->mask_track_id : -1;
2032 gui->update_preview(1);
2036 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
2039 calculate_extents(gui, &w, &h, _("Solo"));
2043 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
2044 CWindowMaskGUI *gui, int x, int y)
2045 : BC_GenericButton(x, y, _("Delete"))
2047 this->mwindow = mwindow;
2049 set_tooltip(_("Delete mask"));
2052 int CWindowMaskDelMask::handle_event()
2061 // Get existing keyframe
2062 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2065 mwindow->undo->update_undo_before(_("mask delete"), 0);
2067 #ifdef USE_KEYFRAME_SPANNING
2068 // Create temp keyframe
2069 MaskAuto temp_keyframe(mwindow->edl, autos);
2070 temp_keyframe.copy_data(keyframe);
2071 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2072 submask->points.remove_all_objects();
2074 // Commit change to span of keyframes
2075 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
2077 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
2078 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2079 submask->points.remove_all_objects();
2080 current = current == (MaskAuto*)autos->default_auto ?
2081 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2085 if( mwindow->cwindow->gui->affected_point >= total_points )
2086 mwindow->cwindow->gui->affected_point =
2087 total_points > 0 ? total_points-1 : 0;
2090 gui->update_preview();
2091 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
2097 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
2098 CWindowMaskGUI *gui, int x, int y)
2099 : BC_GenericButton(x, y, _("Delete"))
2101 this->mwindow = mwindow;
2103 set_tooltip(_("Delete point"));
2106 int CWindowMaskDelPoint::handle_event()
2115 // Get existing keyframe
2116 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2118 mwindow->undo->update_undo_before(_("point delete"), 0);
2120 #ifdef USE_KEYFRAME_SPANNING
2121 // Create temp keyframe
2122 MaskAuto temp_keyframe(mwindow->edl, autos);
2123 temp_keyframe.copy_data(keyframe);
2125 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2126 int i = mwindow->cwindow->gui->affected_point;
2127 for( ; i<submask->points.total-1; ++i )
2128 *submask->points.values[i] = *submask->points.values[i+1];
2129 if( submask->points.total > 0 ) {
2130 point = submask->points.values[submask->points.total-1];
2131 submask->points.remove_object(point);
2133 total_points = submask->points.total;
2135 // Commit change to span of keyframes
2136 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
2139 MaskAuto *current = (MaskAuto*)autos->default_auto;
2141 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2142 int i = mwindow->cwindow->gui->affected_point;
2143 for( ; i<submask->points.total-1; ++i )
2144 *submask->points.values[i] = *submask->points.values[i+1];
2145 if( submask->points.total > 0 ) {
2146 point = submask->points.values[submask->points.total-1];
2147 submask->points.remove_object(point);
2149 total_points = submask->points.total;
2150 current = current == (MaskAuto*)autos->default_auto ?
2151 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2154 if( mwindow->cwindow->gui->affected_point >= total_points )
2155 mwindow->cwindow->gui->affected_point =
2156 total_points > 0 ? total_points-1 : 0;
2159 gui->update_preview();
2160 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
2167 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
2168 CWindowMaskGUI *gui, int x, int y)
2169 : BC_TumbleTextBox(gui,
2170 (int64_t)mwindow->cwindow->gui->affected_point,
2171 (int64_t)0, INT64_MAX, x, y, xS(70))
2173 this->mwindow = mwindow;
2177 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
2181 int CWindowMaskAffectedPoint::handle_event()
2183 int total_points = 0;
2184 int affected_point = atol(get_text());
2185 Track *track = mwindow->cwindow->calculate_mask_track();
2187 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2188 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
2190 SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2191 total_points = mask->points.size();
2194 int active_point = affected_point;
2195 if( affected_point >= total_points )
2196 affected_point = total_points - 1;
2197 if( affected_point < 0 )
2199 if( active_point != affected_point )
2200 update((int64_t)affected_point);
2201 mwindow->cwindow->gui->affected_point = affected_point;
2203 gui->update_preview();
2208 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2209 : BC_CheckBox(x, y, gui->focused, _("Focus"))
2211 this->mwindow = mwindow;
2213 set_tooltip(_("Center for rotate/scale"));
2216 CWindowMaskFocus::~CWindowMaskFocus()
2220 int CWindowMaskFocus::handle_event()
2222 gui->focused = get_value();
2224 gui->update_preview();
2228 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
2231 calculate_extents(gui, &w, &h, _("Focus"));
2235 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
2236 int x, int y, VFrame **data, int v, int id, const char *tip)
2237 : BC_Toggle(x, y, data, v)
2240 this->mwindow = mwindow;
2245 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2249 int CWindowMaskScaleXY::handle_event()
2251 gui->scale_mode = id;
2252 gui->mask_scale_x->update(id == MASK_SCALE_X);
2253 gui->mask_scale_y->update(id == MASK_SCALE_Y);
2254 gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2258 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2259 : BC_CheckBox(x, y, 0, _("Help"))
2261 this->mwindow = mwindow;
2263 set_tooltip(_("Show help text"));
2266 CWindowMaskHelp::~CWindowMaskHelp()
2270 int CWindowMaskHelp::handle_event()
2272 gui->helped = get_value();
2273 gui->resize_window(gui->get_w(),
2274 gui->helped ? gui->help_h : gui->help_y);
2279 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2280 : BC_CheckBox(x, y, gui->markers, _("Markers"))
2282 this->mwindow = mwindow;
2284 set_tooltip("Display points");
2287 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2291 int CWindowMaskDrawMarkers::handle_event()
2293 gui->markers = get_value();
2295 gui->update_preview();
2299 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2300 : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2302 this->mwindow = mwindow;
2304 set_tooltip("Display mask outline");
2307 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2311 int CWindowMaskDrawBoundary::handle_event()
2313 gui->boundary = get_value();
2315 gui->update_preview();
2320 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2321 : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, xS(64), 2)
2323 this->mwindow = mwindow;
2326 CWindowMaskFeather::~CWindowMaskFeather()
2330 int CWindowMaskFeather::update(float v)
2332 gui->feather_slider->update(v);
2333 return BC_TumbleTextBox::update(v);
2336 int CWindowMaskFeather::update_value(float v)
2343 #ifdef USE_KEYFRAME_SPANNING
2349 mwindow->undo->update_undo_before(_("mask feather"), this);
2351 // Get existing keyframe
2352 gui->get_keyframe(track, autos, keyframe,
2353 mask, point, create_it);
2355 int gang = gui->gang_feather->get_value();
2356 #ifdef USE_KEYFRAME_SPANNING
2357 MaskAuto temp_keyframe(mwindow->edl, autos);
2358 temp_keyframe.copy_data(keyframe);
2359 keyframe = &temp_keyframe;
2361 float change = v - mask->feather;
2362 int k = mwindow->edl->session->cwindow_mask;
2363 int n = gang ? keyframe->masks.size() : k+1;
2364 for( int i=gang? 0 : k; i<n; ++i ) {
2365 if( !gui->mask_enables[i]->get_value() ) continue;
2366 SubMask *sub_mask = keyframe->get_submask(i);
2367 float feather = sub_mask->feather + change;
2368 sub_mask->feather = feather;
2370 #ifdef USE_KEYFRAME_SPANNING
2371 autos->update_parameter(keyframe);
2373 gui->update_preview();
2376 mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2380 int CWindowMaskFeather::handle_event()
2382 float v = atof(get_text());
2383 if( fabsf(v) > MAX_FEATHER )
2384 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2385 gui->feather_slider->update(v);
2386 return gui->feather->update_value(v);
2389 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2390 CWindowMaskGUI *gui, int x, int y, int w, float v)
2391 : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2393 this->mwindow = mwindow;
2395 set_precision(0.01);
2396 timer = new Timer();
2402 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2407 int CWindowMaskFeatherSlider::handle_event()
2410 float v = get_value();
2411 if( fabsf(v) > MAX_FEATHER )
2412 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2413 if( stick && timer->get_difference() >= 250 )
2414 stick = 0; // no events for .25 sec
2415 if( stick && (last_v * (v-last_v)) < 0 )
2416 stick = 0; // dv changed direction
2425 if( max > MAX_FEATHER ) max = MAX_FEATHER;
2426 update(get_w(), v=last_v, -max-5, max+5);
2427 button_release_event();
2430 else if( v > max ) { v = max; sticky = 24; }
2431 else if( v < -max ) { v = -max; sticky = 24; }
2432 else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0; sticky = 16; }
2433 if( sticky ) { update(v); stick = sticky; timer->update(); }
2435 gui->feather->BC_TumbleTextBox::update(v);
2436 return gui->feather->update_value(v);
2439 int CWindowMaskFeatherSlider::update(float v)
2441 float vv = fabsf(v);
2442 if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2443 while( max < vv ) max *= 1.25;
2444 return update(get_w(), v, -max-5, max+5);
2446 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2448 return BC_FSlider::update(r, v, mn, mx);
2451 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2452 : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, xS(64), 2)
2454 this->mwindow = mwindow;
2457 CWindowMaskFade::~CWindowMaskFade()
2461 int CWindowMaskFade::update(float v)
2463 gui->fade_slider->update(v);
2464 return BC_TumbleTextBox::update(v);
2467 int CWindowMaskFade::update_value(float v)
2474 #ifdef USE_KEYFRAME_SPANNING
2480 mwindow->undo->update_undo_before(_("mask fade"), this);
2482 // Get existing keyframe
2483 gui->get_keyframe(track, autos, keyframe,
2484 mask, point, create_it);
2486 int gang = gui->gang_fader->get_value();
2487 #ifdef USE_KEYFRAME_SPANNING
2488 MaskAuto temp_keyframe(mwindow->edl, autos);
2489 temp_keyframe.copy_data(keyframe);
2490 keyframe = &temp_keyframe;
2492 float change = v - mask->fader;
2493 int k = mwindow->edl->session->cwindow_mask;
2494 int n = gang ? keyframe->masks.size() : k+1;
2495 for( int i=gang? 0 : k; i<n; ++i ) {
2496 if( !gui->mask_enables[i]->get_value() ) continue;
2497 SubMask *sub_mask = keyframe->get_submask(i);
2498 float fader = sub_mask->fader + change;
2499 bclamp(fader, -100.f, 100.f);
2500 sub_mask->fader = fader;
2502 #ifdef USE_KEYFRAME_SPANNING
2503 autos->update_parameter(keyframe);
2505 gui->update_preview();
2508 mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2512 int CWindowMaskFade::handle_event()
2514 float v = atof(get_text());
2515 gui->fade_slider->update(v);
2516 return gui->fade->update_value(v);
2519 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2520 int x, int y, int w)
2521 : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2523 this->mwindow = mwindow;
2525 timer = new Timer();
2530 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2535 int CWindowMaskFadeSlider::handle_event()
2537 float v = 100*get_value()/200;
2539 int64_t ms = timer->get_difference();
2540 if( ms < 250 && --stick > 0 ) {
2541 if( get_value() == 0 ) return 1;
2549 else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2556 gui->fade->BC_TumbleTextBox::update(v);
2557 return gui->fade->update_value(v);
2560 int CWindowMaskFadeSlider::update(int64_t v)
2562 return BC_ISlider::update(200*v/100);
2565 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2566 CWindowMaskGUI *gui, int x, int y)
2567 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2569 this->mwindow = mwindow;
2571 set_tooltip(_("Gang fader"));
2574 CWindowMaskGangFader::~CWindowMaskGangFader()
2578 int CWindowMaskGangFader::handle_event()
2583 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2584 CWindowMaskGUI *gui, int x, int y)
2585 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2587 this->mwindow = mwindow;
2589 set_tooltip(_("Gang rotate/scale/translate"));
2592 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2596 int CWindowMaskGangFocus::handle_event()
2601 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2602 CWindowMaskGUI *gui, int x, int y)
2603 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2605 this->mwindow = mwindow;
2607 set_tooltip(_("Gang points"));
2610 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2614 int CWindowMaskGangPoint::handle_event()
2620 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2621 const char *tip, int type, int on, int x, int y, const char *images)
2622 : BC_Button(x, y, mwindow->theme->get_image_set(images))
2624 this->mwindow = mwindow;
2631 int CWindowMaskSmoothButton::handle_event()
2633 return gui->smooth_mask(type, on);
2636 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2637 : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2642 int CWindowMaskBeforePlugins::handle_event()
2649 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2652 int v = get_value();
2653 #ifdef USE_KEYFRAME_SPANNING
2654 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2655 temp_keyframe.copy_data(keyframe);
2656 temp_keyframe.apply_before_plugins = v;
2657 autos->update_parameter(&temp_keyframe);
2659 keyframe->apply_before_plugins = v;
2661 gui->update_preview();
2667 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2668 : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2673 int CWindowDisableOpenGLMasking::handle_event()
2680 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2683 int v = get_value();
2684 #ifdef USE_KEYFRAME_SPANNING
2685 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2686 temp_keyframe.copy_data(keyframe);
2687 temp_keyframe.disable_opengl_masking = v;
2688 autos->update_parameter(&temp_keyframe);
2690 keyframe->disable_opengl_masking = v;
2692 gui->update_preview();
2698 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2699 CWindowMaskGUI *gui, int x, int y)
2700 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2702 this->mwindow = mwindow;
2704 set_tooltip(_("Delete all masks"));
2707 CWindowMaskClrMask::~CWindowMaskClrMask()
2711 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2713 VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2714 return vfrm->get_w();
2717 int CWindowMaskClrMask::handle_event()
2725 // Get existing keyframe
2726 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2729 mwindow->undo->update_undo_before(_("del masks"), 0);
2730 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2731 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2735 gui->update_preview(1);
2739 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2740 CWindowMaskGUI *gui, int x, int y)
2741 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2743 this->mwindow = mwindow;
2745 set_tooltip(_("Gang feather"));
2748 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2752 int CWindowMaskGangFeather::handle_event()
2757 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2758 : CWindowToolGUI(mwindow, thread,
2759 _(PROGRAM_NAME ": Mask"), xS(440), yS(700))
2761 this->mwindow = mwindow;
2762 this->thread = thread;
2772 CWindowMaskGUI::~CWindowMaskGUI()
2774 lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2776 delete active_point;
2780 delete preset_dialog;
2783 void CWindowMaskGUI::create_objects()
2786 Theme *theme = mwindow->theme;
2787 int xs10 = xS(10), ys10 = yS(10);
2788 int x = xs10, y = ys10;
2789 int margin = theme->widget_border;
2790 int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2791 int clr_x = get_w()-x - clr_w;
2793 lock_window("CWindowMaskGUI::create_objects");
2794 BC_TitleBar *title_bar;
2795 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2796 _("Masks on Track")));
2797 y += title_bar->get_h() + margin;
2799 add_subwindow(title = new BC_Title(x,y, _("Track:")));
2800 int x1 = x + xS(90), ww = clr_x-2*margin - x1;
2801 for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2803 Track *track = mwindow->cwindow->calculate_affected_track();
2804 const char *text = track ? track->title : "";
2805 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2806 mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, xS(100), text);
2807 mask_on_track->create_objects();
2808 mask_on_track->set_tooltip(_("Video track"));
2809 int x2 = x1 + mask_on_track->get_w();
2810 add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2811 mwindow->edl->local_session->solo_track_id = -1;
2812 add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2813 y += mask_on_track->get_h() + margin;
2814 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2816 y += title_bar->get_h() + margin;
2817 add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2818 mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2819 mask_name->create_objects();
2820 mask_name->set_tooltip(_("Mask name"));
2821 add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2822 add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2823 y += mask_name->get_h() + 2*margin;
2825 // add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2826 // y += bar->get_h() + 2*margin;
2828 add_subwindow(title = new BC_Title(x, y, _("Select:")));
2830 BC_CheckBox::calculate_extents(this, &bw, &bh);
2831 for( int i=0; i<SUBMASKS; ++i ) {
2832 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2833 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2834 add_subwindow(mask_buttons[i]);
2836 add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2838 for( int i=0; i<SUBMASKS; ++i ) {
2839 char text[BCSTRLEN]; sprintf(text, "%d", i);
2840 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2841 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2842 add_subwindow(mask_blabels[i]);
2844 y += mask_blabels[0]->get_h() + margin;
2845 add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2846 for( int i=0; i<SUBMASKS; ++i ) {
2847 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2848 add_subwindow(mask_enables[i]);
2850 add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2851 y += mask_enables[0]->get_h() + 2*margin;
2852 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2853 _("Preset Shapes")));
2854 y += title_bar->get_h() + margin;
2855 add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2856 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2857 add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2858 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2859 add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2860 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2861 add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2862 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2863 add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2864 add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, xS(80)));
2865 add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, xS(80)));
2866 add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, xS(80)));
2867 y += mask_load->get_h() + 2*margin;
2868 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2869 _("Position & Scale")));
2870 y += title_bar->get_h() + 2*margin;
2871 add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, xS(80)));
2872 add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, xS(80)));
2874 add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2875 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2876 add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2877 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2878 add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2879 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2880 y += mask_center->get_h() + 2*margin;
2881 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2882 _("Fade & Feather")));
2883 y += title_bar->get_h() + 2*margin;
2885 add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2886 fade = new CWindowMaskFade(mwindow, this, x1, y);
2887 fade->create_objects();
2888 x2 = x1 + fade->get_w() + 2*margin;
2889 int w2 = clr_x-2*margin - x2;
2890 add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2891 add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2892 y += fade->get_h() + margin;
2893 add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2894 feather = new CWindowMaskFeather(mwindow, this, x1, y);
2895 feather->create_objects();
2896 w2 = clr_x - 2*margin - x2;
2897 feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2898 add_subwindow(feather_slider);
2899 add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2900 y += feather->get_h() + 2*margin;
2901 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2903 y += title_bar->get_h() + margin;
2905 add_subwindow(title = new BC_Title(x, y, _("Point:")));
2906 active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2907 active_point->create_objects();
2908 // typ=0, this mask, this point
2909 add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2910 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2911 add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2912 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2913 add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2914 add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2915 y += active_point->get_h() + margin;
2916 add_subwindow(title = new BC_Title(x, y, "X:"));
2917 this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2918 this->x->create_objects();
2919 // typ>0, this mask, all points
2920 add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2921 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2922 add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2923 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2924 add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2925 y += this->x->get_h() + margin;
2926 add_subwindow(title = new BC_Title(x, y, "Y:"));
2927 this->y = new CWindowCoord(this, x1, y, (float)0.0);
2928 this->y->create_objects();
2929 // typ<0, all masks, all points
2930 add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2931 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2932 add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2933 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2934 add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2935 y += this->y->get_h() + 2*margin;
2936 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2938 y += title_bar->get_h() + margin;
2940 add_subwindow(title = new BC_Title(x, y, "X:"));
2941 float cx = mwindow->edl->session->output_w / 2.f;
2942 focus_x = new CWindowCoord(this, x1, y, cx);
2943 focus_x->create_objects();
2944 add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2945 add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2946 y += focus_x->get_h() + margin;
2947 add_subwindow(title = new BC_Title(x, y, "Y:"));
2948 float cy = mwindow->edl->session->output_h / 2.f;
2949 focus_y = new CWindowCoord(this, x1, y, cy);
2950 focus_y->create_objects();
2951 y += focus_y->get_h() + 2*margin;
2952 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2953 y += bar->get_h() + margin;
2954 add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, x, y));
2955 y += this->apply_before_plugins->get_h();
2956 add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, x, y));
2957 add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2958 y += this->disable_opengl_masking->get_h() + 2*margin;
2960 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2961 y += bar->get_h() + 2*margin;
2962 add_subwindow(title = new BC_Title(x, y, _(
2963 "Shift+LMB: move an end point\n"
2964 "Ctrl+LMB: move a control point\n"
2965 "Alt+LMB: to drag translate the mask\n"
2966 "Shift+MMB: Set Pivot Point at pointer\n"
2967 "Wheel: rotate around Pivot Point\n"
2968 "Shift+Wheel: scale around Pivot Point\n"
2969 "Ctrl+Wheel: rotate/scale around pointer")));
2970 help_h = y + title->get_h() + 2*margin;
2972 resize_window(get_w(), help_y);
2976 int CWindowMaskGUI::close_event()
2979 return CWindowToolGUI::close_event();
2982 void CWindowMaskGUI::done_event()
2984 if( mwindow->in_destructor ) return;
2985 int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2986 if( solo_track_id >= 0 ) {
2992 void CWindowMaskGUI::get_keyframe(Track* &track,
2993 MaskAutos* &autos, MaskAuto* &keyframe,
2994 SubMask* &mask, MaskPoint* &point, int create_it)
2999 track = mwindow->cwindow->calculate_mask_track();
3001 track = mwindow->cwindow->calculate_affected_track();
3004 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
3005 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
3010 mask = !keyframe ? 0 :
3011 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
3015 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
3016 mwindow->cwindow->gui->affected_point >= 0 ) {
3017 point = mask->points.values[mwindow->cwindow->gui->affected_point];
3022 void CWindowMaskGUI::update()
3029 //printf("CWindowMaskGUI::update 1\n");
3030 get_keyframe(track, autos, keyframe, mask, point, 0);
3031 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
3032 mask_on_track->set_back_color(!track || track->is_armed() ?
3033 get_resources()->text_background :
3034 get_resources()->text_background_disarmed);
3035 mask_on_track->update_items();
3036 mask_on_track->update(!track ? "" : track->title);
3037 mask_name->update_items(keyframe);
3038 const char *text = "";
3039 int sz = !keyframe ? 0 : keyframe->masks.size();
3040 int k = mwindow->edl->session->cwindow_mask;
3041 if( k >= 0 && k < sz )
3042 text = keyframe->masks[k]->name;
3044 k = mwindow->edl->session->cwindow_mask = 0;
3045 mask_name->update(text);
3046 update_buttons(keyframe, k);
3048 x->update(point->x);
3049 y->update(point->y);
3052 double position = mwindow->edl->local_session->get_selectionstart(1);
3053 int64_t position_i = track->to_units(position, 0);
3054 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
3055 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
3056 int show_mask = track->masks;
3057 for( int i=0; i<SUBMASKS; ++i )
3058 mask_enables[i]->update((show_mask>>i) & 1);
3061 apply_before_plugins->update(keyframe->apply_before_plugins);
3062 disable_opengl_masking->update(keyframe->disable_opengl_masking);
3064 active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
3067 void CWindowMaskGUI::handle_event()
3070 if( event_caller == this->focus_x ||
3071 event_caller == this->focus_y ) {
3074 else if( event_caller == this->x ||
3075 event_caller == this->y ) {
3081 get_keyframe(track, autos, keyframe, mask, point, 0);
3083 mwindow->undo->update_undo_before(_("mask point"), this);
3086 float px = atof(x->get_text());
3087 float py = atof(y->get_text());
3088 float dx = px - point->x, dy = py - point->y;
3089 #ifdef USE_KEYFRAME_SPANNING
3090 // Create temp keyframe
3091 MaskAuto temp_keyframe(mwindow->edl, autos);
3092 temp_keyframe.copy_data(keyframe);
3093 // Get affected point in temp keyframe
3094 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3096 MaskPoints &points = mask->points;
3097 int gang = gang_point->get_value();
3098 int k = mwindow->cwindow->gui->affected_point;
3099 int n = gang ? points.size() : k+1;
3100 for( int i=gang? 0 : k; i<n; ++i ) {
3101 if( i < 0 || i >= points.size() ) continue;
3102 MaskPoint *point = points[i];
3103 point->x += dx; point->y += dy;
3105 #ifdef USE_KEYFRAME_SPANNING
3106 // Commit to spanned keyframes
3107 autos->update_parameter(&temp_keyframe);
3110 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
3118 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
3120 CWindowGUI *cgui = mwindow->cwindow->gui;
3121 cgui->unlock_window();
3122 lock_window("CWindowMaskGUI::set_focused");
3124 focus->update(focused = v);
3125 focus_x->update(cx);
3126 focus_y->update(cy);
3128 cgui->lock_window("CWindowCanvas::set_focused");
3131 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
3133 int text_color = get_resources()->default_text_color;
3134 int high_color = get_resources()->button_highlighted;
3135 for( int i=0; i<SUBMASKS; ++i ) {
3136 int color = text_color;
3138 SubMask *submask = keyframe->get_submask(i);
3139 if( submask && submask->points.size() )
3142 mask_blabels[i]->set_color(color);
3143 mask_buttons[i]->update(i==k ? 1 : 0);
3147 // typ=0, this mask, this point
3148 // typ>0, this mask, all points
3149 // typ<0, all masks, all points
3150 // dxy= on? pt[+1]-pt[-1] : dxy=0
3151 int CWindowMaskGUI::smooth_mask(int typ, int on)
3158 #ifdef USE_KEYFRAME_SPANNING
3164 mwindow->undo->update_undo_before(_("mask smooth"), this);
3166 // Get existing keyframe
3167 get_keyframe(track, autos, keyframe,
3168 mask, point, create_it);
3170 #ifdef USE_KEYFRAME_SPANNING
3171 MaskAuto temp_keyframe(mwindow->edl, autos);
3172 temp_keyframe.copy_data(keyframe);
3173 keyframe = &temp_keyframe;
3175 int k = mwindow->edl->session->cwindow_mask;
3176 int n = typ>=0 ? k+1 : keyframe->masks.size();
3177 for( int j=typ<0? 0 : k; j<n; ++j ) {
3178 if( !mask_enables[j]->get_value() ) continue;
3179 SubMask *sub_mask = keyframe->get_submask(j);
3180 MaskPoints &points = sub_mask->points;
3181 int psz = points.size();
3182 if( psz < 3 ) continue;
3183 int l = mwindow->cwindow->gui->affected_point;
3184 if( l > psz ) l = psz;
3185 int m = typ ? psz : l+1;
3186 for( int i=typ ? 0 : l; i<m; ++i ) {
3187 int i0 = i-1, i1 = i+1;
3188 if( i0 < 0 ) i0 = psz-1;
3189 if( i1 >= psz ) i1 = 0;
3190 MaskPoint *p0 = points[i0];
3191 MaskPoint *p = points[i];
3192 MaskPoint *p1 = points[i1];
3193 float dx = !on ? 0 : p1->x - p0->x;
3194 float dy = !on ? 0 : p1->y - p0->y;
3195 p->control_x1 = -dx/4; p->control_y1 = -dy/4;
3196 p->control_x2 = dx/4; p->control_y2 = dy/4;
3199 #ifdef USE_KEYFRAME_SPANNING
3200 autos->update_parameter(keyframe);
3205 mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
3209 int CWindowMaskGUI::save_mask(const char *nm)
3211 int k = mwindow->edl->session->cwindow_mask;
3217 get_keyframe(track, autos, keyframe, mask, point, 0);
3218 if( !track ) return 0;
3219 SubMask *sub_mask = keyframe->get_submask(k);
3220 ArrayList<SubMask *> masks;
3222 int i = masks.size();
3224 if( strcmp(masks[i]->name, nm) ) continue;
3225 masks.remove_object_number(i++);
3227 mask = new SubMask(0, -1);
3228 strncpy(mask->name, nm, sizeof(mask->name)-1);
3229 mask->copy_from(*sub_mask, 0);
3232 masks.remove_all_objects();
3236 int CWindowMaskGUI::del_mask(const char *nm)
3238 ArrayList<SubMask *> masks;
3240 int i = masks.size();
3242 if( strcmp(masks[i]->name, nm) ) continue;
3243 masks.remove_object_number(i++);
3246 masks.remove_all_objects();
3250 int CWindowMaskGUI::center_mask()
3252 int k = mwindow->edl->session->cwindow_mask;
3258 #ifdef USE_KEYFRAME_SPANNING
3263 get_keyframe(track, autos, keyframe,
3264 mask, point, create_it);
3265 if( !track ) return 0;
3266 mwindow->undo->update_undo_before(_("mask center"), this);
3268 // Get existing keyframe
3269 #ifdef USE_KEYFRAME_SPANNING
3270 MaskAuto temp_keyframe(mwindow->edl, autos);
3271 temp_keyframe.copy_data(keyframe);
3272 keyframe = &temp_keyframe;
3274 SubMask *sub_mask = keyframe->get_submask(k);
3275 MaskPoints &points = sub_mask->points;
3276 int psz = points.size();
3278 float cx = 0, cy = 0;
3279 for( int i=0; i<psz; ++i ) {
3280 MaskPoint *p = points[i];
3281 cx += p->x; cy += p->y;
3283 cx /= psz; cy /= psz;
3284 cx -= mwindow->edl->session->output_w / 2.f;
3285 cy -= mwindow->edl->session->output_h / 2.f;
3286 for( int i=0; i<psz; ++i ) {
3287 MaskPoint *p = points[i];
3288 p->x -= cx; p->y -= cy;
3291 #ifdef USE_KEYFRAME_SPANNING
3292 autos->update_parameter(keyframe);
3295 mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3299 int CWindowMaskGUI::normal_mask()
3301 int k = mwindow->edl->session->cwindow_mask;
3307 #ifdef USE_KEYFRAME_SPANNING
3312 // Get existing keyframe
3313 get_keyframe(track, autos, keyframe,
3314 mask, point, create_it);
3315 if( !track ) return 0;
3316 mwindow->undo->update_undo_before(_("mask normal"), this);
3318 #ifdef USE_KEYFRAME_SPANNING
3319 MaskAuto temp_keyframe(mwindow->edl, autos);
3320 temp_keyframe.copy_data(keyframe);
3321 keyframe = &temp_keyframe;
3323 SubMask *sub_mask = keyframe->get_submask(k);
3324 MaskPoints &points = sub_mask->points;
3325 int psz = points.size();
3326 float cx = 0, cy = 0;
3329 for( int i=0; i<psz; ++i ) {
3330 MaskPoint *p = points[i];
3331 cx += p->x; cy += p->y;
3333 cx /= psz; cy /= psz;
3334 for( int i=0; i<psz; ++i ) {
3335 MaskPoint *p = points[i];
3336 float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3337 double d = sqrt(dx*dx + dy*dy);
3338 if( dr < d ) dr = d;
3342 float out_w = mwindow->edl->session->output_w;
3343 float out_h = mwindow->edl->session->output_h;
3344 float r = bmax(out_w, out_h);
3345 float s = r / (4 * dr * sqrt(2.));
3346 for( int i=0; i<psz; ++i ) {
3347 MaskPoint *p = points[i];
3348 float x = p->x, y = p->y;
3349 p->x = (x-cx) * s + cx;
3350 p->y = (y-cy) * s + cy;
3351 p->control_x1 *= s; p->control_y1 *= s;
3352 p->control_x2 *= s; p->control_y2 *= s;
3355 #ifdef USE_KEYFRAME_SPANNING
3356 autos->update_parameter(keyframe);
3360 mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3365 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3366 : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3368 this->mwindow = mwindow;
3373 CWindowMaskLoadList::~CWindowMaskLoadList()
3378 int CWindowMaskLoadList::handle_event()
3385 #ifdef USE_KEYFRAME_SPANNING
3391 mwindow->undo->update_undo_before(_("mask shape"), this);
3393 // Get existing keyframe
3394 gui->get_keyframe(track, autos, keyframe,
3395 mask, point, create_it);
3396 CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3397 if( track && item ) {
3398 #ifdef USE_KEYFRAME_SPANNING
3399 MaskAuto temp_keyframe(mwindow->edl, autos);
3400 temp_keyframe.copy_data(keyframe);
3401 keyframe = &temp_keyframe;
3402 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3404 ArrayList<SubMask *> masks;
3405 gui->load_masks(masks);
3406 mask->copy_from(*masks[item->id], 0);
3407 masks.remove_all_objects();
3408 #ifdef USE_KEYFRAME_SPANNING
3409 autos->update_parameter(keyframe);
3412 gui->update_preview(1);
3414 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3418 void CWindowMaskLoadList::create_objects()
3420 shape_items.remove_all_objects();
3421 ArrayList<SubMask *> masks;
3422 gui->load_masks(masks);
3423 for( int i=0; i<masks.size(); ++i )
3424 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3425 masks.remove_all_objects();
3426 update(&shape_items, 0, 0, 1);
3429 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3430 CWindowMaskGUI *gui, int x, int y, int w)
3431 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3433 this->mwindow = mwindow;
3435 set_tooltip(_("Load preset"));
3438 int CWindowMaskLoad::handle_event()
3440 gui->mask_load_list->create_objects();
3442 get_abs_cursor(px, py);
3443 return gui->mask_load_list->activate(px, py, xS(120),yS(160));
3447 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3448 CWindowMaskGUI *gui, int x, int y, int w)
3449 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3451 this->mwindow = mwindow;
3453 set_tooltip(_("Save preset"));
3456 CWindowMaskSave::~CWindowMaskSave()
3460 int CWindowMaskSave::handle_event()
3467 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3470 gui->get_abs_cursor(sx, sy);
3471 if( !gui->preset_dialog )
3472 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3473 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3478 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3481 this->mwindow = mwindow;
3486 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3491 void CWindowMaskPresetDialog::handle_close_event(int result)
3496 void CWindowMaskPresetDialog::handle_done_event(int result)
3498 if( result ) return;
3499 const char *nm = pgui->preset_text->get_text();
3506 BC_Window* CWindowMaskPresetDialog::new_gui()
3508 pgui = new CWindowMaskPresetGUI(this, sx, sy,
3509 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3510 _(PROGRAM_NAME ": Delete Mask"));
3511 pgui->create_objects();
3515 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3518 this->sx = sx; this->sy = sy;
3519 this->keyframe = keyframe;
3523 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3524 int x, int y, const char *title)
3525 : BC_Window(title, x, y, xS(320), yS(100), xS(320), yS(100), 0, 0, 1)
3527 this->preset_dialog = preset_dialog;
3530 void CWindowMaskPresetGUI::create_objects()
3532 int xs8 = xS(8), xs10 = xS(10);
3534 int x = xs10, y = ys10;
3535 lock_window("CWindowMaskPresetGUI::create_objects");
3537 add_subwindow(title = new BC_Title(x, y,
3538 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3539 int x1 = x + title->get_w() + xs8;
3540 int x2 = get_w() - x - xs8 - x1 -
3541 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3542 CWindowMaskGUI *gui = preset_dialog->gui;
3543 preset_text = new CWindowMaskPresetText(this,
3544 x1, y, x2, yS(120), gui->mask_name->get_text());
3545 preset_text->create_objects();
3546 preset_text->set_tooltip(_("Mask name"));
3547 preset_text->update_items();
3548 add_subwindow(new BC_OKButton(this));
3549 add_subwindow(new BC_CancelButton(this));
3555 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3556 int x, int y, int w, int h, const char *text)
3557 : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3562 int CWindowMaskPresetText::handle_event()
3564 int k = get_number();
3565 if( k >= 0 && k<mask_items.size() )
3566 update(mask_items[k]->get_text());
3570 void CWindowMaskPresetText::update_items()
3572 mask_items.remove_all_objects();
3573 ArrayList<SubMask *> masks;
3574 pgui->preset_dialog->gui->load_masks(masks);
3575 for( int i=0; i<masks.size(); ++i ) {
3576 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
3577 strncpy(text, masks[i]->name, sizeof(text)-1);
3578 mask_items.append(new CWindowMaskItem(text));
3580 masks.remove_all_objects();
3581 update_list(&mask_items);
3585 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3586 CWindowMaskGUI *gui, int x, int y, int w)
3587 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3589 this->mwindow = mwindow;
3591 set_tooltip(_("Delete preset"));
3594 int CWindowMaskDelete::handle_event()
3597 gui->get_abs_cursor(sx, sy);
3598 if( !gui->preset_dialog )
3599 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3600 gui->preset_dialog->start_dialog(sx, sy, 0);
3605 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3606 CWindowMaskGUI *gui, int x, int y, int w)
3607 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3609 this->mwindow = mwindow;
3611 set_tooltip(_("center mask"));
3614 int CWindowMaskCenter::handle_event()
3616 return gui->center_mask();
3620 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3621 CWindowMaskGUI *gui, int x, int y, int w)
3622 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3624 this->mwindow = mwindow;
3626 set_tooltip(_("normalize mask"));
3629 int CWindowMaskNormal::handle_event()
3631 return gui->normal_mask();
3635 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3636 const char *images, int shape, int x, int y, const char *tip)
3637 : BC_Button(x, y, mwindow->theme->get_image_set(images))
3639 this->mwindow = mwindow;
3641 this->shape = shape;
3645 CWindowMaskShape::~CWindowMaskShape()
3649 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3651 int out_w = mwindow->edl->session->output_w;
3652 int out_h = mwindow->edl->session->output_h;
3653 float cx = out_w/2.f, cy = out_h/2.f;
3654 float r = bmax(cx, cy) / 4.f;
3655 double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3656 float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3658 MaskPoints &points = sub_mask->points;
3659 points.remove_all_objects();
3661 case MASK_SHAPE_SQUARE:
3662 points.append(pt = new MaskPoint());
3663 pt->x = cx - r; pt->y = cy - r;
3664 points.append(pt = new MaskPoint());
3665 pt->x = cx + r; pt->y = cy - r;
3666 points.append(pt = new MaskPoint());
3667 pt->x = cx + r; pt->y = cy + r;
3668 points.append(pt = new MaskPoint());
3669 pt->x = cx - r; pt->y = cy + r;
3671 case MASK_SHAPE_CIRCLE:
3672 points.append(pt = new MaskPoint());
3673 pt->x = cx - r; pt->y = cy - r;
3674 pt->control_x1 = -rc; pt->control_y1 = rc;
3675 pt->control_x2 = rc; pt->control_y2 = -rc;
3676 points.append(pt = new MaskPoint());
3677 pt->x = cx + r; pt->y = cy - r;
3678 pt->control_x1 = -rc; pt->control_y1 = -rc;
3679 pt->control_x2 = rc; pt->control_y2 = rc;
3680 points.append(pt = new MaskPoint());
3681 pt->x = cx + r; pt->y = cy + r;
3682 pt->control_x1 = rc; pt->control_y1 = -rc;
3683 pt->control_x2 = -rc; pt->control_y2 = rc;
3684 points.append(pt = new MaskPoint());
3685 pt->x = cx - r; pt->y = cy + r;
3686 pt->control_x1 = rc; pt->control_y1 = rc;
3687 pt->control_x2 = -rc; pt->control_y2 = -rc;
3689 case MASK_SHAPE_TRIANGLE:
3690 points.append(pt = new MaskPoint());
3691 pt->x = cx + 0; pt->y = cy - r*(sqrt(3.)-1.);
3692 points.append(pt = new MaskPoint());
3693 pt->x = cx + r; pt->y = cy + r;
3694 points.append(pt = new MaskPoint());
3695 pt->x = cx - r; pt->y = cy + r;
3697 case MASK_SHAPE_OVAL:
3698 points.append(pt = new MaskPoint());
3699 pt->x = cx - r; pt->y = cy - r2;
3700 pt->control_x1 = -r2; pt->control_y1 = r4;
3701 pt->control_x2 = r2; pt->control_y2 = -r4;
3702 points.append(pt = new MaskPoint());
3703 pt->x = cx + r; pt->y = cy - r2;
3704 pt->control_x1 = -r2; pt->control_y1 = -r4;
3705 pt->control_x2 = r2; pt->control_y2 = r4;
3706 points.append(pt = new MaskPoint());
3707 pt->x = cx + r; pt->y = cy + r2;
3708 pt->control_x1 = r2; pt->control_y1 = -r4;
3709 pt->control_x2 = -r2; pt->control_y2 = r4;
3710 points.append(pt = new MaskPoint());
3711 pt->x = cx - r; pt->y = cy + r2;
3712 pt->control_x1 = r2; pt->control_y1 = r4;
3713 pt->control_x2 = -r2; pt->control_y2 = -r4;
3718 int CWindowMaskShape::handle_event()
3725 #ifdef USE_KEYFRAME_SPANNING
3731 mwindow->undo->update_undo_before(_("mask shape"), this);
3733 // Get existing keyframe
3734 gui->get_keyframe(track, autos, keyframe,
3735 mask, point, create_it);
3737 #ifdef USE_KEYFRAME_SPANNING
3738 MaskAuto temp_keyframe(mwindow->edl, autos);
3739 temp_keyframe.copy_data(keyframe);
3740 keyframe = &temp_keyframe;
3741 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3744 builtin_shape(shape, mask);
3745 #ifdef USE_KEYFRAME_SPANNING
3746 autos->update_parameter(keyframe);
3749 gui->update_preview(1);
3752 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3756 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3758 char path[BCTEXTLEN];
3759 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3761 fs.complete_path(path);
3763 file.read_from_file(path, 1);
3765 masks.remove_all_objects();
3767 while( !(result = file.read_tag()) ) {
3768 if( file.tag.title_is("MASK") ) {
3769 SubMask *sub_mask = new SubMask(0, -1);
3770 char name[BCTEXTLEN]; name[0] = 0;
3771 file.tag.get_property("NAME", name);
3772 strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3773 sub_mask->load(&file);
3774 masks.append(sub_mask);
3779 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3782 for( int i=0; i<masks.size(); ++i ) {
3783 SubMask *sub_mask = masks[i];
3784 sub_mask->copy(&file);
3786 file.terminate_string();
3788 char path[BCTEXTLEN];
3789 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3791 fs.complete_path(path);
3792 file.write_to_file(path);
3796 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3797 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), xS(320), yS(240))
3801 CWindowRulerGUI::~CWindowRulerGUI()
3805 void CWindowRulerGUI::create_objects()
3807 int xs10 = xS(10), xs200 = xS(200);
3808 int ys5 = yS(5), ys10 = yS(10);
3809 int x = xs10, y = ys10, x1 = xS(100);
3812 lock_window("CWindowRulerGUI::create_objects");
3813 add_subwindow(title = new BC_Title(x, y, _("Current:")));
3814 add_subwindow(current = new BC_TextBox(x1, y, xs200, 1, ""));
3815 y += title->get_h() + ys5;
3816 add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3817 add_subwindow(point1 = new BC_TextBox(x1, y, xs200, 1, ""));
3818 y += title->get_h() + ys5;
3819 add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3820 add_subwindow(point2 = new BC_TextBox(x1, y, xs200, 1, ""));
3821 y += title->get_h() + ys5;
3822 add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3823 add_subwindow(deltas = new BC_TextBox(x1, y, xs200, 1, ""));
3824 y += title->get_h() + ys5;
3825 add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3826 add_subwindow(distance = new BC_TextBox(x1, y, xs200, 1, ""));
3827 y += title->get_h() + ys5;
3828 add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3829 add_subwindow(angle = new BC_TextBox(x1, y, xs200, 1, ""));
3830 y += title->get_h() + ys10;
3831 char string[BCTEXTLEN];
3833 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3834 0xc2, 0xb0); // degrees utf
3835 add_subwindow(title = new BC_Title(x,
3838 y += title->get_h() + ys10;
3839 sprintf(string, _("Press Alt to translate the ruler."));
3840 add_subwindow(title = new BC_Title(x,
3847 void CWindowRulerGUI::update()
3849 char string[BCTEXTLEN];
3850 int cx = mwindow->session->cwindow_output_x;
3851 int cy = mwindow->session->cwindow_output_y;
3852 sprintf(string, "%d, %d", cx, cy);
3853 current->update(string);
3854 double x1 = mwindow->edl->session->ruler_x1;
3855 double y1 = mwindow->edl->session->ruler_y1;
3856 sprintf(string, "%.0f, %.0f", x1, y1);
3857 point1->update(string);
3858 double x2 = mwindow->edl->session->ruler_x2;
3859 double y2 = mwindow->edl->session->ruler_y2;
3860 sprintf(string, "%.0f, %.0f", x2, y2);
3861 point2->update(string);
3862 double dx = x2 - x1, dy = y2 - y1;
3863 sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3864 deltas->update(string);
3865 double d = sqrt(dx*dx + dy*dy);
3866 sprintf(string, _("%0.01f pixels"), d);
3867 distance->update(string);
3868 double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3869 sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3870 angle->update(string);
3873 void CWindowRulerGUI::handle_event()