3 * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "automation.h"
28 #include "condition.h"
30 #include "cplayback.h"
32 #include "cwindowgui.h"
33 #include "cwindowtool.h"
35 #include "edlsession.h"
38 #include "floatauto.h"
39 #include "floatautos.h"
42 #include "localsession.h"
43 #include "mainsession.h"
46 #include "maskautos.h"
49 #include "mwindowgui.h"
53 #include "trackcanvas.h"
54 #include "transportque.h"
57 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
60 this->mwindow = mwindow;
64 current_tool = CWINDOW_NONE;
66 input_lock = new Condition(0, "CWindowTool::input_lock");
67 output_lock = new Condition(1, "CWindowTool::output_lock");
68 tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
71 CWindowTool::~CWindowTool()
82 void CWindowTool::start_tool(int operation)
84 CWindowToolGUI *new_gui = 0;
87 //printf("CWindowTool::start_tool 1\n");
88 if(current_tool != operation)
90 int previous_tool = current_tool;
91 current_tool = operation;
95 new_gui = new CWindowEyedropGUI(mwindow, this);
98 new_gui = new CWindowCropGUI(mwindow, this);
101 new_gui = new CWindowCameraGUI(mwindow, this);
103 case CWINDOW_PROJECTOR:
104 new_gui = new CWindowProjectorGUI(mwindow, this);
107 new_gui = new CWindowMaskGUI(mwindow, this);
110 new_gui = new CWindowRulerGUI(mwindow, this);
112 case CWINDOW_PROTECT:
113 mwindow->edl->session->tool_window = 0;
114 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(0);
122 //printf("CWindowTool::start_tool 1\n");
128 // Wait for previous tool GUI to finish
129 output_lock->lock("CWindowTool::start_tool");
130 this->tool_gui = new_gui;
131 tool_gui->create_objects();
132 if( previous_tool == CWINDOW_PROTECT || previous_tool == CWINDOW_NONE ) {
133 mwindow->edl->session->tool_window = 1;
134 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
136 update_show_window();
138 // Signal thread to run next tool GUI
139 input_lock->unlock();
141 //printf("CWindowTool::start_tool 1\n");
146 tool_gui->lock_window("CWindowTool::start_tool");
148 tool_gui->unlock_window();
151 //printf("CWindowTool::start_tool 2\n");
156 void CWindowTool::stop_tool()
160 tool_gui->lock_window("CWindowTool::stop_tool");
161 tool_gui->set_done(0);
162 tool_gui->unlock_window();
166 void CWindowTool::show_tool()
168 if(tool_gui && mwindow->edl->session->tool_window)
170 tool_gui->lock_window("CWindowTool::show_tool");
171 tool_gui->show_window();
172 tool_gui->unlock_window();
176 void CWindowTool::hide_tool()
178 if(tool_gui && mwindow->edl->session->tool_window)
180 tool_gui->lock_window("CWindowTool::show_tool");
181 tool_gui->hide_window();
182 tool_gui->unlock_window();
186 void CWindowTool::raise_tool()
188 if(tool_gui && mwindow->edl->session->tool_window)
190 tool_gui->lock_window("CWindowTool::show_tool");
191 tool_gui->raise_window();
192 tool_gui->unlock_window();
197 void CWindowTool::run()
201 input_lock->lock("CWindowTool::run");
204 tool_gui->run_window();
205 tool_gui_lock->lock("CWindowTool::run");
208 tool_gui_lock->unlock();
210 output_lock->unlock();
214 void CWindowTool::update_show_window()
218 tool_gui->lock_window("CWindowTool::update_show_window");
220 if(mwindow->edl->session->tool_window)
223 tool_gui->show_window();
226 tool_gui->hide_window();
229 tool_gui->unlock_window();
233 void CWindowTool::raise_window()
237 gui->unlock_window();
238 tool_gui->lock_window("CWindowTool::raise_window");
239 tool_gui->raise_window();
240 tool_gui->unlock_window();
241 gui->lock_window("CWindowTool::raise_window");
245 void CWindowTool::update_values()
247 tool_gui_lock->lock("CWindowTool::update_values");
250 tool_gui->lock_window("CWindowTool::update_values");
253 tool_gui->unlock_window();
255 tool_gui_lock->unlock();
264 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
270 mwindow->session->ctool_x,
271 mwindow->session->ctool_y,
280 this->mwindow = mwindow;
281 this->thread = thread;
282 current_operation = 0;
285 CWindowToolGUI::~CWindowToolGUI()
289 int CWindowToolGUI::close_event()
293 mwindow->edl->session->tool_window = 0;
295 thread->gui->lock_window("CWindowToolGUI::close_event");
296 thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
297 thread->gui->flush();
298 thread->gui->unlock_window();
299 lock_window("CWindowToolGUI::close_event");
303 int CWindowToolGUI::keypress_event()
307 switch( get_keypress() ) {
310 return close_event();
323 resend_event(thread->gui);
330 int CWindowToolGUI::translation_event()
332 mwindow->session->ctool_x = get_x();
333 mwindow->session->ctool_y = get_y();
338 void CWindowToolGUI::update_preview(int changed_edl)
341 draw_preview(changed_edl);
342 lock_window("CWindowToolGUI::update_preview");
345 void CWindowToolGUI::draw_preview(int changed_edl)
347 CWindowGUI *cgui = mwindow->cwindow->gui;
348 cgui->lock_window("CWindowToolGUI::draw_preview");
349 int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
350 cgui->sync_parameters(change_type, 0, 1);
351 cgui->unlock_window();
355 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
356 : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 70, 3)
359 set_log_floatincrement(log_increment);
362 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
363 : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 70, 3)
367 int CWindowCoord::handle_event()
369 gui->event_caller = this;
375 CWindowCropOK::CWindowCropOK(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
376 : BC_GenericButton(x, y, _("Do it"))
378 this->mwindow = mwindow;
381 int CWindowCropOK::handle_event()
383 mwindow->crop_video();
388 int CWindowCropOK::keypress_event()
390 if(get_keypress() == 0xd)
404 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
405 : CWindowToolGUI(mwindow,
407 _(PROGRAM_NAME ": Crop"),
414 CWindowCropGUI::~CWindowCropGUI()
418 void CWindowCropGUI::create_objects()
423 lock_window("CWindowCropGUI::create_objects");
425 int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
426 BC_Title::calculate_h(this, "X")) + 5;
427 add_subwindow(title = new BC_Title(x, y, "X1:"));
428 column1 = MAX(column1, title->get_w());
430 add_subwindow(title = new BC_Title(x, y, _("W:")));
431 column1 = MAX(column1, title->get_w());
433 add_subwindow(new CWindowCropOK(mwindow, thread->tool_gui, x, y));
437 x1 = new CWindowCoord(thread->tool_gui, x, y,
438 mwindow->edl->session->crop_x1);
439 x1->create_objects();
441 width = new CWindowCoord(thread->tool_gui, x, y,
442 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
443 width->create_objects();
446 x += x1->get_w() + 10;
449 add_subwindow(title = new BC_Title(x, y, "Y1:"));
450 column2 = MAX(column2, title->get_w());
452 add_subwindow(title = new BC_Title(x, y, _("H:")));
453 column2 = MAX(column2, title->get_w());
458 y1 = new CWindowCoord(thread->tool_gui, x, y,
459 mwindow->edl->session->crop_y1);
460 y1->create_objects();
462 height = new CWindowCoord(thread->tool_gui, x, y,
463 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
464 height->create_objects();
468 void CWindowCropGUI::handle_event()
471 new_x1 = atol(x1->get_text());
472 new_y1 = atol(y1->get_text());
473 if(new_x1 != mwindow->edl->session->crop_x1)
475 mwindow->edl->session->crop_x2 = new_x1 +
476 mwindow->edl->session->crop_x2 -
477 mwindow->edl->session->crop_x1;
478 mwindow->edl->session->crop_x1 = new_x1;
480 if(new_y1 != mwindow->edl->session->crop_y1)
482 mwindow->edl->session->crop_y2 = new_y1 +
483 mwindow->edl->session->crop_y2 -
484 mwindow->edl->session->crop_y1;
485 mwindow->edl->session->crop_y1 = atol(y1->get_text());
487 mwindow->edl->session->crop_x2 = atol(width->get_text()) +
488 mwindow->edl->session->crop_x1;
489 mwindow->edl->session->crop_y2 = atol(height->get_text()) +
490 mwindow->edl->session->crop_y1;
492 mwindow->cwindow->gui->canvas->redraw(1);
495 void CWindowCropGUI::update()
497 x1->update((int64_t)mwindow->edl->session->crop_x1);
498 y1->update((int64_t)mwindow->edl->session->crop_y1);
499 width->update((int64_t)mwindow->edl->session->crop_x2 -
500 mwindow->edl->session->crop_x1);
501 height->update((int64_t)mwindow->edl->session->crop_y2 -
502 mwindow->edl->session->crop_y1);
506 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
507 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), 220, 290)
511 CWindowEyedropGUI::~CWindowEyedropGUI()
515 void CWindowEyedropGUI::create_objects()
517 int margin = mwindow->theme->widget_border;
520 int x2 = 70, x3 = x2 + 60;
521 lock_window("CWindowEyedropGUI::create_objects");
522 BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
523 add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
524 y += title0->get_h() + margin;
525 add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
526 y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
528 add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
529 y += title1->get_h() + margin;
530 add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
531 y += title2->get_h() + margin;
532 add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
533 y += title3->get_h() + margin;
535 add_subwindow(title4 = new BC_Title(x, y, "Y:"));
536 y += title4->get_h() + margin;
537 add_subwindow(title5 = new BC_Title(x, y, "U:"));
538 y += title5->get_h() + margin;
539 add_subwindow(title6 = new BC_Title(x, y, "V:"));
541 add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
543 radius = new CWindowCoord(this, x2, title7->get_y(),
544 mwindow->edl->session->eyedrop_radius);
545 radius->create_objects();
546 radius->set_boundaries((int64_t)0, (int64_t)255);
548 add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
549 add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
550 add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
551 add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
553 add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
554 add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
555 add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
556 add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
558 y = title6->get_y() + this->v->get_h() + 2*margin;
559 add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
560 y += sample->get_h() + margin;
561 add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
566 void CWindowEyedropGUI::update()
568 char string[BCTEXTLEN];
569 sprintf(string, "%d, %d",
570 thread->gui->eyedrop_x,
571 thread->gui->eyedrop_y);
572 current->update(string);
574 radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
576 LocalSession *local_session = mwindow->edl->local_session;
577 int use_max = local_session->use_max;
578 float r = use_max ? local_session->red_max : local_session->red;
579 float g = use_max ? local_session->green_max : local_session->green;
580 float b = use_max ? local_session->blue_max : local_session->blue;
581 this->red->update(r);
582 this->green->update(g);
583 this->blue->update(b);
585 int rx = 255*r + 0.5; bclamp(rx,0,255);
586 int gx = 255*g + 0.5; bclamp(gx,0,255);
587 int bx = 255*b + 0.5; bclamp(bx,0,255);
588 char rgb_text[BCSTRLEN];
589 sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
590 rgb_hex->update(rgb_text);
593 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
595 this->u->update(u); u += 0.5;
596 this->v->update(v); v += 0.5;
598 int yx = 255*y + 0.5; bclamp(yx,0,255);
599 int ux = 255*u + 0.5; bclamp(ux,0,255);
600 int vx = 255*v + 0.5; bclamp(vx,0,255);
601 char yuv_text[BCSTRLEN];
602 sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
603 yuv_hex->update(yuv_text);
605 int rgb = (rx << 16) | (gx << 8) | (bx << 0);
606 sample->set_color(rgb);
607 sample->draw_box(0, 0, sample->get_w(), sample->get_h());
608 sample->set_color(BLACK);
609 sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
613 void CWindowEyedropGUI::handle_event()
615 int new_radius = atoi(radius->get_text());
616 if(new_radius != mwindow->edl->session->eyedrop_radius)
618 CWindowGUI *gui = mwindow->cwindow->gui;
619 if(gui->eyedrop_visible)
621 gui->lock_window("CWindowEyedropGUI::handle_event");
624 gui->canvas->do_eyedrop(rerender, 0, 1);
627 mwindow->edl->session->eyedrop_radius = new_radius;
629 if(gui->eyedrop_visible)
633 gui->canvas->do_eyedrop(rerender, 0, 1);
634 gui->unlock_window();
641 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
643 // Configuration for all possible Keyframe Curve Mode toggles
645 FloatAuto::t_mode mode;
651 const _CVD Camera_Crv_Smooth =
655 N_("\"smooth\" Curve on current Camera Keyframes")
657 const _CVD Camera_Crv_Linear =
661 N_("\"linear\" Curve on current Camera Keyframes")
663 const _CVD Projector_Crv_Smooth =
667 N_("\"smooth\" Curve on current Projector Keyframes")
669 const _CVD Projector_Crv_Linear =
673 N_("\"linear\" Curve on current Projector Keyframes")
676 // Implementation Class für Keyframe Curve Mode buttons
678 // This button reflects the state of the "current" keyframe
679 // (the nearest keyframe on the left) for all three automation
680 // lines together. Clicking on this button (re)sets the curve
681 // mode for the three "current" keyframes simultanously, but
682 // never creates a new keyframe.
684 class CWindowCurveToggle : public BC_Toggle
687 CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
688 void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
697 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
698 : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
702 this->mwindow = mwindow;
703 set_tooltip(_(cfg.tooltip));
706 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
708 // the toggle state is only set to ON if all
709 // three automation lines have the same curve mode.
710 // For mixed states the toggle stays off.
711 set_value( x->curve_mode == this->cfg.mode &&
712 y->curve_mode == this->cfg.mode &&
713 z->curve_mode == this->cfg.mode
714 ,true // redraw to show new state
718 int CWindowCurveToggle::handle_event()
720 Track *track = mwindow->cwindow->calculate_affected_track();
722 FloatAuto *x=0, *y=0, *z=0;
723 mwindow->cwindow->calculate_affected_autos(track,
724 &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
725 if( x ) x->change_curve_mode(cfg.mode);
726 if( y ) y->change_curve_mode(cfg.mode);
727 if( z ) z->change_curve_mode(cfg.mode);
730 gui->update_preview();
737 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
738 CWindowEyedropGUI *gui, int x, int y)
739 : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
741 this->mwindow = mwindow;
745 int CWindowEyedropCheckBox::handle_event()
747 mwindow->edl->local_session->use_max = get_value();
754 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
755 : CWindowToolGUI(mwindow,
757 _(PROGRAM_NAME ": Camera"),
762 CWindowCameraGUI::~CWindowCameraGUI()
766 void CWindowCameraGUI::create_objects()
768 int x = 10, y = 10, x1;
769 Track *track = mwindow->cwindow->calculate_affected_track();
770 FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
774 lock_window("CWindowCameraGUI::create_objects");
776 mwindow->cwindow->calculate_affected_autos(track,
777 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
780 add_subwindow(title = new BC_Title(x, y, "X:"));
782 this->x = new CWindowCoord(this, x, y,
783 x_auto ? x_auto->get_value() : (float)0);
784 this->x->create_objects();
789 add_subwindow(title = new BC_Title(x, y, "Y:"));
791 this->y = new CWindowCoord(this, x, y,
792 y_auto ? y_auto->get_value() : (float)0);
793 this->y->create_objects();
796 add_subwindow(title = new BC_Title(x, y, "Z:"));
798 this->z = new CWindowCoord(this, x, y,
799 z_auto ? z_auto->get_value() : (float)1);
800 this->z->create_objects();
801 this->z->set_increment(0.01);
805 add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
806 x1 += button->get_w();
807 add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
808 x1 += button->get_w();
809 add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
811 y += button->get_h();
813 add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
814 x1 += button->get_w();
815 add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
816 x1 += button->get_w();
817 add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
818 // additional Buttons to control the curve mode of the "current" keyframe
819 x1 += button->get_w() + 15;
820 add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
821 x1 += button->get_w();
822 add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
824 // fill in current auto keyframe values, set toggle states.
829 void CWindowCameraGUI::handle_event()
831 FloatAuto *x_auto = 0;
832 FloatAuto *y_auto = 0;
833 FloatAuto *z_auto = 0;
834 Track *track = mwindow->cwindow->calculate_affected_track();
837 mwindow->undo->update_undo_before(_("camera"), this);
838 if(event_caller == x)
840 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
841 track->automation->autos[AUTOMATION_CAMERA_X],
845 x_auto->set_value(atof(x->get_text()));
851 if(event_caller == y)
853 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
854 track->automation->autos[AUTOMATION_CAMERA_Y],
858 y_auto->set_value(atof(y->get_text()));
864 if(event_caller == z)
866 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
867 track->automation->autos[AUTOMATION_CAMERA_Z],
871 float zoom = atof(z->get_text());
872 if(zoom > 100.) zoom = 100.;
874 if(zoom < 0.01) zoom = 0.01;
875 // Doesn't allow user to enter from scratch
876 // if(zoom != atof(z->get_text()))
879 z_auto->set_value(zoom);
880 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
881 mwindow->gui->draw_overlays(1);
882 mwindow->gui->unlock_window();
888 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
892 void CWindowCameraGUI::update()
894 FloatAuto *x_auto = 0;
895 FloatAuto *y_auto = 0;
896 FloatAuto *z_auto = 0;
897 Track *track = mwindow->cwindow->calculate_affected_track();
899 mwindow->cwindow->calculate_affected_autos(track,
900 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
904 x->update(x_auto->get_value());
906 y->update(y_auto->get_value());
908 float value = z_auto->get_value();
910 thread->gui->lock_window("CWindowCameraGUI::update");
911 thread->gui->composite_panel->cpanel_zoom->update(value);
912 thread->gui->unlock_window();
915 if( x_auto && y_auto && z_auto )
917 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
918 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
925 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
926 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
929 this->mwindow = mwindow;
930 set_tooltip(_("Left justify"));
932 int CWindowCameraLeft::handle_event()
934 FloatAuto *x_auto = 0;
935 FloatAuto *z_auto = 0;
936 Track *track = mwindow->cwindow->calculate_affected_track();
938 mwindow->cwindow->calculate_affected_autos(track,
939 &x_auto, 0, &z_auto, 1, 1, 0, 0);
945 track->get_source_dimensions(
946 mwindow->edl->local_session->get_selectionstart(1),
952 mwindow->undo->update_undo_before(_("camera"), 0);
954 (double)track->track_w / z_auto->get_value() / 2 -
956 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
958 gui->update_preview();
966 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
967 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
970 this->mwindow = mwindow;
971 set_tooltip(_("Center horizontal"));
973 int CWindowCameraCenter::handle_event()
975 FloatAuto *x_auto = 0;
976 Track *track = mwindow->cwindow->calculate_affected_track();
978 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
979 track->automation->autos[AUTOMATION_CAMERA_X],
984 mwindow->undo->update_undo_before(_("camera"), 0);
985 x_auto->set_value(0);
987 gui->update_preview();
988 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
995 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
996 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
999 this->mwindow = mwindow;
1000 set_tooltip(_("Right justify"));
1002 int CWindowCameraRight::handle_event()
1004 FloatAuto *x_auto = 0;
1005 FloatAuto *z_auto = 0;
1006 Track *track = mwindow->cwindow->calculate_affected_track();
1008 mwindow->cwindow->calculate_affected_autos(track,
1009 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1012 if(x_auto && z_auto)
1015 track->get_source_dimensions(
1016 mwindow->edl->local_session->get_selectionstart(1),
1022 mwindow->undo->update_undo_before(_("camera"), 0);
1023 x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1026 gui->update_preview();
1027 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1035 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1036 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1039 this->mwindow = mwindow;
1040 set_tooltip(_("Top justify"));
1042 int CWindowCameraTop::handle_event()
1044 FloatAuto *y_auto = 0;
1045 FloatAuto *z_auto = 0;
1046 Track *track = mwindow->cwindow->calculate_affected_track();
1048 mwindow->cwindow->calculate_affected_autos(track,
1049 0, &y_auto, &z_auto, 1, 0, 1, 0);
1052 if(y_auto && z_auto)
1055 track->get_source_dimensions(
1056 mwindow->edl->local_session->get_selectionstart(1),
1062 mwindow->undo->update_undo_before(_("camera"), 0);
1063 y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1066 gui->update_preview();
1067 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1075 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1076 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1079 this->mwindow = mwindow;
1080 set_tooltip(_("Center vertical"));
1082 int CWindowCameraMiddle::handle_event()
1084 FloatAuto *y_auto = 0;
1085 Track *track = mwindow->cwindow->calculate_affected_track();
1087 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1088 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1092 mwindow->undo->update_undo_before(_("camera"), 0);
1093 y_auto->set_value(0);
1095 gui->update_preview();
1096 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1103 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1104 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1107 this->mwindow = mwindow;
1108 set_tooltip(_("Bottom justify"));
1110 int CWindowCameraBottom::handle_event()
1112 FloatAuto *y_auto = 0;
1113 FloatAuto *z_auto = 0;
1114 Track *track = mwindow->cwindow->calculate_affected_track();
1116 mwindow->cwindow->calculate_affected_autos(track,
1117 0, &y_auto, &z_auto, 1, 0, 1, 0);
1120 if(y_auto && z_auto)
1123 track->get_source_dimensions(
1124 mwindow->edl->local_session->get_selectionstart(1),
1130 mwindow->undo->update_undo_before(_("camera"), 0);
1131 y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1134 gui->update_preview();
1135 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1143 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1144 : CWindowToolGUI(mwindow,
1146 _(PROGRAM_NAME ": Projector"),
1151 CWindowProjectorGUI::~CWindowProjectorGUI()
1154 void CWindowProjectorGUI::create_objects()
1156 int x = 10, y = 10, x1;
1157 Track *track = mwindow->cwindow->calculate_affected_track();
1158 FloatAuto *x_auto = 0;
1159 FloatAuto *y_auto = 0;
1160 FloatAuto *z_auto = 0;
1164 lock_window("CWindowProjectorGUI::create_objects");
1166 mwindow->cwindow->calculate_affected_autos(track,
1167 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1170 add_subwindow(title = new BC_Title(x, y, "X:"));
1171 x += title->get_w();
1172 this->x = new CWindowCoord(this, x, y,
1173 x_auto ? x_auto->get_value() : (float)0);
1174 this->x->create_objects();
1177 add_subwindow(title = new BC_Title(x, y, "Y:"));
1178 x += title->get_w();
1179 this->y = new CWindowCoord(this, x, y,
1180 y_auto ? y_auto->get_value() : (float)0);
1181 this->y->create_objects();
1184 add_subwindow(title = new BC_Title(x, y, "Z:"));
1185 x += title->get_w();
1186 this->z = new CWindowCoord(this, x, y,
1187 z_auto ? z_auto->get_value() : (float)1);
1188 this->z->create_objects();
1189 this->z->set_increment(0.01);
1193 add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1194 x1 += button->get_w();
1195 add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1196 x1 += button->get_w();
1197 add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1199 y += button->get_h();
1201 add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1202 x1 += button->get_w();
1203 add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1204 x1 += button->get_w();
1205 add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1207 // additional Buttons to control the curve mode of the "current" keyframe
1208 x1 += button->get_w() + 15;
1209 add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1210 x1 += button->get_w();
1211 add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1213 // fill in current auto keyframe values, set toggle states.
1218 void CWindowProjectorGUI::handle_event()
1220 FloatAuto *x_auto = 0;
1221 FloatAuto *y_auto = 0;
1222 FloatAuto *z_auto = 0;
1223 Track *track = mwindow->cwindow->calculate_affected_track();
1227 mwindow->undo->update_undo_before(_("projector"), this);
1228 if(event_caller == x)
1230 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1231 track->automation->autos[AUTOMATION_PROJECTOR_X],
1235 x_auto->set_value(atof(x->get_text()));
1241 if(event_caller == y)
1243 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1244 track->automation->autos[AUTOMATION_PROJECTOR_Y],
1248 y_auto->set_value(atof(y->get_text()));
1254 if(event_caller == z)
1256 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1257 track->automation->autos[AUTOMATION_PROJECTOR_Z],
1261 float zoom = atof(z->get_text());
1262 if(zoom > 100.) zoom = 100.;
1263 else if(zoom < 0.01) zoom = 0.01;
1264 // if (zoom != atof(z->get_text()))
1266 z_auto->set_value(zoom);
1268 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1269 mwindow->gui->draw_overlays(1);
1270 mwindow->gui->unlock_window();
1276 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1280 void CWindowProjectorGUI::update()
1282 FloatAuto *x_auto = 0;
1283 FloatAuto *y_auto = 0;
1284 FloatAuto *z_auto = 0;
1285 Track *track = mwindow->cwindow->calculate_affected_track();
1287 mwindow->cwindow->calculate_affected_autos(track,
1288 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1292 x->update(x_auto->get_value());
1294 y->update(y_auto->get_value());
1296 float value = z_auto->get_value();
1298 thread->gui->lock_window("CWindowProjectorGUI::update");
1299 thread->gui->composite_panel->cpanel_zoom->update(value);
1300 thread->gui->unlock_window();
1303 if( x_auto && y_auto && z_auto )
1305 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1306 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1310 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1311 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1314 this->mwindow = mwindow;
1315 set_tooltip(_("Left justify"));
1317 int CWindowProjectorLeft::handle_event()
1319 FloatAuto *x_auto = 0;
1320 FloatAuto *z_auto = 0;
1321 Track *track = mwindow->cwindow->calculate_affected_track();
1323 mwindow->cwindow->calculate_affected_autos(track,
1324 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1326 if(x_auto && z_auto)
1328 mwindow->undo->update_undo_before(_("projector"), 0);
1329 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1330 (double)mwindow->edl->session->output_w / 2 );
1332 gui->update_preview();
1333 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1340 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1341 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1344 this->mwindow = mwindow;
1345 set_tooltip(_("Center horizontal"));
1347 int CWindowProjectorCenter::handle_event()
1349 FloatAuto *x_auto = 0;
1350 Track *track = mwindow->cwindow->calculate_affected_track();
1352 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1353 track->automation->autos[AUTOMATION_PROJECTOR_X],
1358 mwindow->undo->update_undo_before(_("projector"), 0);
1359 x_auto->set_value(0);
1361 gui->update_preview();
1362 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1369 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1370 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1373 this->mwindow = mwindow;
1374 set_tooltip(_("Right justify"));
1376 int CWindowProjectorRight::handle_event()
1378 FloatAuto *x_auto = 0;
1379 FloatAuto *z_auto = 0;
1380 Track *track = mwindow->cwindow->calculate_affected_track();
1382 mwindow->cwindow->calculate_affected_autos(track,
1383 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1386 if(x_auto && z_auto)
1388 mwindow->undo->update_undo_before(_("projector"), 0);
1389 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1390 (double)mwindow->edl->session->output_w / 2));
1392 gui->update_preview();
1393 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1400 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1401 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1404 this->mwindow = mwindow;
1405 set_tooltip(_("Top justify"));
1407 int CWindowProjectorTop::handle_event()
1409 FloatAuto *y_auto = 0;
1410 FloatAuto *z_auto = 0;
1411 Track *track = mwindow->cwindow->calculate_affected_track();
1413 mwindow->cwindow->calculate_affected_autos(track,
1414 0, &y_auto, &z_auto, 0, 0, 1, 0);
1417 if(y_auto && z_auto)
1419 mwindow->undo->update_undo_before(_("projector"), 0);
1420 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1421 (double)mwindow->edl->session->output_h / 2 );
1423 gui->update_preview();
1424 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1431 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1432 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1435 this->mwindow = mwindow;
1436 set_tooltip(_("Center vertical"));
1438 int CWindowProjectorMiddle::handle_event()
1440 FloatAuto *y_auto = 0;
1441 Track *track = mwindow->cwindow->calculate_affected_track();
1443 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1444 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1448 mwindow->undo->update_undo_before(_("projector"), 0);
1449 y_auto->set_value(0);
1451 gui->update_preview();
1452 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1459 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1460 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1463 this->mwindow = mwindow;
1464 set_tooltip(_("Bottom justify"));
1466 int CWindowProjectorBottom::handle_event()
1468 FloatAuto *y_auto = 0;
1469 FloatAuto *z_auto = 0;
1470 Track *track = mwindow->cwindow->calculate_affected_track();
1472 mwindow->cwindow->calculate_affected_autos(track,
1473 0, &y_auto, &z_auto, 0, 0, 1, 0);
1476 if(y_auto && z_auto)
1478 mwindow->undo->update_undo_before(_("projector"), 0);
1479 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1480 (double)mwindow->edl->session->output_h / 2));
1482 gui->update_preview();
1483 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1490 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1491 int x, int y, int w, const char *text)
1492 : BC_PopupTextBox(gui, 0, text, x, y, w, 120)
1494 this->mwindow = mwindow;
1498 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1502 int CWindowMaskOnTrack::handle_event()
1504 CWindowMaskItem *track_item = 0;
1505 int k = get_number(), track_id = -1;
1506 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1508 track_item = (CWindowMaskItem *)track_items[k];
1509 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1510 if( track && track->record ) track_id = track->get_id();
1513 track_id = mwindow->cwindow->mask_track_id;
1514 set_back_color(track_id >= 0 ?
1515 gui->get_resources()->text_background :
1516 gui->get_resources()->text_background_disarmed);
1517 if( mwindow->cwindow->mask_track_id != track_id )
1518 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1519 mwindow->cwindow->mask_track_id = track_id;
1520 mwindow->edl->local_session->solo_track_id = -1;
1521 gui->mask_solo_track->update(0);
1523 gui->update_preview(1);
1527 void CWindowMaskOnTrack::update_items()
1529 track_items.remove_all_objects();
1530 int high_color = gui->get_resources()->button_highlighted;
1531 for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1532 if( track->data_type != TRACK_VIDEO ) continue;
1533 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1534 int color = !track->record ? RED : mask_autos->first ? high_color : -1;
1535 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1536 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1537 if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1538 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1540 update_list(&track_items);
1543 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1547 this->mwindow = mwindow;
1550 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1554 int CWindowMaskTrackTumbler::handle_up_event()
1559 int CWindowMaskTrackTumbler::handle_down_event()
1561 return do_event(-1);
1564 int CWindowMaskTrackTumbler::do_event(int dir)
1566 CWindowMaskItem *track_item = 0;
1567 CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1568 int n = gui->mask_on_track->track_items.size();
1569 int id = mwindow->cwindow->mask_track_id;
1572 while( --k >= 0 && items[k]->id != id );
1576 track_item = items[k];
1579 track_item = items[0];
1581 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1582 int track_id = track_item && track && track->record ? track_item->id : -1;
1583 gui->mask_on_track->set_back_color(track_id >= 0 ?
1584 gui->get_resources()->text_background :
1585 gui->get_resources()->text_background_disarmed);
1586 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1587 mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1588 mwindow->edl->local_session->solo_track_id = -1;
1589 gui->mask_solo_track->update(0);
1591 gui->update_preview(1);
1596 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1597 int x, int y, const char *text)
1598 : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
1600 this->mwindow = mwindow;
1604 CWindowMaskName::~CWindowMaskName()
1608 int CWindowMaskName::handle_event()
1615 //printf("CWindowMaskGUI::update 1\n");
1616 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1618 int k = get_number();
1619 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1620 else mwindow->edl->session->cwindow_mask = k;
1621 if( k >= 0 && k < mask_items.size() ) {
1622 mask_items[k]->set_text(get_text());
1623 update_list(&mask_items);
1625 #ifdef USE_KEYFRAME_SPANNING
1626 MaskAuto temp_keyframe(mwindow->edl, autos);
1627 temp_keyframe.copy_data(keyframe);
1628 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1629 memset(submask->name, 0, sizeof(submask->name));
1630 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1631 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1633 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1634 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1635 memset(submask->name, 0, sizeof(submask->name));
1636 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1637 current = current == (MaskAuto*)autos->default_auto ?
1638 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1642 gui->update_preview();
1647 void CWindowMaskName::update_items(MaskAuto *keyframe)
1649 mask_items.remove_all_objects();
1650 int sz = !keyframe ? 0 : keyframe->masks.size();
1651 for( int i=0; i<SUBMASKS; ++i ) {
1652 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
1654 SubMask *sub_mask = keyframe->masks.get(i);
1655 strncpy(text, sub_mask->name, sizeof(text)-1);
1658 sprintf(text, "%d", i);
1659 mask_items.append(new CWindowMaskItem(text));
1661 update_list(&mask_items);
1665 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1666 int x, int y, int no, int v)
1667 : BC_CheckBox(x, y, v)
1669 this->mwindow = mwindow;
1674 CWindowMaskButton::~CWindowMaskButton()
1678 int CWindowMaskButton::handle_event()
1680 mwindow->edl->session->cwindow_mask = no;
1681 gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1683 gui->update_preview();
1687 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1691 this->mwindow = mwindow;
1695 CWindowMaskThumbler::~CWindowMaskThumbler()
1699 int CWindowMaskThumbler::handle_up_event()
1704 int CWindowMaskThumbler::handle_down_event()
1706 return do_event(-1);
1709 int CWindowMaskThumbler::do_event(int dir)
1711 int k = mwindow->edl->session->cwindow_mask;
1712 if( (k+=dir) >= SUBMASKS ) k = 0;
1713 else if( k < 0 ) k = SUBMASKS-1;
1714 mwindow->edl->session->cwindow_mask = k;
1715 gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1717 gui->update_preview();
1721 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1722 int x, int y, int no, int v)
1723 : BC_CheckBox(x, y, v)
1725 this->mwindow = mwindow;
1730 CWindowMaskEnable::~CWindowMaskEnable()
1734 int CWindowMaskEnable::handle_event()
1736 Track *track = mwindow->cwindow->calculate_mask_track();
1738 mwindow->undo->update_undo_before(_("mask enable"), this);
1741 track->masks |= bit;
1743 track->masks &= ~bit;
1745 gui->update_preview(1);
1746 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1751 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1752 CWindowMaskGUI *gui, int x, int y)
1753 : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1755 this->mwindow = mwindow;
1757 set_tooltip(_("Show/Hide mask"));
1760 int CWindowMaskUnclear::handle_event()
1762 Track *track = mwindow->cwindow->calculate_mask_track();
1764 mwindow->undo->update_undo_before(_("mask enables"), this);
1765 int m = (1<<SUBMASKS)-1;
1766 if( track->masks == m )
1770 for( int i=0; i<SUBMASKS; ++i )
1771 gui->mask_enables[i]->update((track->masks>>i) & 1);
1772 gui->update_preview(1);
1773 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
1778 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
1779 CWindowMaskGUI *gui, int x, int y, int v)
1780 : BC_CheckBox(x, y, v, _("Solo"))
1782 this->mwindow = mwindow;
1784 set_tooltip(_("Solo video track"));
1787 int CWindowMaskSoloTrack::handle_event()
1789 mwindow->edl->local_session->solo_track_id =
1790 get_value() ? mwindow->cwindow->mask_track_id : -1;
1791 gui->update_preview(1);
1795 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
1798 calculate_extents(gui, &w, &h, _("Solo"));
1802 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
1803 CWindowMaskGUI *gui, int x, int y)
1804 : BC_GenericButton(x, y, _("Delete"))
1806 this->mwindow = mwindow;
1808 set_tooltip(_("Delete mask"));
1811 int CWindowMaskDelMask::handle_event()
1820 // Get existing keyframe
1821 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1824 mwindow->undo->update_undo_before(_("mask delete"), 0);
1826 #ifdef USE_KEYFRAME_SPANNING
1827 // Create temp keyframe
1828 MaskAuto temp_keyframe(mwindow->edl, autos);
1829 temp_keyframe.copy_data(keyframe);
1830 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1831 submask->points.remove_all_objects();
1833 // Commit change to span of keyframes
1834 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1836 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1837 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1838 submask->points.remove_all_objects();
1839 current = current == (MaskAuto*)autos->default_auto ?
1840 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1844 if( mwindow->cwindow->gui->affected_point >= total_points )
1845 mwindow->cwindow->gui->affected_point =
1846 total_points > 0 ? total_points-1 : 0;
1849 gui->update_preview();
1850 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1856 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
1857 CWindowMaskGUI *gui, int x, int y)
1858 : BC_GenericButton(x, y, _("Delete"))
1860 this->mwindow = mwindow;
1862 set_tooltip(_("Delete point"));
1865 int CWindowMaskDelPoint::handle_event()
1874 // Get existing keyframe
1875 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1877 mwindow->undo->update_undo_before(_("point delete"), 0);
1879 #ifdef USE_KEYFRAME_SPANNING
1880 // Create temp keyframe
1881 MaskAuto temp_keyframe(mwindow->edl, autos);
1882 temp_keyframe.copy_data(keyframe);
1884 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1885 int i = mwindow->cwindow->gui->affected_point;
1886 for( ; i<submask->points.total-1; ++i )
1887 *submask->points.values[i] = *submask->points.values[i+1];
1888 if( submask->points.total > 0 ) {
1889 point = submask->points.values[submask->points.total-1];
1890 submask->points.remove_object(point);
1892 total_points = submask->points.total;
1894 // Commit change to span of keyframes
1895 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1898 MaskAuto *current = (MaskAuto*)autos->default_auto;
1900 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1901 int i = mwindow->cwindow->gui->affected_point;
1902 for( ; i<submask->points.total-1; ++i )
1903 *submask->points.values[i] = *submask->points.values[i+1];
1904 if( submask->points.total > 0 ) {
1905 point = submask->points.values[submask->points.total-1];
1906 submask->points.remove_object(point);
1908 total_points = submask->points.total;
1909 current = current == (MaskAuto*)autos->default_auto ?
1910 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1913 if( mwindow->cwindow->gui->affected_point >= total_points )
1914 mwindow->cwindow->gui->affected_point =
1915 total_points > 0 ? total_points-1 : 0;
1918 gui->update_preview();
1919 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
1926 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
1927 CWindowMaskGUI *gui, int x, int y)
1928 : BC_TumbleTextBox(gui,
1929 (int64_t)mwindow->cwindow->gui->affected_point,
1930 (int64_t)0, INT64_MAX, x, y, 70)
1932 this->mwindow = mwindow;
1936 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
1940 int CWindowMaskAffectedPoint::handle_event()
1942 int total_points = 0;
1943 int affected_point = atol(get_text());
1944 Track *track = mwindow->cwindow->calculate_mask_track();
1946 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1947 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
1949 SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
1950 total_points = mask->points.size();
1953 int active_point = affected_point;
1954 if( affected_point >= total_points )
1955 affected_point = total_points - 1;
1956 if( affected_point < 0 )
1958 if( active_point != affected_point )
1959 update((int64_t)affected_point);
1960 mwindow->cwindow->gui->affected_point = affected_point;
1962 gui->update_preview();
1967 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
1968 : BC_CheckBox(x, y, gui->focused, _("Focus"))
1970 this->mwindow = mwindow;
1972 set_tooltip(_("Center for rotate/scale"));
1975 CWindowMaskFocus::~CWindowMaskFocus()
1979 int CWindowMaskFocus::handle_event()
1981 gui->focused = get_value();
1983 gui->update_preview();
1987 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
1990 calculate_extents(gui, &w, &h, _("Focus"));
1994 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
1995 int x, int y, VFrame **data, int v, int id, const char *tip)
1996 : BC_Toggle(x, y, data, v)
1999 this->mwindow = mwindow;
2004 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2008 int CWindowMaskScaleXY::handle_event()
2010 gui->scale_mode = id;
2011 gui->mask_scale_x->update(id == MASK_SCALE_X);
2012 gui->mask_scale_y->update(id == MASK_SCALE_Y);
2013 gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2017 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2018 : BC_CheckBox(x, y, 0, _("Help"))
2020 this->mwindow = mwindow;
2022 set_tooltip(_("Show help text"));
2025 CWindowMaskHelp::~CWindowMaskHelp()
2029 int CWindowMaskHelp::handle_event()
2031 gui->helped = get_value();
2032 gui->resize_window(gui->get_w(),
2033 gui->helped ? gui->help_h : gui->help_y);
2038 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2039 : BC_CheckBox(x, y, gui->markers, _("Markers"))
2041 this->mwindow = mwindow;
2043 set_tooltip("Display points");
2046 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2050 int CWindowMaskDrawMarkers::handle_event()
2052 gui->markers = get_value();
2054 gui->update_preview();
2058 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2059 : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2061 this->mwindow = mwindow;
2063 set_tooltip("Display mask outline");
2066 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2070 int CWindowMaskDrawBoundary::handle_event()
2072 gui->boundary = get_value();
2074 gui->update_preview();
2079 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2080 : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, 64, 2)
2082 this->mwindow = mwindow;
2085 CWindowMaskFeather::~CWindowMaskFeather()
2089 int CWindowMaskFeather::update(float v)
2091 gui->feather_slider->update(v);
2092 return BC_TumbleTextBox::update(v);
2095 int CWindowMaskFeather::update_value(float v)
2102 #ifdef USE_KEYFRAME_SPANNING
2108 mwindow->undo->update_undo_before(_("mask feather"), this);
2110 // Get existing keyframe
2111 gui->get_keyframe(track, autos, keyframe,
2112 mask, point, create_it);
2114 int gang = gui->gang_feather->get_value();
2115 #ifdef USE_KEYFRAME_SPANNING
2116 MaskAuto temp_keyframe(mwindow->edl, autos);
2117 temp_keyframe.copy_data(keyframe);
2118 keyframe = &temp_keyframe;
2120 float change = v - mask->feather;
2121 int k = mwindow->edl->session->cwindow_mask;
2122 int n = gang ? keyframe->masks.size() : k+1;
2123 for( int i=gang? 0 : k; i<n; ++i ) {
2124 if( !gui->mask_enables[i]->get_value() ) continue;
2125 SubMask *sub_mask = keyframe->get_submask(i);
2126 float feather = sub_mask->feather + change;
2127 sub_mask->feather = feather;
2129 #ifdef USE_KEYFRAME_SPANNING
2130 autos->update_parameter(keyframe);
2132 gui->update_preview();
2135 mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2139 int CWindowMaskFeather::handle_event()
2141 float v = atof(get_text());
2142 if( fabsf(v) > MAX_FEATHER )
2143 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2144 gui->feather_slider->update(v);
2145 return gui->feather->update_value(v);
2148 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2149 CWindowMaskGUI *gui, int x, int y, int w, float v)
2150 : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2152 this->mwindow = mwindow;
2154 set_precision(0.01);
2155 timer = new Timer();
2161 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2166 int CWindowMaskFeatherSlider::handle_event()
2169 float v = get_value();
2170 if( fabsf(v) > MAX_FEATHER )
2171 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2172 if( stick && timer->get_difference() >= 250 )
2173 stick = 0; // no events for .25 sec
2174 if( stick && (last_v * (v-last_v)) < 0 )
2175 stick = 0; // dv changed direction
2184 if( max > MAX_FEATHER ) max = MAX_FEATHER;
2185 update(get_w(), v=last_v, -max-5, max+5);
2186 button_release_event();
2189 else if( v > max ) { v = max; sticky = 24; }
2190 else if( v < -max ) { v = -max; sticky = 24; }
2191 else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0; sticky = 16; }
2192 if( sticky ) { update(v); stick = sticky; timer->update(); }
2194 gui->feather->BC_TumbleTextBox::update(v);
2195 return gui->feather->update_value(v);
2198 int CWindowMaskFeatherSlider::update(float v)
2200 float vv = fabsf(v);
2201 if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2202 while( max < vv ) max *= 1.25;
2203 return update(get_w(), v, -max-5, max+5);
2205 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2207 return BC_FSlider::update(r, v, mn, mx);
2210 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2211 : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
2213 this->mwindow = mwindow;
2216 CWindowMaskFade::~CWindowMaskFade()
2220 int CWindowMaskFade::update(float v)
2222 gui->fade_slider->update(v);
2223 return BC_TumbleTextBox::update(v);
2226 int CWindowMaskFade::update_value(float v)
2233 #ifdef USE_KEYFRAME_SPANNING
2239 mwindow->undo->update_undo_before(_("mask fade"), this);
2241 // Get existing keyframe
2242 gui->get_keyframe(track, autos, keyframe,
2243 mask, point, create_it);
2245 int gang = gui->gang_fader->get_value();
2246 #ifdef USE_KEYFRAME_SPANNING
2247 MaskAuto temp_keyframe(mwindow->edl, autos);
2248 temp_keyframe.copy_data(keyframe);
2249 keyframe = &temp_keyframe;
2251 float change = v - mask->fader;
2252 int k = mwindow->edl->session->cwindow_mask;
2253 int n = gang ? keyframe->masks.size() : k+1;
2254 for( int i=gang? 0 : k; i<n; ++i ) {
2255 if( !gui->mask_enables[i]->get_value() ) continue;
2256 SubMask *sub_mask = keyframe->get_submask(i);
2257 float fader = sub_mask->fader + change;
2258 bclamp(fader, -100.f, 100.f);
2259 sub_mask->fader = fader;
2261 #ifdef USE_KEYFRAME_SPANNING
2262 autos->update_parameter(keyframe);
2264 gui->update_preview();
2267 mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2271 int CWindowMaskFade::handle_event()
2273 float v = atof(get_text());
2274 gui->fade_slider->update(v);
2275 return gui->fade->update_value(v);
2278 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2279 int x, int y, int w)
2280 : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2282 this->mwindow = mwindow;
2284 timer = new Timer();
2289 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2294 int CWindowMaskFadeSlider::handle_event()
2296 float v = 100*get_value()/200;
2298 int64_t ms = timer->get_difference();
2299 if( ms < 250 && --stick > 0 ) {
2300 if( get_value() == 0 ) return 1;
2308 else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2315 gui->fade->BC_TumbleTextBox::update(v);
2316 return gui->fade->update_value(v);
2319 int CWindowMaskFadeSlider::update(int64_t v)
2321 return BC_ISlider::update(200*v/100);
2324 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2325 CWindowMaskGUI *gui, int x, int y)
2326 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2328 this->mwindow = mwindow;
2330 set_tooltip(_("Gang fader"));
2333 CWindowMaskGangFader::~CWindowMaskGangFader()
2337 int CWindowMaskGangFader::handle_event()
2342 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2343 CWindowMaskGUI *gui, int x, int y)
2344 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2346 this->mwindow = mwindow;
2348 set_tooltip(_("Gang rotate/scale/translate"));
2351 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2355 int CWindowMaskGangFocus::handle_event()
2360 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2361 CWindowMaskGUI *gui, int x, int y)
2362 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2364 this->mwindow = mwindow;
2366 set_tooltip(_("Gang points"));
2369 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2373 int CWindowMaskGangPoint::handle_event()
2379 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2380 const char *tip, int type, int on, int x, int y, const char *images)
2381 : BC_Button(x, y, mwindow->theme->get_image_set(images))
2383 this->mwindow = mwindow;
2390 int CWindowMaskSmoothButton::handle_event()
2392 return gui->smooth_mask(type, on);
2395 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2396 : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2401 int CWindowMaskBeforePlugins::handle_event()
2408 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2411 int v = get_value();
2412 #ifdef USE_KEYFRAME_SPANNING
2413 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2414 temp_keyframe.copy_data(keyframe);
2415 temp_keyframe.apply_before_plugins = v;
2416 autos->update_parameter(&temp_keyframe);
2418 keyframe->apply_before_plugins = v;
2420 gui->update_preview();
2426 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2427 : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2432 int CWindowDisableOpenGLMasking::handle_event()
2439 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2442 int v = get_value();
2443 #ifdef USE_KEYFRAME_SPANNING
2444 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2445 temp_keyframe.copy_data(keyframe);
2446 temp_keyframe.disable_opengl_masking = v;
2447 autos->update_parameter(&temp_keyframe);
2449 keyframe->disable_opengl_masking = v;
2451 gui->update_preview();
2457 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2458 CWindowMaskGUI *gui, int x, int y)
2459 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2461 this->mwindow = mwindow;
2463 set_tooltip(_("Delete all masks"));
2466 CWindowMaskClrMask::~CWindowMaskClrMask()
2470 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2472 VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2473 return vfrm->get_w();
2476 int CWindowMaskClrMask::handle_event()
2484 // Get existing keyframe
2485 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2488 mwindow->undo->update_undo_before(_("del masks"), 0);
2489 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2490 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2494 gui->update_preview(1);
2498 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2499 CWindowMaskGUI *gui, int x, int y)
2500 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2502 this->mwindow = mwindow;
2504 set_tooltip(_("Gang feather"));
2507 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2511 int CWindowMaskGangFeather::handle_event()
2516 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2517 : CWindowToolGUI(mwindow, thread,
2518 _(PROGRAM_NAME ": Mask"), 440, 700)
2520 this->mwindow = mwindow;
2521 this->thread = thread;
2531 CWindowMaskGUI::~CWindowMaskGUI()
2533 lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2535 delete active_point;
2539 delete preset_dialog;
2542 void CWindowMaskGUI::create_objects()
2544 Theme *theme = mwindow->theme;
2545 int x = 10, y = 10, margin = theme->widget_border, t[SUBMASKS];
2546 int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2547 int clr_x = get_w()-x - clr_w;
2549 lock_window("CWindowMaskGUI::create_objects");
2550 BC_TitleBar *title_bar;
2551 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks on Track")));
2552 y += title_bar->get_h() + margin;
2554 add_subwindow(title = new BC_Title(x,y, _("Track:")));
2555 int x1 = x + 90, ww = clr_x-2*margin - x1;
2556 for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2558 Track *track = mwindow->cwindow->calculate_affected_track();
2559 const char *text = track ? track->title : "";
2560 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2561 mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, 100, text);
2562 mask_on_track->create_objects();
2563 mask_on_track->set_tooltip(_("Video track"));
2564 int x2 = x1 + mask_on_track->get_w();
2565 add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2566 mwindow->edl->local_session->solo_track_id = -1;
2567 add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2568 y += mask_on_track->get_h() + margin;
2569 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks")));
2570 y += title_bar->get_h() + margin;
2571 add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2572 mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2573 mask_name->create_objects();
2574 mask_name->set_tooltip(_("Mask name"));
2575 add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2576 add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2577 y += mask_name->get_h() + 2*margin;
2579 // add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2580 // y += bar->get_h() + 2*margin;
2582 add_subwindow(title = new BC_Title(x, y, _("Select:")));
2584 BC_CheckBox::calculate_extents(this, &bw, &bh);
2585 for( int i=0; i<SUBMASKS; ++i ) {
2586 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2587 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2588 add_subwindow(mask_buttons[i]);
2590 add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2592 for( int i=0; i<SUBMASKS; ++i ) {
2593 char text[BCSTRLEN]; sprintf(text, "%d", i);
2594 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2595 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2596 add_subwindow(mask_blabels[i]);
2598 y += mask_blabels[0]->get_h() + margin;
2599 add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2600 for( int i=0; i<SUBMASKS; ++i ) {
2601 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2602 add_subwindow(mask_enables[i]);
2604 add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2605 y += mask_enables[0]->get_h() + 2*margin;
2606 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Preset Shapes")));
2607 y += title_bar->get_h() + margin;
2608 add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2609 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2610 add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2611 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2612 add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2613 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2614 add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2615 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2616 add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2617 add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, 80));
2618 add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, 80));
2619 add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, 80));
2620 y += mask_load->get_h() + 2*margin;
2621 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Position & Scale")));
2622 y += title_bar->get_h() + 2*margin;
2623 add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, 80));
2624 add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, 80));
2626 add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2627 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2628 add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2629 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2630 add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2631 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2632 y += mask_center->get_h() + 2*margin;
2633 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Fade & Feather")));
2634 y += title_bar->get_h() + 2*margin;
2636 add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2637 fade = new CWindowMaskFade(mwindow, this, x1, y);
2638 fade->create_objects();
2639 x2 = x1 + fade->get_w() + 2*margin;
2640 int w2 = clr_x-2*margin - x2;
2641 add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2642 add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2643 y += fade->get_h() + margin;
2644 add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2645 feather = new CWindowMaskFeather(mwindow, this, x1, y);
2646 feather->create_objects();
2647 w2 = clr_x - 2*margin - x2;
2648 feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2649 add_subwindow(feather_slider);
2650 add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2651 y += feather->get_h() + 2*margin;
2652 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Mask Points")));
2653 y += title_bar->get_h() + margin;
2655 add_subwindow(title = new BC_Title(x, y, _("Point:")));
2656 active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2657 active_point->create_objects();
2658 // typ=0, this mask, this point
2659 add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2660 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2661 add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2662 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2663 add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2664 add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2665 y += active_point->get_h() + margin;
2666 add_subwindow(title = new BC_Title(x, y, "X:"));
2667 this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2668 this->x->create_objects();
2669 // typ>0, this mask, all points
2670 add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2671 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2672 add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2673 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2674 add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2675 y += this->x->get_h() + margin;
2676 add_subwindow(title = new BC_Title(x, y, "Y:"));
2677 this->y = new CWindowCoord(this, x1, y, (float)0.0);
2678 this->y->create_objects();
2679 // typ<0, all masks, all points
2680 add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2681 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2682 add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2683 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2684 add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2685 y += this->y->get_h() + 2*margin;
2686 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Pivot Point")));
2687 y += title_bar->get_h() + margin;
2689 add_subwindow(title = new BC_Title(x, y, "X:"));
2690 float cx = mwindow->edl->session->output_w / 2.f;
2691 focus_x = new CWindowCoord(this, x1, y, cx);
2692 focus_x->create_objects();
2693 add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2694 add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2695 y += focus_x->get_h() + margin;
2696 add_subwindow(title = new BC_Title(x, y, "Y:"));
2697 float cy = mwindow->edl->session->output_h / 2.f;
2698 focus_y = new CWindowCoord(this, x1, y, cy);
2699 focus_y->create_objects();
2700 y += focus_y->get_h() + 2*margin;
2701 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2702 y += bar->get_h() + margin;
2703 add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
2704 y += this->apply_before_plugins->get_h();
2705 add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
2706 add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2707 y += this->disable_opengl_masking->get_h() + 2*margin;
2709 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2710 y += bar->get_h() + 2*margin;
2711 add_subwindow(title = new BC_Title(x, y, _(
2712 "Shift+LMB: move an end point\n"
2713 "Ctrl+LMB: move a control point\n"
2714 "Alt+LMB: to drag translate the mask\n"
2715 "Shift+MMB: Set Pivot Point at pointer\n"
2716 "Wheel: rotate around Pivot Point\n"
2717 "Shift+Wheel: scale around Pivot Point\n"
2718 "Ctrl+Wheel: rotate/scale around pointer")));
2719 help_h = y + title->get_h() + 2*margin;
2721 resize_window(get_w(), help_y);
2725 int CWindowMaskGUI::close_event()
2728 return CWindowToolGUI::close_event();
2731 void CWindowMaskGUI::done_event()
2733 if( mwindow->in_destructor ) return;
2734 int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2735 if( solo_track_id >= 0 ) {
2741 void CWindowMaskGUI::get_keyframe(Track* &track,
2742 MaskAutos* &autos, MaskAuto* &keyframe,
2743 SubMask* &mask, MaskPoint* &point, int create_it)
2748 track = mwindow->cwindow->calculate_mask_track();
2750 track = mwindow->cwindow->calculate_affected_track();
2753 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2754 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2759 mask = !keyframe ? 0 :
2760 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2764 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
2765 mwindow->cwindow->gui->affected_point >= 0 ) {
2766 point = mask->points.values[mwindow->cwindow->gui->affected_point];
2771 void CWindowMaskGUI::update()
2778 //printf("CWindowMaskGUI::update 1\n");
2779 get_keyframe(track, autos, keyframe, mask, point, 0);
2780 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2781 mask_on_track->set_back_color(!track || track->record ?
2782 get_resources()->text_background :
2783 get_resources()->text_background_disarmed);
2784 mask_on_track->update_items();
2785 mask_on_track->update(!track ? "" : track->title);
2786 mask_name->update_items(keyframe);
2787 const char *text = "";
2788 int sz = !keyframe ? 0 : keyframe->masks.size();
2789 int k = mwindow->edl->session->cwindow_mask;
2790 if( k >= 0 && k < sz )
2791 text = keyframe->masks[k]->name;
2793 k = mwindow->edl->session->cwindow_mask = 0;
2794 mask_name->update(text);
2795 update_buttons(keyframe, k);
2797 x->update(point->x);
2798 y->update(point->y);
2801 double position = mwindow->edl->local_session->get_selectionstart(1);
2802 int64_t position_i = track->to_units(position, 0);
2803 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
2804 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
2805 int show_mask = track->masks;
2806 for( int i=0; i<SUBMASKS; ++i )
2807 mask_enables[i]->update((show_mask>>i) & 1);
2810 apply_before_plugins->update(keyframe->apply_before_plugins);
2811 disable_opengl_masking->update(keyframe->disable_opengl_masking);
2813 active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2816 void CWindowMaskGUI::handle_event()
2819 if( event_caller == this->focus_x ||
2820 event_caller == this->focus_y ) {
2823 else if( event_caller == this->x ||
2824 event_caller == this->y ) {
2830 get_keyframe(track, autos, keyframe, mask, point, 0);
2832 mwindow->undo->update_undo_before(_("mask point"), this);
2835 float px = atof(x->get_text());
2836 float py = atof(y->get_text());
2837 float dx = px - point->x, dy = py - point->y;
2838 #ifdef USE_KEYFRAME_SPANNING
2839 // Create temp keyframe
2840 MaskAuto temp_keyframe(mwindow->edl, autos);
2841 temp_keyframe.copy_data(keyframe);
2842 // Get affected point in temp keyframe
2843 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2845 MaskPoints &points = mask->points;
2846 int gang = gang_point->get_value();
2847 int k = mwindow->cwindow->gui->affected_point;
2848 int n = gang ? points.size() : k+1;
2849 for( int i=gang? 0 : k; i<n; ++i ) {
2850 if( i < 0 || i >= points.size() ) continue;
2851 MaskPoint *point = points[i];
2852 point->x += dx; point->y += dy;
2854 #ifdef USE_KEYFRAME_SPANNING
2855 // Commit to spanned keyframes
2856 autos->update_parameter(&temp_keyframe);
2859 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2867 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
2869 CWindowGUI *cgui = mwindow->cwindow->gui;
2870 cgui->unlock_window();
2871 lock_window("CWindowMaskGUI::set_focused");
2873 focus->update(focused = v);
2874 focus_x->update(cx);
2875 focus_y->update(cy);
2877 cgui->lock_window("CWindowCanvas::set_focused");
2880 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
2882 int text_color = get_resources()->default_text_color;
2883 int high_color = get_resources()->button_highlighted;
2884 for( int i=0; i<SUBMASKS; ++i ) {
2885 int color = text_color;
2887 SubMask *submask = keyframe->get_submask(i);
2888 if( submask && submask->points.size() )
2891 mask_blabels[i]->set_color(color);
2892 mask_buttons[i]->update(i==k ? 1 : 0);
2896 // typ=0, this mask, this point
2897 // typ>0, this mask, all points
2898 // typ<0, all masks, all points
2899 // dxy= on? pt[+1]-pt[-1] : dxy=0
2900 int CWindowMaskGUI::smooth_mask(int typ, int on)
2907 #ifdef USE_KEYFRAME_SPANNING
2913 mwindow->undo->update_undo_before(_("mask smooth"), this);
2915 // Get existing keyframe
2916 get_keyframe(track, autos, keyframe,
2917 mask, point, create_it);
2919 #ifdef USE_KEYFRAME_SPANNING
2920 MaskAuto temp_keyframe(mwindow->edl, autos);
2921 temp_keyframe.copy_data(keyframe);
2922 keyframe = &temp_keyframe;
2924 int k = mwindow->edl->session->cwindow_mask;
2925 int n = typ>=0 ? k+1 : keyframe->masks.size();
2926 for( int j=typ<0? 0 : k; j<n; ++j ) {
2927 if( !mask_enables[j]->get_value() ) continue;
2928 SubMask *sub_mask = keyframe->get_submask(j);
2929 MaskPoints &points = sub_mask->points;
2930 int psz = points.size();
2931 if( psz < 3 ) continue;
2932 int l = mwindow->cwindow->gui->affected_point;
2933 if( l > psz ) l = psz;
2934 int m = typ ? psz : l+1;
2935 for( int i=typ ? 0 : l; i<m; ++i ) {
2936 int i0 = i-1, i1 = i+1;
2937 if( i0 < 0 ) i0 = psz-1;
2938 if( i1 >= psz ) i1 = 0;
2939 MaskPoint *p0 = points[i0];
2940 MaskPoint *p = points[i];
2941 MaskPoint *p1 = points[i1];
2942 float dx = !on ? 0 : p1->x - p0->x;
2943 float dy = !on ? 0 : p1->y - p0->y;
2944 p->control_x1 = -dx/4; p->control_y1 = -dy/4;
2945 p->control_x2 = dx/4; p->control_y2 = dy/4;
2948 #ifdef USE_KEYFRAME_SPANNING
2949 autos->update_parameter(keyframe);
2954 mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
2958 int CWindowMaskGUI::save_mask(const char *nm)
2960 int k = mwindow->edl->session->cwindow_mask;
2966 get_keyframe(track, autos, keyframe, mask, point, 0);
2967 if( !track ) return 0;
2968 SubMask *sub_mask = keyframe->get_submask(k);
2969 ArrayList<SubMask *> masks;
2971 int i = masks.size();
2973 if( strcmp(masks[i]->name, nm) ) continue;
2974 masks.remove_object_number(i);
2976 mask = new SubMask(0, -1);
2977 strncpy(mask->name, nm, sizeof(mask->name)-1);
2978 mask->copy_from(*sub_mask, 0);
2981 masks.remove_all_objects();
2985 int CWindowMaskGUI::del_mask(const char *nm)
2987 ArrayList<SubMask *> masks;
2989 int i = masks.size();
2991 if( strcmp(masks[i]->name, nm) ) continue;
2992 masks.remove_object_number(i);
2995 masks.remove_all_objects();
2999 int CWindowMaskGUI::center_mask()
3001 int k = mwindow->edl->session->cwindow_mask;
3007 #ifdef USE_KEYFRAME_SPANNING
3012 get_keyframe(track, autos, keyframe,
3013 mask, point, create_it);
3014 if( !track ) return 0;
3015 mwindow->undo->update_undo_before(_("mask center"), this);
3017 // Get existing keyframe
3018 #ifdef USE_KEYFRAME_SPANNING
3019 MaskAuto temp_keyframe(mwindow->edl, autos);
3020 temp_keyframe.copy_data(keyframe);
3021 keyframe = &temp_keyframe;
3023 SubMask *sub_mask = keyframe->get_submask(k);
3024 MaskPoints &points = sub_mask->points;
3025 int psz = points.size();
3027 float cx = 0, cy = 0;
3028 for( int i=0; i<psz; ++i ) {
3029 MaskPoint *p = points[i];
3030 cx += p->x; cy += p->y;
3032 cx /= psz; cy /= psz;
3033 cx -= mwindow->edl->session->output_w / 2.f;
3034 cy -= mwindow->edl->session->output_h / 2.f;
3035 for( int i=0; i<psz; ++i ) {
3036 MaskPoint *p = points[i];
3037 p->x -= cx; p->y -= cy;
3040 #ifdef USE_KEYFRAME_SPANNING
3041 autos->update_parameter(keyframe);
3044 mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3048 int CWindowMaskGUI::normal_mask()
3050 int k = mwindow->edl->session->cwindow_mask;
3056 #ifdef USE_KEYFRAME_SPANNING
3061 // Get existing keyframe
3062 get_keyframe(track, autos, keyframe,
3063 mask, point, create_it);
3064 if( !track ) return 0;
3065 mwindow->undo->update_undo_before(_("mask normal"), this);
3067 #ifdef USE_KEYFRAME_SPANNING
3068 MaskAuto temp_keyframe(mwindow->edl, autos);
3069 temp_keyframe.copy_data(keyframe);
3070 keyframe = &temp_keyframe;
3072 SubMask *sub_mask = keyframe->get_submask(k);
3073 MaskPoints &points = sub_mask->points;
3074 int psz = points.size();
3075 float cx = 0, cy = 0;
3078 for( int i=0; i<psz; ++i ) {
3079 MaskPoint *p = points[i];
3080 cx += p->x; cy += p->y;
3082 cx /= psz; cy /= psz;
3083 for( int i=0; i<psz; ++i ) {
3084 MaskPoint *p = points[i];
3085 float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3086 double d = sqrt(dx*dx + dy*dy);
3087 if( dr < d ) dr = d;
3091 float out_w = mwindow->edl->session->output_w;
3092 float out_h = mwindow->edl->session->output_h;
3093 float r = bmax(out_w, out_h);
3094 float s = r / (4 * dr * sqrt(2.));
3095 for( int i=0; i<psz; ++i ) {
3096 MaskPoint *p = points[i];
3097 float x = p->x, y = p->y;
3098 p->x = (x-cx) * s + cx;
3099 p->y = (y-cy) * s + cy;
3100 p->control_x1 *= s; p->control_y1 *= s;
3101 p->control_x2 *= s; p->control_y2 *= s;
3104 #ifdef USE_KEYFRAME_SPANNING
3105 autos->update_parameter(keyframe);
3109 mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3114 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3115 : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3117 this->mwindow = mwindow;
3122 CWindowMaskLoadList::~CWindowMaskLoadList()
3127 int CWindowMaskLoadList::handle_event()
3134 #ifdef USE_KEYFRAME_SPANNING
3140 mwindow->undo->update_undo_before(_("mask shape"), this);
3142 // Get existing keyframe
3143 gui->get_keyframe(track, autos, keyframe,
3144 mask, point, create_it);
3145 CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3146 if( track && item ) {
3147 #ifdef USE_KEYFRAME_SPANNING
3148 MaskAuto temp_keyframe(mwindow->edl, autos);
3149 temp_keyframe.copy_data(keyframe);
3150 keyframe = &temp_keyframe;
3151 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3153 ArrayList<SubMask *> masks;
3154 gui->load_masks(masks);
3155 mask->copy_from(*masks[item->id], 0);
3156 masks.remove_all_objects();
3157 #ifdef USE_KEYFRAME_SPANNING
3158 autos->update_parameter(keyframe);
3161 gui->update_preview(1);
3163 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3167 void CWindowMaskLoadList::create_objects()
3169 shape_items.remove_all_objects();
3170 ArrayList<SubMask *> masks;
3171 gui->load_masks(masks);
3172 for( int i=0; i<masks.size(); ++i )
3173 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3174 masks.remove_all_objects();
3175 update(&shape_items, 0, 0, 1);
3178 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3179 CWindowMaskGUI *gui, int x, int y, int w)
3180 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3182 this->mwindow = mwindow;
3184 set_tooltip(_("Load preset"));
3187 int CWindowMaskLoad::handle_event()
3189 gui->mask_load_list->create_objects();
3191 get_abs_cursor(px, py);
3192 return gui->mask_load_list->activate(px, py, 120,160);
3196 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3197 CWindowMaskGUI *gui, int x, int y, int w)
3198 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3200 this->mwindow = mwindow;
3202 set_tooltip(_("Save preset"));
3205 CWindowMaskSave::~CWindowMaskSave()
3209 int CWindowMaskSave::handle_event()
3216 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3219 gui->get_abs_cursor(sx, sy);
3220 if( !gui->preset_dialog )
3221 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3222 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3227 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3230 this->mwindow = mwindow;
3235 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3240 void CWindowMaskPresetDialog::handle_close_event(int result)
3245 void CWindowMaskPresetDialog::handle_done_event(int result)
3247 if( result ) return;
3248 const char *nm = pgui->preset_text->get_text();
3255 BC_Window* CWindowMaskPresetDialog::new_gui()
3257 pgui = new CWindowMaskPresetGUI(this, sx, sy,
3258 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3259 _(PROGRAM_NAME ": Delete Mask"));
3260 pgui->create_objects();
3264 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3267 this->sx = sx; this->sy = sy;
3268 this->keyframe = keyframe;
3272 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3273 int x, int y, const char *title)
3274 : BC_Window(title, x, y, 320, 100, 320, 100, 0, 0, 1)
3276 this->preset_dialog = preset_dialog;
3279 void CWindowMaskPresetGUI::create_objects()
3281 int x = 10, y = 10, pad = 8;
3282 lock_window("CWindowMaskPresetGUI::create_objects");
3284 add_subwindow(title = new BC_Title(x, y,
3285 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3286 int x1 = x + title->get_w() + pad;
3287 int x2 = get_w() - x - pad - x1 -
3288 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3289 CWindowMaskGUI *gui = preset_dialog->gui;
3290 preset_text = new CWindowMaskPresetText(this,
3291 x1, y, x2, 120, gui->mask_name->get_text());
3292 preset_text->create_objects();
3293 preset_text->set_tooltip(_("Mask name"));
3294 preset_text->update_items();
3295 add_subwindow(new BC_OKButton(this));
3296 add_subwindow(new BC_CancelButton(this));
3302 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3303 int x, int y, int w, int h, const char *text)
3304 : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3309 int CWindowMaskPresetText::handle_event()
3311 int k = get_number();
3312 if( k >= 0 && k<mask_items.size() )
3313 update(mask_items[k]->get_text());
3317 void CWindowMaskPresetText::update_items()
3319 mask_items.remove_all_objects();
3320 ArrayList<SubMask *> masks;
3321 pgui->preset_dialog->gui->load_masks(masks);
3322 for( int i=0; i<masks.size(); ++i ) {
3323 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
3324 strncpy(text, masks[i]->name, sizeof(text)-1);
3325 mask_items.append(new CWindowMaskItem(text));
3327 masks.remove_all_objects();
3328 update_list(&mask_items);
3332 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3333 CWindowMaskGUI *gui, int x, int y, int w)
3334 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3336 this->mwindow = mwindow;
3338 set_tooltip(_("Delete preset"));
3341 int CWindowMaskDelete::handle_event()
3344 gui->get_abs_cursor(sx, sy);
3345 if( !gui->preset_dialog )
3346 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3347 gui->preset_dialog->start_dialog(sx, sy, 0);
3352 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3353 CWindowMaskGUI *gui, int x, int y, int w)
3354 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3356 this->mwindow = mwindow;
3358 set_tooltip(_("center mask"));
3361 int CWindowMaskCenter::handle_event()
3363 return gui->center_mask();
3367 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3368 CWindowMaskGUI *gui, int x, int y, int w)
3369 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3371 this->mwindow = mwindow;
3373 set_tooltip(_("normalize mask"));
3376 int CWindowMaskNormal::handle_event()
3378 return gui->normal_mask();
3382 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3383 const char *images, int shape, int x, int y, const char *tip)
3384 : BC_Button(x, y, mwindow->theme->get_image_set(images))
3386 this->mwindow = mwindow;
3388 this->shape = shape;
3392 CWindowMaskShape::~CWindowMaskShape()
3396 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3398 int out_w = mwindow->edl->session->output_w;
3399 int out_h = mwindow->edl->session->output_h;
3400 float cx = out_w/2.f, cy = out_h/2.f;
3401 float r = bmax(cx, cy) / 4.f;
3402 double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3403 float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3405 MaskPoints &points = sub_mask->points;
3406 points.remove_all_objects();
3408 case MASK_SHAPE_SQUARE:
3409 points.append(pt = new MaskPoint());
3410 pt->x = cx - r; pt->y = cy - r;
3411 points.append(pt = new MaskPoint());
3412 pt->x = cx + r; pt->y = cy - r;
3413 points.append(pt = new MaskPoint());
3414 pt->x = cx + r; pt->y = cy + r;
3415 points.append(pt = new MaskPoint());
3416 pt->x = cx - r; pt->y = cy + r;
3418 case MASK_SHAPE_CIRCLE:
3419 points.append(pt = new MaskPoint());
3420 pt->x = cx - r; pt->y = cy - r;
3421 pt->control_x1 = -rc; pt->control_y1 = rc;
3422 pt->control_x2 = rc; pt->control_y2 = -rc;
3423 points.append(pt = new MaskPoint());
3424 pt->x = cx + r; pt->y = cy - r;
3425 pt->control_x1 = -rc; pt->control_y1 = -rc;
3426 pt->control_x2 = rc; pt->control_y2 = rc;
3427 points.append(pt = new MaskPoint());
3428 pt->x = cx + r; pt->y = cy + r;
3429 pt->control_x1 = rc; pt->control_y1 = -rc;
3430 pt->control_x2 = -rc; pt->control_y2 = rc;
3431 points.append(pt = new MaskPoint());
3432 pt->x = cx - r; pt->y = cy + r;
3433 pt->control_x1 = rc; pt->control_y1 = rc;
3434 pt->control_x2 = -rc; pt->control_y2 = -rc;
3436 case MASK_SHAPE_TRIANGLE:
3437 points.append(pt = new MaskPoint());
3438 pt->x = cx + 0; pt->y = cy - r*(sqrt(3.)-1.);
3439 points.append(pt = new MaskPoint());
3440 pt->x = cx + r; pt->y = cy + r;
3441 points.append(pt = new MaskPoint());
3442 pt->x = cx - r; pt->y = cy + r;
3444 case MASK_SHAPE_OVAL:
3445 points.append(pt = new MaskPoint());
3446 pt->x = cx - r; pt->y = cy - r2;
3447 pt->control_x1 = -r2; pt->control_y1 = r4;
3448 pt->control_x2 = r2; pt->control_y2 = -r4;
3449 points.append(pt = new MaskPoint());
3450 pt->x = cx + r; pt->y = cy - r2;
3451 pt->control_x1 = -r2; pt->control_y1 = -r4;
3452 pt->control_x2 = r2; pt->control_y2 = r4;
3453 points.append(pt = new MaskPoint());
3454 pt->x = cx + r; pt->y = cy + r2;
3455 pt->control_x1 = r2; pt->control_y1 = -r4;
3456 pt->control_x2 = -r2; pt->control_y2 = r4;
3457 points.append(pt = new MaskPoint());
3458 pt->x = cx - r; pt->y = cy + r2;
3459 pt->control_x1 = r2; pt->control_y1 = r4;
3460 pt->control_x2 = -r2; pt->control_y2 = -r4;
3465 int CWindowMaskShape::handle_event()
3472 #ifdef USE_KEYFRAME_SPANNING
3478 mwindow->undo->update_undo_before(_("mask shape"), this);
3480 // Get existing keyframe
3481 gui->get_keyframe(track, autos, keyframe,
3482 mask, point, create_it);
3484 #ifdef USE_KEYFRAME_SPANNING
3485 MaskAuto temp_keyframe(mwindow->edl, autos);
3486 temp_keyframe.copy_data(keyframe);
3487 keyframe = &temp_keyframe;
3488 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3491 builtin_shape(shape, mask);
3492 #ifdef USE_KEYFRAME_SPANNING
3493 autos->update_parameter(keyframe);
3496 gui->update_preview(1);
3499 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3503 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3505 char path[BCTEXTLEN];
3506 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3508 fs.complete_path(path);
3510 file.read_from_file(path, 1);
3512 masks.remove_all_objects();
3514 while( !(result = file.read_tag()) ) {
3515 if( file.tag.title_is("MASK") ) {
3516 SubMask *sub_mask = new SubMask(0, -1);
3517 char name[BCTEXTLEN]; name[0] = 0;
3518 file.tag.get_property("NAME", name);
3519 strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3520 sub_mask->load(&file);
3521 masks.append(sub_mask);
3526 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3529 for( int i=0; i<masks.size(); ++i ) {
3530 SubMask *sub_mask = masks[i];
3531 sub_mask->copy(&file);
3533 file.terminate_string();
3535 char path[BCTEXTLEN];
3536 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3538 fs.complete_path(path);
3539 file.write_to_file(path);
3543 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3544 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
3548 CWindowRulerGUI::~CWindowRulerGUI()
3552 void CWindowRulerGUI::create_objects()
3554 int x = 10, y = 10, x1 = 100;
3557 lock_window("CWindowRulerGUI::create_objects");
3558 add_subwindow(title = new BC_Title(x, y, _("Current:")));
3559 add_subwindow(current = new BC_TextBox(x1, y, 200, 1, ""));
3560 y += title->get_h() + 5;
3561 add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3562 add_subwindow(point1 = new BC_TextBox(x1, y, 200, 1, ""));
3563 y += title->get_h() + 5;
3564 add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3565 add_subwindow(point2 = new BC_TextBox(x1, y, 200, 1, ""));
3566 y += title->get_h() + 5;
3567 add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3568 add_subwindow(deltas = new BC_TextBox(x1, y, 200, 1, ""));
3569 y += title->get_h() + 5;
3570 add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3571 add_subwindow(distance = new BC_TextBox(x1, y, 200, 1, ""));
3572 y += title->get_h() + 5;
3573 add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3574 add_subwindow(angle = new BC_TextBox(x1, y, 200, 1, ""));
3575 y += title->get_h() + 10;
3576 char string[BCTEXTLEN];
3578 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3579 0xc2, 0xb0); // degrees utf
3580 add_subwindow(title = new BC_Title(x,
3583 y += title->get_h() + 10;
3584 sprintf(string, _("Press Alt to translate the ruler."));
3585 add_subwindow(title = new BC_Title(x,
3592 void CWindowRulerGUI::update()
3594 char string[BCTEXTLEN];
3595 int cx = mwindow->session->cwindow_output_x;
3596 int cy = mwindow->session->cwindow_output_y;
3597 sprintf(string, "%d, %d", cx, cy);
3598 current->update(string);
3599 double x1 = mwindow->edl->session->ruler_x1;
3600 double y1 = mwindow->edl->session->ruler_y1;
3601 sprintf(string, "%.0f, %.0f", x1, y1);
3602 point1->update(string);
3603 double x2 = mwindow->edl->session->ruler_x2;
3604 double y2 = mwindow->edl->session->ruler_y2;
3605 sprintf(string, "%.0f, %.0f", x2, y2);
3606 point2->update(string);
3607 double dx = x2 - x1, dy = y2 - y1;
3608 sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3609 deltas->update(string);
3610 double d = sqrt(dx*dx + dy*dy);
3611 sprintf(string, _("%0.01f pixels"), d);
3612 distance->update(string);
3613 double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3614 sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3615 angle->update(string);
3618 void CWindowRulerGUI::handle_event()