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 CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
376 : BC_GenericButton(x, y, _("Apply"))
378 this->mwindow = mwindow;
379 this->crop_gui = crop_gui;
381 int CWindowCropApply::handle_event()
383 mwindow->crop_video(crop_gui->crop_mode->mode);
388 int CWindowCropApply::keypress_event()
390 if(get_keypress() == 0xd)
398 const char *CWindowCropOpMode::crop_ops[] = {
404 CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
405 int mode, int x, int y)
406 : BC_PopupMenu(x, y, 140, _(crop_ops[mode]), 1)
408 this->mwindow = mwindow;
409 this->crop_gui = crop_gui;
412 CWindowCropOpMode::~CWindowCropOpMode()
416 void CWindowCropOpMode::create_objects()
418 for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
419 add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
423 int CWindowCropOpMode::handle_event()
425 set_text(_(crop_ops[mode]));
429 CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
436 int CWindowCropOpItem::handle_event()
438 popup->set_text(get_text());
440 return popup->handle_event();
447 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
448 : CWindowToolGUI(mwindow,
450 _(PROGRAM_NAME ": Crop"),
457 CWindowCropGUI::~CWindowCropGUI()
461 void CWindowCropGUI::create_objects()
466 lock_window("CWindowCropGUI::create_objects");
468 int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
469 BC_Title::calculate_h(this, "X")) + 5;
470 add_subwindow(title = new BC_Title(x, y, "X1:"));
471 column1 = MAX(column1, title->get_w());
473 add_subwindow(title = new BC_Title(x, y, _("W:")));
474 column1 = MAX(column1, title->get_w());
476 add_subwindow(new CWindowCropApply(mwindow, this, x, y));
480 x1 = new CWindowCoord(thread->tool_gui, x, y,
481 mwindow->edl->session->crop_x1);
482 x1->create_objects();
483 x1->set_boundaries((int64_t)0, (int64_t)65536);
485 width = new CWindowCoord(thread->tool_gui, x, y,
486 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
487 width->create_objects();
488 width->set_boundaries((int64_t)1, (int64_t)65536);
491 x += x1->get_w() + 10;
494 add_subwindow(title = new BC_Title(x, y, "Y1:"));
495 column2 = MAX(column2, title->get_w());
497 add_subwindow(title = new BC_Title(x, y, _("H:")));
498 column2 = MAX(column2, title->get_w());
503 y1 = new CWindowCoord(thread->tool_gui, x, y,
504 mwindow->edl->session->crop_y1);
505 y1->create_objects();
506 y1->set_boundaries((int64_t)0, (int64_t)65536);
509 height = new CWindowCoord(thread->tool_gui, x, y,
510 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
511 height->create_objects();
512 height->set_boundaries((int64_t)1, (int64_t)65536);
515 add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
516 CROP_REFORMAT, x, y));
517 crop_mode->create_objects();
522 void CWindowCropGUI::handle_event()
525 new_x1 = atol(x1->get_text());
526 new_y1 = atol(y1->get_text());
527 if(new_x1 != mwindow->edl->session->crop_x1)
529 mwindow->edl->session->crop_x2 = new_x1 +
530 mwindow->edl->session->crop_x2 -
531 mwindow->edl->session->crop_x1;
532 mwindow->edl->session->crop_x1 = new_x1;
534 if(new_y1 != mwindow->edl->session->crop_y1)
536 mwindow->edl->session->crop_y2 = new_y1 +
537 mwindow->edl->session->crop_y2 -
538 mwindow->edl->session->crop_y1;
539 mwindow->edl->session->crop_y1 = atol(y1->get_text());
541 mwindow->edl->session->crop_x2 = atol(width->get_text()) +
542 mwindow->edl->session->crop_x1;
543 mwindow->edl->session->crop_y2 = atol(height->get_text()) +
544 mwindow->edl->session->crop_y1;
546 mwindow->cwindow->gui->canvas->redraw(1);
549 void CWindowCropGUI::update()
551 x1->update((int64_t)mwindow->edl->session->crop_x1);
552 y1->update((int64_t)mwindow->edl->session->crop_y1);
553 width->update((int64_t)mwindow->edl->session->crop_x2 -
554 mwindow->edl->session->crop_x1);
555 height->update((int64_t)mwindow->edl->session->crop_y2 -
556 mwindow->edl->session->crop_y1);
560 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
561 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), 220, 290)
565 CWindowEyedropGUI::~CWindowEyedropGUI()
569 void CWindowEyedropGUI::create_objects()
571 int margin = mwindow->theme->widget_border;
574 int x2 = 70, x3 = x2 + 60;
575 lock_window("CWindowEyedropGUI::create_objects");
576 BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
577 add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
578 y += title0->get_h() + margin;
579 add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
580 y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
582 add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
583 y += title1->get_h() + margin;
584 add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
585 y += title2->get_h() + margin;
586 add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
587 y += title3->get_h() + margin;
589 add_subwindow(title4 = new BC_Title(x, y, "Y:"));
590 y += title4->get_h() + margin;
591 add_subwindow(title5 = new BC_Title(x, y, "U:"));
592 y += title5->get_h() + margin;
593 add_subwindow(title6 = new BC_Title(x, y, "V:"));
595 add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
597 radius = new CWindowCoord(this, x2, title7->get_y(),
598 mwindow->edl->session->eyedrop_radius);
599 radius->create_objects();
600 radius->set_boundaries((int64_t)0, (int64_t)255);
602 add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
603 add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
604 add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
605 add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
607 add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
608 add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
609 add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
610 add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
612 y = title6->get_y() + this->v->get_h() + 2*margin;
613 add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
614 y += sample->get_h() + margin;
615 add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
620 void CWindowEyedropGUI::update()
622 char string[BCTEXTLEN];
623 sprintf(string, "%d, %d",
624 thread->gui->eyedrop_x,
625 thread->gui->eyedrop_y);
626 current->update(string);
628 radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
630 LocalSession *local_session = mwindow->edl->local_session;
631 int use_max = local_session->use_max;
632 float r = use_max ? local_session->red_max : local_session->red;
633 float g = use_max ? local_session->green_max : local_session->green;
634 float b = use_max ? local_session->blue_max : local_session->blue;
635 this->red->update(r);
636 this->green->update(g);
637 this->blue->update(b);
639 int rx = 255*r + 0.5; bclamp(rx,0,255);
640 int gx = 255*g + 0.5; bclamp(gx,0,255);
641 int bx = 255*b + 0.5; bclamp(bx,0,255);
642 char rgb_text[BCSTRLEN];
643 sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
644 rgb_hex->update(rgb_text);
647 YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
649 this->u->update(u); u += 0.5;
650 this->v->update(v); v += 0.5;
652 int yx = 255*y + 0.5; bclamp(yx,0,255);
653 int ux = 255*u + 0.5; bclamp(ux,0,255);
654 int vx = 255*v + 0.5; bclamp(vx,0,255);
655 char yuv_text[BCSTRLEN];
656 sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
657 yuv_hex->update(yuv_text);
659 int rgb = (rx << 16) | (gx << 8) | (bx << 0);
660 sample->set_color(rgb);
661 sample->draw_box(0, 0, sample->get_w(), sample->get_h());
662 sample->set_color(BLACK);
663 sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
667 void CWindowEyedropGUI::handle_event()
669 int new_radius = atoi(radius->get_text());
670 if(new_radius != mwindow->edl->session->eyedrop_radius)
672 CWindowGUI *gui = mwindow->cwindow->gui;
673 if(gui->eyedrop_visible)
675 gui->lock_window("CWindowEyedropGUI::handle_event");
678 gui->canvas->do_eyedrop(rerender, 0, 1);
681 mwindow->edl->session->eyedrop_radius = new_radius;
683 if(gui->eyedrop_visible)
687 gui->canvas->do_eyedrop(rerender, 0, 1);
688 gui->unlock_window();
695 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
697 // Configuration for all possible Keyframe Curve Mode toggles
699 FloatAuto::t_mode mode;
705 const _CVD Camera_Crv_Smooth =
709 N_("\"smooth\" Curve on current Camera Keyframes")
711 const _CVD Camera_Crv_Linear =
715 N_("\"linear\" Curve on current Camera Keyframes")
717 const _CVD Projector_Crv_Smooth =
721 N_("\"smooth\" Curve on current Projector Keyframes")
723 const _CVD Projector_Crv_Linear =
727 N_("\"linear\" Curve on current Projector Keyframes")
730 // Implementation Class für Keyframe Curve Mode buttons
732 // This button reflects the state of the "current" keyframe
733 // (the nearest keyframe on the left) for all three automation
734 // lines together. Clicking on this button (re)sets the curve
735 // mode for the three "current" keyframes simultanously, but
736 // never creates a new keyframe.
738 class CWindowCurveToggle : public BC_Toggle
741 CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
742 void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
751 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
752 : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
756 this->mwindow = mwindow;
757 set_tooltip(_(cfg.tooltip));
760 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
762 // the toggle state is only set to ON if all
763 // three automation lines have the same curve mode.
764 // For mixed states the toggle stays off.
765 set_value( x->curve_mode == this->cfg.mode &&
766 y->curve_mode == this->cfg.mode &&
767 z->curve_mode == this->cfg.mode
768 ,true // redraw to show new state
772 int CWindowCurveToggle::handle_event()
774 Track *track = mwindow->cwindow->calculate_affected_track();
776 FloatAuto *x=0, *y=0, *z=0;
777 mwindow->cwindow->calculate_affected_autos(track,
778 &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
779 if( x ) x->change_curve_mode(cfg.mode);
780 if( y ) y->change_curve_mode(cfg.mode);
781 if( z ) z->change_curve_mode(cfg.mode);
784 gui->update_preview();
791 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
792 CWindowEyedropGUI *gui, int x, int y)
793 : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
795 this->mwindow = mwindow;
799 int CWindowEyedropCheckBox::handle_event()
801 mwindow->edl->local_session->use_max = get_value();
808 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
809 : CWindowToolGUI(mwindow,
811 _(PROGRAM_NAME ": Camera"),
816 CWindowCameraGUI::~CWindowCameraGUI()
820 void CWindowCameraGUI::create_objects()
822 int x = 10, y = 10, x1;
823 Track *track = mwindow->cwindow->calculate_affected_track();
824 FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
828 lock_window("CWindowCameraGUI::create_objects");
830 mwindow->cwindow->calculate_affected_autos(track,
831 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
834 add_subwindow(title = new BC_Title(x, y, "X:"));
836 this->x = new CWindowCoord(this, x, y,
837 x_auto ? x_auto->get_value() : (float)0);
838 this->x->create_objects();
843 add_subwindow(title = new BC_Title(x, y, "Y:"));
845 this->y = new CWindowCoord(this, x, y,
846 y_auto ? y_auto->get_value() : (float)0);
847 this->y->create_objects();
850 add_subwindow(title = new BC_Title(x, y, "Z:"));
852 this->z = new CWindowCoord(this, x, y,
853 z_auto ? z_auto->get_value() : (float)1);
854 this->z->create_objects();
855 this->z->set_increment(0.01);
859 add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
860 x1 += button->get_w();
861 add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
862 x1 += button->get_w();
863 add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
865 y += button->get_h();
867 add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
868 x1 += button->get_w();
869 add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
870 x1 += button->get_w();
871 add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
872 // additional Buttons to control the curve mode of the "current" keyframe
873 x1 += button->get_w() + 15;
874 add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
875 x1 += button->get_w();
876 add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
878 // fill in current auto keyframe values, set toggle states.
883 void CWindowCameraGUI::handle_event()
885 FloatAuto *x_auto = 0;
886 FloatAuto *y_auto = 0;
887 FloatAuto *z_auto = 0;
888 Track *track = mwindow->cwindow->calculate_affected_track();
891 mwindow->undo->update_undo_before(_("camera"), this);
892 if(event_caller == x)
894 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
895 track->automation->autos[AUTOMATION_CAMERA_X],
899 x_auto->set_value(atof(x->get_text()));
905 if(event_caller == y)
907 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
908 track->automation->autos[AUTOMATION_CAMERA_Y],
912 y_auto->set_value(atof(y->get_text()));
918 if(event_caller == z)
920 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
921 track->automation->autos[AUTOMATION_CAMERA_Z],
925 float zoom = atof(z->get_text());
926 if(zoom > 100.) zoom = 100.;
928 if(zoom < 0.01) zoom = 0.01;
929 // Doesn't allow user to enter from scratch
930 // if(zoom != atof(z->get_text()))
933 z_auto->set_value(zoom);
934 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
935 mwindow->gui->draw_overlays(1);
936 mwindow->gui->unlock_window();
942 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
946 void CWindowCameraGUI::update()
948 FloatAuto *x_auto = 0;
949 FloatAuto *y_auto = 0;
950 FloatAuto *z_auto = 0;
951 Track *track = mwindow->cwindow->calculate_affected_track();
953 mwindow->cwindow->calculate_affected_autos(track,
954 &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
958 x->update(x_auto->get_value());
960 y->update(y_auto->get_value());
962 float value = z_auto->get_value();
964 thread->gui->lock_window("CWindowCameraGUI::update");
965 thread->gui->composite_panel->cpanel_zoom->update(value);
966 thread->gui->unlock_window();
969 if( x_auto && y_auto && z_auto )
971 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
972 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
979 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
980 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
983 this->mwindow = mwindow;
984 set_tooltip(_("Left justify"));
986 int CWindowCameraLeft::handle_event()
988 FloatAuto *x_auto = 0;
989 FloatAuto *z_auto = 0;
990 Track *track = mwindow->cwindow->calculate_affected_track();
992 mwindow->cwindow->calculate_affected_autos(track,
993 &x_auto, 0, &z_auto, 1, 1, 0, 0);
999 track->get_source_dimensions(
1000 mwindow->edl->local_session->get_selectionstart(1),
1006 mwindow->undo->update_undo_before(_("camera"), 0);
1008 (double)track->track_w / z_auto->get_value() / 2 -
1010 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1012 gui->update_preview();
1020 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1021 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1024 this->mwindow = mwindow;
1025 set_tooltip(_("Center horizontal"));
1027 int CWindowCameraCenter::handle_event()
1029 FloatAuto *x_auto = 0;
1030 Track *track = mwindow->cwindow->calculate_affected_track();
1032 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1033 track->automation->autos[AUTOMATION_CAMERA_X],
1038 mwindow->undo->update_undo_before(_("camera"), 0);
1039 x_auto->set_value(0);
1041 gui->update_preview();
1042 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1049 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1050 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1053 this->mwindow = mwindow;
1054 set_tooltip(_("Right justify"));
1056 int CWindowCameraRight::handle_event()
1058 FloatAuto *x_auto = 0;
1059 FloatAuto *z_auto = 0;
1060 Track *track = mwindow->cwindow->calculate_affected_track();
1062 mwindow->cwindow->calculate_affected_autos(track,
1063 &x_auto, 0, &z_auto, 1, 1, 0, 0);
1066 if(x_auto && z_auto)
1069 track->get_source_dimensions(
1070 mwindow->edl->local_session->get_selectionstart(1),
1076 mwindow->undo->update_undo_before(_("camera"), 0);
1077 x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1080 gui->update_preview();
1081 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1089 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1090 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1093 this->mwindow = mwindow;
1094 set_tooltip(_("Top justify"));
1096 int CWindowCameraTop::handle_event()
1098 FloatAuto *y_auto = 0;
1099 FloatAuto *z_auto = 0;
1100 Track *track = mwindow->cwindow->calculate_affected_track();
1102 mwindow->cwindow->calculate_affected_autos(track,
1103 0, &y_auto, &z_auto, 1, 0, 1, 0);
1106 if(y_auto && z_auto)
1109 track->get_source_dimensions(
1110 mwindow->edl->local_session->get_selectionstart(1),
1116 mwindow->undo->update_undo_before(_("camera"), 0);
1117 y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1120 gui->update_preview();
1121 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1129 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1130 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1133 this->mwindow = mwindow;
1134 set_tooltip(_("Center vertical"));
1136 int CWindowCameraMiddle::handle_event()
1138 FloatAuto *y_auto = 0;
1139 Track *track = mwindow->cwindow->calculate_affected_track();
1141 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1142 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1146 mwindow->undo->update_undo_before(_("camera"), 0);
1147 y_auto->set_value(0);
1149 gui->update_preview();
1150 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1157 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1158 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1161 this->mwindow = mwindow;
1162 set_tooltip(_("Bottom justify"));
1164 int CWindowCameraBottom::handle_event()
1166 FloatAuto *y_auto = 0;
1167 FloatAuto *z_auto = 0;
1168 Track *track = mwindow->cwindow->calculate_affected_track();
1170 mwindow->cwindow->calculate_affected_autos(track,
1171 0, &y_auto, &z_auto, 1, 0, 1, 0);
1174 if(y_auto && z_auto)
1177 track->get_source_dimensions(
1178 mwindow->edl->local_session->get_selectionstart(1),
1184 mwindow->undo->update_undo_before(_("camera"), 0);
1185 y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1188 gui->update_preview();
1189 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1197 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1198 : CWindowToolGUI(mwindow,
1200 _(PROGRAM_NAME ": Projector"),
1205 CWindowProjectorGUI::~CWindowProjectorGUI()
1208 void CWindowProjectorGUI::create_objects()
1210 int x = 10, y = 10, x1;
1211 Track *track = mwindow->cwindow->calculate_affected_track();
1212 FloatAuto *x_auto = 0;
1213 FloatAuto *y_auto = 0;
1214 FloatAuto *z_auto = 0;
1218 lock_window("CWindowProjectorGUI::create_objects");
1220 mwindow->cwindow->calculate_affected_autos(track,
1221 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1224 add_subwindow(title = new BC_Title(x, y, "X:"));
1225 x += title->get_w();
1226 this->x = new CWindowCoord(this, x, y,
1227 x_auto ? x_auto->get_value() : (float)0);
1228 this->x->create_objects();
1231 add_subwindow(title = new BC_Title(x, y, "Y:"));
1232 x += title->get_w();
1233 this->y = new CWindowCoord(this, x, y,
1234 y_auto ? y_auto->get_value() : (float)0);
1235 this->y->create_objects();
1238 add_subwindow(title = new BC_Title(x, y, "Z:"));
1239 x += title->get_w();
1240 this->z = new CWindowCoord(this, x, y,
1241 z_auto ? z_auto->get_value() : (float)1);
1242 this->z->create_objects();
1243 this->z->set_increment(0.01);
1247 add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1248 x1 += button->get_w();
1249 add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1250 x1 += button->get_w();
1251 add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1253 y += button->get_h();
1255 add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1256 x1 += button->get_w();
1257 add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1258 x1 += button->get_w();
1259 add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1261 // additional Buttons to control the curve mode of the "current" keyframe
1262 x1 += button->get_w() + 15;
1263 add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1264 x1 += button->get_w();
1265 add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1267 // fill in current auto keyframe values, set toggle states.
1272 void CWindowProjectorGUI::handle_event()
1274 FloatAuto *x_auto = 0;
1275 FloatAuto *y_auto = 0;
1276 FloatAuto *z_auto = 0;
1277 Track *track = mwindow->cwindow->calculate_affected_track();
1281 mwindow->undo->update_undo_before(_("projector"), this);
1282 if(event_caller == x)
1284 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1285 track->automation->autos[AUTOMATION_PROJECTOR_X],
1289 x_auto->set_value(atof(x->get_text()));
1295 if(event_caller == y)
1297 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1298 track->automation->autos[AUTOMATION_PROJECTOR_Y],
1302 y_auto->set_value(atof(y->get_text()));
1308 if(event_caller == z)
1310 z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1311 track->automation->autos[AUTOMATION_PROJECTOR_Z],
1315 float zoom = atof(z->get_text());
1316 if(zoom > 100.) zoom = 100.;
1317 else if(zoom < 0.01) zoom = 0.01;
1318 // if (zoom != atof(z->get_text()))
1320 z_auto->set_value(zoom);
1322 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1323 mwindow->gui->draw_overlays(1);
1324 mwindow->gui->unlock_window();
1330 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1334 void CWindowProjectorGUI::update()
1336 FloatAuto *x_auto = 0;
1337 FloatAuto *y_auto = 0;
1338 FloatAuto *z_auto = 0;
1339 Track *track = mwindow->cwindow->calculate_affected_track();
1341 mwindow->cwindow->calculate_affected_autos(track,
1342 &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1346 x->update(x_auto->get_value());
1348 y->update(y_auto->get_value());
1350 float value = z_auto->get_value();
1352 thread->gui->lock_window("CWindowProjectorGUI::update");
1353 thread->gui->composite_panel->cpanel_zoom->update(value);
1354 thread->gui->unlock_window();
1357 if( x_auto && y_auto && z_auto )
1359 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1360 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1364 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1365 : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1368 this->mwindow = mwindow;
1369 set_tooltip(_("Left justify"));
1371 int CWindowProjectorLeft::handle_event()
1373 FloatAuto *x_auto = 0;
1374 FloatAuto *z_auto = 0;
1375 Track *track = mwindow->cwindow->calculate_affected_track();
1377 mwindow->cwindow->calculate_affected_autos(track,
1378 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1380 if(x_auto && z_auto)
1382 mwindow->undo->update_undo_before(_("projector"), 0);
1383 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1384 (double)mwindow->edl->session->output_w / 2 );
1386 gui->update_preview();
1387 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1394 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1395 : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1398 this->mwindow = mwindow;
1399 set_tooltip(_("Center horizontal"));
1401 int CWindowProjectorCenter::handle_event()
1403 FloatAuto *x_auto = 0;
1404 Track *track = mwindow->cwindow->calculate_affected_track();
1406 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1407 track->automation->autos[AUTOMATION_PROJECTOR_X],
1412 mwindow->undo->update_undo_before(_("projector"), 0);
1413 x_auto->set_value(0);
1415 gui->update_preview();
1416 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1423 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1424 : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1427 this->mwindow = mwindow;
1428 set_tooltip(_("Right justify"));
1430 int CWindowProjectorRight::handle_event()
1432 FloatAuto *x_auto = 0;
1433 FloatAuto *z_auto = 0;
1434 Track *track = mwindow->cwindow->calculate_affected_track();
1436 mwindow->cwindow->calculate_affected_autos(track,
1437 &x_auto, 0, &z_auto, 0, 1, 0, 0);
1440 if(x_auto && z_auto)
1442 mwindow->undo->update_undo_before(_("projector"), 0);
1443 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1444 (double)mwindow->edl->session->output_w / 2));
1446 gui->update_preview();
1447 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1454 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1455 : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1458 this->mwindow = mwindow;
1459 set_tooltip(_("Top justify"));
1461 int CWindowProjectorTop::handle_event()
1463 FloatAuto *y_auto = 0;
1464 FloatAuto *z_auto = 0;
1465 Track *track = mwindow->cwindow->calculate_affected_track();
1467 mwindow->cwindow->calculate_affected_autos(track,
1468 0, &y_auto, &z_auto, 0, 0, 1, 0);
1471 if(y_auto && z_auto)
1473 mwindow->undo->update_undo_before(_("projector"), 0);
1474 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1475 (double)mwindow->edl->session->output_h / 2 );
1477 gui->update_preview();
1478 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1485 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1486 : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1489 this->mwindow = mwindow;
1490 set_tooltip(_("Center vertical"));
1492 int CWindowProjectorMiddle::handle_event()
1494 FloatAuto *y_auto = 0;
1495 Track *track = mwindow->cwindow->calculate_affected_track();
1497 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1498 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1502 mwindow->undo->update_undo_before(_("projector"), 0);
1503 y_auto->set_value(0);
1505 gui->update_preview();
1506 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1513 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1514 : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1517 this->mwindow = mwindow;
1518 set_tooltip(_("Bottom justify"));
1520 int CWindowProjectorBottom::handle_event()
1522 FloatAuto *y_auto = 0;
1523 FloatAuto *z_auto = 0;
1524 Track *track = mwindow->cwindow->calculate_affected_track();
1526 mwindow->cwindow->calculate_affected_autos(track,
1527 0, &y_auto, &z_auto, 0, 0, 1, 0);
1530 if(y_auto && z_auto)
1532 mwindow->undo->update_undo_before(_("projector"), 0);
1533 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1534 (double)mwindow->edl->session->output_h / 2));
1536 gui->update_preview();
1537 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1544 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1545 int x, int y, int w, const char *text)
1546 : BC_PopupTextBox(gui, 0, text, x, y, w, 120)
1548 this->mwindow = mwindow;
1552 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1556 int CWindowMaskOnTrack::handle_event()
1558 CWindowMaskItem *track_item = 0;
1559 int k = get_number(), track_id = -1;
1560 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1562 track_item = (CWindowMaskItem *)track_items[k];
1563 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1564 if( track && track->record ) track_id = track->get_id();
1567 track_id = mwindow->cwindow->mask_track_id;
1568 set_back_color(track_id >= 0 ?
1569 gui->get_resources()->text_background :
1570 gui->get_resources()->text_background_disarmed);
1571 if( mwindow->cwindow->mask_track_id != track_id )
1572 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1573 mwindow->cwindow->mask_track_id = track_id;
1574 mwindow->edl->local_session->solo_track_id = -1;
1575 gui->mask_solo_track->update(0);
1577 gui->update_preview(1);
1581 void CWindowMaskOnTrack::update_items()
1583 track_items.remove_all_objects();
1584 int high_color = gui->get_resources()->button_highlighted;
1585 for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1586 if( track->data_type != TRACK_VIDEO ) continue;
1587 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1588 int color = !track->record ? RED : mask_autos->first ? high_color : -1;
1589 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1590 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1591 if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1592 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1594 update_list(&track_items);
1597 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1601 this->mwindow = mwindow;
1604 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1608 int CWindowMaskTrackTumbler::handle_up_event()
1613 int CWindowMaskTrackTumbler::handle_down_event()
1615 return do_event(-1);
1618 int CWindowMaskTrackTumbler::do_event(int dir)
1620 CWindowMaskItem *track_item = 0;
1621 CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1622 int n = gui->mask_on_track->track_items.size();
1623 int id = mwindow->cwindow->mask_track_id;
1626 while( --k >= 0 && items[k]->id != id );
1630 track_item = items[k];
1633 track_item = items[0];
1635 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1636 int track_id = track_item && track && track->record ? track_item->id : -1;
1637 gui->mask_on_track->set_back_color(track_id >= 0 ?
1638 gui->get_resources()->text_background :
1639 gui->get_resources()->text_background_disarmed);
1640 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1641 mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1642 mwindow->edl->local_session->solo_track_id = -1;
1643 gui->mask_solo_track->update(0);
1645 gui->update_preview(1);
1650 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1651 int x, int y, const char *text)
1652 : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
1654 this->mwindow = mwindow;
1658 CWindowMaskName::~CWindowMaskName()
1662 int CWindowMaskName::handle_event()
1669 //printf("CWindowMaskGUI::update 1\n");
1670 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1672 int k = get_number();
1673 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1674 else mwindow->edl->session->cwindow_mask = k;
1675 if( k >= 0 && k < mask_items.size() ) {
1676 mask_items[k]->set_text(get_text());
1677 update_list(&mask_items);
1679 #ifdef USE_KEYFRAME_SPANNING
1680 MaskAuto temp_keyframe(mwindow->edl, autos);
1681 temp_keyframe.copy_data(keyframe);
1682 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1683 memset(submask->name, 0, sizeof(submask->name));
1684 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1685 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1687 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1688 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1689 memset(submask->name, 0, sizeof(submask->name));
1690 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1691 current = current == (MaskAuto*)autos->default_auto ?
1692 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1696 gui->update_preview();
1701 void CWindowMaskName::update_items(MaskAuto *keyframe)
1703 mask_items.remove_all_objects();
1704 int sz = !keyframe ? 0 : keyframe->masks.size();
1705 for( int i=0; i<SUBMASKS; ++i ) {
1706 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
1708 SubMask *sub_mask = keyframe->masks.get(i);
1709 strncpy(text, sub_mask->name, sizeof(text)-1);
1712 sprintf(text, "%d", i);
1713 mask_items.append(new CWindowMaskItem(text));
1715 update_list(&mask_items);
1719 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1720 int x, int y, int no, int v)
1721 : BC_CheckBox(x, y, v)
1723 this->mwindow = mwindow;
1728 CWindowMaskButton::~CWindowMaskButton()
1732 int CWindowMaskButton::handle_event()
1734 mwindow->edl->session->cwindow_mask = no;
1735 gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1737 gui->update_preview();
1741 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1745 this->mwindow = mwindow;
1749 CWindowMaskThumbler::~CWindowMaskThumbler()
1753 int CWindowMaskThumbler::handle_up_event()
1758 int CWindowMaskThumbler::handle_down_event()
1760 return do_event(-1);
1763 int CWindowMaskThumbler::do_event(int dir)
1765 int k = mwindow->edl->session->cwindow_mask;
1766 if( (k+=dir) >= SUBMASKS ) k = 0;
1767 else if( k < 0 ) k = SUBMASKS-1;
1768 mwindow->edl->session->cwindow_mask = k;
1769 gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1771 gui->update_preview();
1775 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1776 int x, int y, int no, int v)
1777 : BC_CheckBox(x, y, v)
1779 this->mwindow = mwindow;
1784 CWindowMaskEnable::~CWindowMaskEnable()
1788 int CWindowMaskEnable::handle_event()
1790 Track *track = mwindow->cwindow->calculate_mask_track();
1792 mwindow->undo->update_undo_before(_("mask enable"), this);
1795 track->masks |= bit;
1797 track->masks &= ~bit;
1799 gui->update_preview(1);
1800 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1805 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1806 CWindowMaskGUI *gui, int x, int y)
1807 : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1809 this->mwindow = mwindow;
1811 set_tooltip(_("Show/Hide mask"));
1814 int CWindowMaskUnclear::handle_event()
1816 Track *track = mwindow->cwindow->calculate_mask_track();
1818 mwindow->undo->update_undo_before(_("mask enables"), this);
1819 int m = (1<<SUBMASKS)-1;
1820 if( track->masks == m )
1824 for( int i=0; i<SUBMASKS; ++i )
1825 gui->mask_enables[i]->update((track->masks>>i) & 1);
1826 gui->update_preview(1);
1827 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
1832 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
1833 CWindowMaskGUI *gui, int x, int y, int v)
1834 : BC_CheckBox(x, y, v, _("Solo"))
1836 this->mwindow = mwindow;
1838 set_tooltip(_("Solo video track"));
1841 int CWindowMaskSoloTrack::handle_event()
1843 mwindow->edl->local_session->solo_track_id =
1844 get_value() ? mwindow->cwindow->mask_track_id : -1;
1845 gui->update_preview(1);
1849 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
1852 calculate_extents(gui, &w, &h, _("Solo"));
1856 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
1857 CWindowMaskGUI *gui, int x, int y)
1858 : BC_GenericButton(x, y, _("Delete"))
1860 this->mwindow = mwindow;
1862 set_tooltip(_("Delete mask"));
1865 int CWindowMaskDelMask::handle_event()
1874 // Get existing keyframe
1875 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1878 mwindow->undo->update_undo_before(_("mask delete"), 0);
1880 #ifdef USE_KEYFRAME_SPANNING
1881 // Create temp keyframe
1882 MaskAuto temp_keyframe(mwindow->edl, autos);
1883 temp_keyframe.copy_data(keyframe);
1884 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1885 submask->points.remove_all_objects();
1887 // Commit change to span of keyframes
1888 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1890 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1891 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1892 submask->points.remove_all_objects();
1893 current = current == (MaskAuto*)autos->default_auto ?
1894 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1898 if( mwindow->cwindow->gui->affected_point >= total_points )
1899 mwindow->cwindow->gui->affected_point =
1900 total_points > 0 ? total_points-1 : 0;
1903 gui->update_preview();
1904 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1910 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
1911 CWindowMaskGUI *gui, int x, int y)
1912 : BC_GenericButton(x, y, _("Delete"))
1914 this->mwindow = mwindow;
1916 set_tooltip(_("Delete point"));
1919 int CWindowMaskDelPoint::handle_event()
1928 // Get existing keyframe
1929 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1931 mwindow->undo->update_undo_before(_("point delete"), 0);
1933 #ifdef USE_KEYFRAME_SPANNING
1934 // Create temp keyframe
1935 MaskAuto temp_keyframe(mwindow->edl, autos);
1936 temp_keyframe.copy_data(keyframe);
1938 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1939 int i = mwindow->cwindow->gui->affected_point;
1940 for( ; i<submask->points.total-1; ++i )
1941 *submask->points.values[i] = *submask->points.values[i+1];
1942 if( submask->points.total > 0 ) {
1943 point = submask->points.values[submask->points.total-1];
1944 submask->points.remove_object(point);
1946 total_points = submask->points.total;
1948 // Commit change to span of keyframes
1949 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1952 MaskAuto *current = (MaskAuto*)autos->default_auto;
1954 SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1955 int i = mwindow->cwindow->gui->affected_point;
1956 for( ; i<submask->points.total-1; ++i )
1957 *submask->points.values[i] = *submask->points.values[i+1];
1958 if( submask->points.total > 0 ) {
1959 point = submask->points.values[submask->points.total-1];
1960 submask->points.remove_object(point);
1962 total_points = submask->points.total;
1963 current = current == (MaskAuto*)autos->default_auto ?
1964 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1967 if( mwindow->cwindow->gui->affected_point >= total_points )
1968 mwindow->cwindow->gui->affected_point =
1969 total_points > 0 ? total_points-1 : 0;
1972 gui->update_preview();
1973 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
1980 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
1981 CWindowMaskGUI *gui, int x, int y)
1982 : BC_TumbleTextBox(gui,
1983 (int64_t)mwindow->cwindow->gui->affected_point,
1984 (int64_t)0, INT64_MAX, x, y, 70)
1986 this->mwindow = mwindow;
1990 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
1994 int CWindowMaskAffectedPoint::handle_event()
1996 int total_points = 0;
1997 int affected_point = atol(get_text());
1998 Track *track = mwindow->cwindow->calculate_mask_track();
2000 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2001 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
2003 SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2004 total_points = mask->points.size();
2007 int active_point = affected_point;
2008 if( affected_point >= total_points )
2009 affected_point = total_points - 1;
2010 if( affected_point < 0 )
2012 if( active_point != affected_point )
2013 update((int64_t)affected_point);
2014 mwindow->cwindow->gui->affected_point = affected_point;
2016 gui->update_preview();
2021 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2022 : BC_CheckBox(x, y, gui->focused, _("Focus"))
2024 this->mwindow = mwindow;
2026 set_tooltip(_("Center for rotate/scale"));
2029 CWindowMaskFocus::~CWindowMaskFocus()
2033 int CWindowMaskFocus::handle_event()
2035 gui->focused = get_value();
2037 gui->update_preview();
2041 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
2044 calculate_extents(gui, &w, &h, _("Focus"));
2048 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
2049 int x, int y, VFrame **data, int v, int id, const char *tip)
2050 : BC_Toggle(x, y, data, v)
2053 this->mwindow = mwindow;
2058 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2062 int CWindowMaskScaleXY::handle_event()
2064 gui->scale_mode = id;
2065 gui->mask_scale_x->update(id == MASK_SCALE_X);
2066 gui->mask_scale_y->update(id == MASK_SCALE_Y);
2067 gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2071 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2072 : BC_CheckBox(x, y, 0, _("Help"))
2074 this->mwindow = mwindow;
2076 set_tooltip(_("Show help text"));
2079 CWindowMaskHelp::~CWindowMaskHelp()
2083 int CWindowMaskHelp::handle_event()
2085 gui->helped = get_value();
2086 gui->resize_window(gui->get_w(),
2087 gui->helped ? gui->help_h : gui->help_y);
2092 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2093 : BC_CheckBox(x, y, gui->markers, _("Markers"))
2095 this->mwindow = mwindow;
2097 set_tooltip("Display points");
2100 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2104 int CWindowMaskDrawMarkers::handle_event()
2106 gui->markers = get_value();
2108 gui->update_preview();
2112 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2113 : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2115 this->mwindow = mwindow;
2117 set_tooltip("Display mask outline");
2120 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2124 int CWindowMaskDrawBoundary::handle_event()
2126 gui->boundary = get_value();
2128 gui->update_preview();
2133 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2134 : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, 64, 2)
2136 this->mwindow = mwindow;
2139 CWindowMaskFeather::~CWindowMaskFeather()
2143 int CWindowMaskFeather::update(float v)
2145 gui->feather_slider->update(v);
2146 return BC_TumbleTextBox::update(v);
2149 int CWindowMaskFeather::update_value(float v)
2156 #ifdef USE_KEYFRAME_SPANNING
2162 mwindow->undo->update_undo_before(_("mask feather"), this);
2164 // Get existing keyframe
2165 gui->get_keyframe(track, autos, keyframe,
2166 mask, point, create_it);
2168 int gang = gui->gang_feather->get_value();
2169 #ifdef USE_KEYFRAME_SPANNING
2170 MaskAuto temp_keyframe(mwindow->edl, autos);
2171 temp_keyframe.copy_data(keyframe);
2172 keyframe = &temp_keyframe;
2174 float change = v - mask->feather;
2175 int k = mwindow->edl->session->cwindow_mask;
2176 int n = gang ? keyframe->masks.size() : k+1;
2177 for( int i=gang? 0 : k; i<n; ++i ) {
2178 if( !gui->mask_enables[i]->get_value() ) continue;
2179 SubMask *sub_mask = keyframe->get_submask(i);
2180 float feather = sub_mask->feather + change;
2181 sub_mask->feather = feather;
2183 #ifdef USE_KEYFRAME_SPANNING
2184 autos->update_parameter(keyframe);
2186 gui->update_preview();
2189 mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2193 int CWindowMaskFeather::handle_event()
2195 float v = atof(get_text());
2196 if( fabsf(v) > MAX_FEATHER )
2197 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2198 gui->feather_slider->update(v);
2199 return gui->feather->update_value(v);
2202 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2203 CWindowMaskGUI *gui, int x, int y, int w, float v)
2204 : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2206 this->mwindow = mwindow;
2208 set_precision(0.01);
2209 timer = new Timer();
2215 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2220 int CWindowMaskFeatherSlider::handle_event()
2223 float v = get_value();
2224 if( fabsf(v) > MAX_FEATHER )
2225 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2226 if( stick && timer->get_difference() >= 250 )
2227 stick = 0; // no events for .25 sec
2228 if( stick && (last_v * (v-last_v)) < 0 )
2229 stick = 0; // dv changed direction
2238 if( max > MAX_FEATHER ) max = MAX_FEATHER;
2239 update(get_w(), v=last_v, -max-5, max+5);
2240 button_release_event();
2243 else if( v > max ) { v = max; sticky = 24; }
2244 else if( v < -max ) { v = -max; sticky = 24; }
2245 else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0; sticky = 16; }
2246 if( sticky ) { update(v); stick = sticky; timer->update(); }
2248 gui->feather->BC_TumbleTextBox::update(v);
2249 return gui->feather->update_value(v);
2252 int CWindowMaskFeatherSlider::update(float v)
2254 float vv = fabsf(v);
2255 if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2256 while( max < vv ) max *= 1.25;
2257 return update(get_w(), v, -max-5, max+5);
2259 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2261 return BC_FSlider::update(r, v, mn, mx);
2264 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2265 : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
2267 this->mwindow = mwindow;
2270 CWindowMaskFade::~CWindowMaskFade()
2274 int CWindowMaskFade::update(float v)
2276 gui->fade_slider->update(v);
2277 return BC_TumbleTextBox::update(v);
2280 int CWindowMaskFade::update_value(float v)
2287 #ifdef USE_KEYFRAME_SPANNING
2293 mwindow->undo->update_undo_before(_("mask fade"), this);
2295 // Get existing keyframe
2296 gui->get_keyframe(track, autos, keyframe,
2297 mask, point, create_it);
2299 int gang = gui->gang_fader->get_value();
2300 #ifdef USE_KEYFRAME_SPANNING
2301 MaskAuto temp_keyframe(mwindow->edl, autos);
2302 temp_keyframe.copy_data(keyframe);
2303 keyframe = &temp_keyframe;
2305 float change = v - mask->fader;
2306 int k = mwindow->edl->session->cwindow_mask;
2307 int n = gang ? keyframe->masks.size() : k+1;
2308 for( int i=gang? 0 : k; i<n; ++i ) {
2309 if( !gui->mask_enables[i]->get_value() ) continue;
2310 SubMask *sub_mask = keyframe->get_submask(i);
2311 float fader = sub_mask->fader + change;
2312 bclamp(fader, -100.f, 100.f);
2313 sub_mask->fader = fader;
2315 #ifdef USE_KEYFRAME_SPANNING
2316 autos->update_parameter(keyframe);
2318 gui->update_preview();
2321 mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2325 int CWindowMaskFade::handle_event()
2327 float v = atof(get_text());
2328 gui->fade_slider->update(v);
2329 return gui->fade->update_value(v);
2332 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2333 int x, int y, int w)
2334 : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2336 this->mwindow = mwindow;
2338 timer = new Timer();
2343 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2348 int CWindowMaskFadeSlider::handle_event()
2350 float v = 100*get_value()/200;
2352 int64_t ms = timer->get_difference();
2353 if( ms < 250 && --stick > 0 ) {
2354 if( get_value() == 0 ) return 1;
2362 else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2369 gui->fade->BC_TumbleTextBox::update(v);
2370 return gui->fade->update_value(v);
2373 int CWindowMaskFadeSlider::update(int64_t v)
2375 return BC_ISlider::update(200*v/100);
2378 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2379 CWindowMaskGUI *gui, int x, int y)
2380 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2382 this->mwindow = mwindow;
2384 set_tooltip(_("Gang fader"));
2387 CWindowMaskGangFader::~CWindowMaskGangFader()
2391 int CWindowMaskGangFader::handle_event()
2396 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2397 CWindowMaskGUI *gui, int x, int y)
2398 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2400 this->mwindow = mwindow;
2402 set_tooltip(_("Gang rotate/scale/translate"));
2405 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2409 int CWindowMaskGangFocus::handle_event()
2414 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2415 CWindowMaskGUI *gui, int x, int y)
2416 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2418 this->mwindow = mwindow;
2420 set_tooltip(_("Gang points"));
2423 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2427 int CWindowMaskGangPoint::handle_event()
2433 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2434 const char *tip, int type, int on, int x, int y, const char *images)
2435 : BC_Button(x, y, mwindow->theme->get_image_set(images))
2437 this->mwindow = mwindow;
2444 int CWindowMaskSmoothButton::handle_event()
2446 return gui->smooth_mask(type, on);
2449 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2450 : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2455 int CWindowMaskBeforePlugins::handle_event()
2462 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2465 int v = get_value();
2466 #ifdef USE_KEYFRAME_SPANNING
2467 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2468 temp_keyframe.copy_data(keyframe);
2469 temp_keyframe.apply_before_plugins = v;
2470 autos->update_parameter(&temp_keyframe);
2472 keyframe->apply_before_plugins = v;
2474 gui->update_preview();
2480 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2481 : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2486 int CWindowDisableOpenGLMasking::handle_event()
2493 gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2496 int v = get_value();
2497 #ifdef USE_KEYFRAME_SPANNING
2498 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2499 temp_keyframe.copy_data(keyframe);
2500 temp_keyframe.disable_opengl_masking = v;
2501 autos->update_parameter(&temp_keyframe);
2503 keyframe->disable_opengl_masking = v;
2505 gui->update_preview();
2511 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2512 CWindowMaskGUI *gui, int x, int y)
2513 : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2515 this->mwindow = mwindow;
2517 set_tooltip(_("Delete all masks"));
2520 CWindowMaskClrMask::~CWindowMaskClrMask()
2524 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2526 VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2527 return vfrm->get_w();
2530 int CWindowMaskClrMask::handle_event()
2538 // Get existing keyframe
2539 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2542 mwindow->undo->update_undo_before(_("del masks"), 0);
2543 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2544 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2548 gui->update_preview(1);
2552 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2553 CWindowMaskGUI *gui, int x, int y)
2554 : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2556 this->mwindow = mwindow;
2558 set_tooltip(_("Gang feather"));
2561 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2565 int CWindowMaskGangFeather::handle_event()
2570 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2571 : CWindowToolGUI(mwindow, thread,
2572 _(PROGRAM_NAME ": Mask"), 440, 700)
2574 this->mwindow = mwindow;
2575 this->thread = thread;
2585 CWindowMaskGUI::~CWindowMaskGUI()
2587 lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2589 delete active_point;
2593 delete preset_dialog;
2596 void CWindowMaskGUI::create_objects()
2598 Theme *theme = mwindow->theme;
2599 int x = 10, y = 10, margin = theme->widget_border, t[SUBMASKS];
2600 int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2601 int clr_x = get_w()-x - clr_w;
2603 lock_window("CWindowMaskGUI::create_objects");
2604 BC_TitleBar *title_bar;
2605 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks on Track")));
2606 y += title_bar->get_h() + margin;
2608 add_subwindow(title = new BC_Title(x,y, _("Track:")));
2609 int x1 = x + 90, ww = clr_x-2*margin - x1;
2610 for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2612 Track *track = mwindow->cwindow->calculate_affected_track();
2613 const char *text = track ? track->title : "";
2614 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2615 mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, 100, text);
2616 mask_on_track->create_objects();
2617 mask_on_track->set_tooltip(_("Video track"));
2618 int x2 = x1 + mask_on_track->get_w();
2619 add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2620 mwindow->edl->local_session->solo_track_id = -1;
2621 add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2622 y += mask_on_track->get_h() + margin;
2623 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Masks")));
2624 y += title_bar->get_h() + margin;
2625 add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2626 mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2627 mask_name->create_objects();
2628 mask_name->set_tooltip(_("Mask name"));
2629 add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2630 add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2631 y += mask_name->get_h() + 2*margin;
2633 // add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2634 // y += bar->get_h() + 2*margin;
2636 add_subwindow(title = new BC_Title(x, y, _("Select:")));
2638 BC_CheckBox::calculate_extents(this, &bw, &bh);
2639 for( int i=0; i<SUBMASKS; ++i ) {
2640 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2641 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2642 add_subwindow(mask_buttons[i]);
2644 add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2646 for( int i=0; i<SUBMASKS; ++i ) {
2647 char text[BCSTRLEN]; sprintf(text, "%d", i);
2648 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2649 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2650 add_subwindow(mask_blabels[i]);
2652 y += mask_blabels[0]->get_h() + margin;
2653 add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2654 for( int i=0; i<SUBMASKS; ++i ) {
2655 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2656 add_subwindow(mask_enables[i]);
2658 add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2659 y += mask_enables[0]->get_h() + 2*margin;
2660 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Preset Shapes")));
2661 y += title_bar->get_h() + margin;
2662 add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2663 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2664 add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2665 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2666 add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2667 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2668 add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2669 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2670 add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2671 add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, 80));
2672 add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, 80));
2673 add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, 80));
2674 y += mask_load->get_h() + 2*margin;
2675 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Position & Scale")));
2676 y += title_bar->get_h() + 2*margin;
2677 add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, 80));
2678 add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, 80));
2680 add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2681 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2682 add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2683 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2684 add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2685 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2686 y += mask_center->get_h() + 2*margin;
2687 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Fade & Feather")));
2688 y += title_bar->get_h() + 2*margin;
2690 add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2691 fade = new CWindowMaskFade(mwindow, this, x1, y);
2692 fade->create_objects();
2693 x2 = x1 + fade->get_w() + 2*margin;
2694 int w2 = clr_x-2*margin - x2;
2695 add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2696 add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2697 y += fade->get_h() + margin;
2698 add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2699 feather = new CWindowMaskFeather(mwindow, this, x1, y);
2700 feather->create_objects();
2701 w2 = clr_x - 2*margin - x2;
2702 feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2703 add_subwindow(feather_slider);
2704 add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2705 y += feather->get_h() + 2*margin;
2706 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Mask Points")));
2707 y += title_bar->get_h() + margin;
2709 add_subwindow(title = new BC_Title(x, y, _("Point:")));
2710 active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2711 active_point->create_objects();
2712 // typ=0, this mask, this point
2713 add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2714 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2715 add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2716 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2717 add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2718 add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2719 y += active_point->get_h() + margin;
2720 add_subwindow(title = new BC_Title(x, y, "X:"));
2721 this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2722 this->x->create_objects();
2723 // typ>0, this mask, all points
2724 add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2725 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2726 add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2727 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2728 add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2729 y += this->x->get_h() + margin;
2730 add_subwindow(title = new BC_Title(x, y, "Y:"));
2731 this->y = new CWindowCoord(this, x1, y, (float)0.0);
2732 this->y->create_objects();
2733 // typ<0, all masks, all points
2734 add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2735 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2736 add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2737 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2738 add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2739 y += this->y->get_h() + 2*margin;
2740 add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, 20, 10, _("Pivot Point")));
2741 y += title_bar->get_h() + margin;
2743 add_subwindow(title = new BC_Title(x, y, "X:"));
2744 float cx = mwindow->edl->session->output_w / 2.f;
2745 focus_x = new CWindowCoord(this, x1, y, cx);
2746 focus_x->create_objects();
2747 add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2748 add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2749 y += focus_x->get_h() + margin;
2750 add_subwindow(title = new BC_Title(x, y, "Y:"));
2751 float cy = mwindow->edl->session->output_h / 2.f;
2752 focus_y = new CWindowCoord(this, x1, y, cy);
2753 focus_y->create_objects();
2754 y += focus_y->get_h() + 2*margin;
2755 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2756 y += bar->get_h() + margin;
2757 add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
2758 y += this->apply_before_plugins->get_h();
2759 add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
2760 add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2761 y += this->disable_opengl_masking->get_h() + 2*margin;
2763 add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2764 y += bar->get_h() + 2*margin;
2765 add_subwindow(title = new BC_Title(x, y, _(
2766 "Shift+LMB: move an end point\n"
2767 "Ctrl+LMB: move a control point\n"
2768 "Alt+LMB: to drag translate the mask\n"
2769 "Shift+MMB: Set Pivot Point at pointer\n"
2770 "Wheel: rotate around Pivot Point\n"
2771 "Shift+Wheel: scale around Pivot Point\n"
2772 "Ctrl+Wheel: rotate/scale around pointer")));
2773 help_h = y + title->get_h() + 2*margin;
2775 resize_window(get_w(), help_y);
2779 int CWindowMaskGUI::close_event()
2782 return CWindowToolGUI::close_event();
2785 void CWindowMaskGUI::done_event()
2787 if( mwindow->in_destructor ) return;
2788 int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2789 if( solo_track_id >= 0 ) {
2795 void CWindowMaskGUI::get_keyframe(Track* &track,
2796 MaskAutos* &autos, MaskAuto* &keyframe,
2797 SubMask* &mask, MaskPoint* &point, int create_it)
2802 track = mwindow->cwindow->calculate_mask_track();
2804 track = mwindow->cwindow->calculate_affected_track();
2807 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2808 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2813 mask = !keyframe ? 0 :
2814 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2818 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
2819 mwindow->cwindow->gui->affected_point >= 0 ) {
2820 point = mask->points.values[mwindow->cwindow->gui->affected_point];
2825 void CWindowMaskGUI::update()
2832 //printf("CWindowMaskGUI::update 1\n");
2833 get_keyframe(track, autos, keyframe, mask, point, 0);
2834 mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2835 mask_on_track->set_back_color(!track || track->record ?
2836 get_resources()->text_background :
2837 get_resources()->text_background_disarmed);
2838 mask_on_track->update_items();
2839 mask_on_track->update(!track ? "" : track->title);
2840 mask_name->update_items(keyframe);
2841 const char *text = "";
2842 int sz = !keyframe ? 0 : keyframe->masks.size();
2843 int k = mwindow->edl->session->cwindow_mask;
2844 if( k >= 0 && k < sz )
2845 text = keyframe->masks[k]->name;
2847 k = mwindow->edl->session->cwindow_mask = 0;
2848 mask_name->update(text);
2849 update_buttons(keyframe, k);
2851 x->update(point->x);
2852 y->update(point->y);
2855 double position = mwindow->edl->local_session->get_selectionstart(1);
2856 int64_t position_i = track->to_units(position, 0);
2857 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
2858 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
2859 int show_mask = track->masks;
2860 for( int i=0; i<SUBMASKS; ++i )
2861 mask_enables[i]->update((show_mask>>i) & 1);
2864 apply_before_plugins->update(keyframe->apply_before_plugins);
2865 disable_opengl_masking->update(keyframe->disable_opengl_masking);
2867 active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2870 void CWindowMaskGUI::handle_event()
2873 if( event_caller == this->focus_x ||
2874 event_caller == this->focus_y ) {
2877 else if( event_caller == this->x ||
2878 event_caller == this->y ) {
2884 get_keyframe(track, autos, keyframe, mask, point, 0);
2886 mwindow->undo->update_undo_before(_("mask point"), this);
2889 float px = atof(x->get_text());
2890 float py = atof(y->get_text());
2891 float dx = px - point->x, dy = py - point->y;
2892 #ifdef USE_KEYFRAME_SPANNING
2893 // Create temp keyframe
2894 MaskAuto temp_keyframe(mwindow->edl, autos);
2895 temp_keyframe.copy_data(keyframe);
2896 // Get affected point in temp keyframe
2897 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2899 MaskPoints &points = mask->points;
2900 int gang = gang_point->get_value();
2901 int k = mwindow->cwindow->gui->affected_point;
2902 int n = gang ? points.size() : k+1;
2903 for( int i=gang? 0 : k; i<n; ++i ) {
2904 if( i < 0 || i >= points.size() ) continue;
2905 MaskPoint *point = points[i];
2906 point->x += dx; point->y += dy;
2908 #ifdef USE_KEYFRAME_SPANNING
2909 // Commit to spanned keyframes
2910 autos->update_parameter(&temp_keyframe);
2913 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2921 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
2923 CWindowGUI *cgui = mwindow->cwindow->gui;
2924 cgui->unlock_window();
2925 lock_window("CWindowMaskGUI::set_focused");
2927 focus->update(focused = v);
2928 focus_x->update(cx);
2929 focus_y->update(cy);
2931 cgui->lock_window("CWindowCanvas::set_focused");
2934 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
2936 int text_color = get_resources()->default_text_color;
2937 int high_color = get_resources()->button_highlighted;
2938 for( int i=0; i<SUBMASKS; ++i ) {
2939 int color = text_color;
2941 SubMask *submask = keyframe->get_submask(i);
2942 if( submask && submask->points.size() )
2945 mask_blabels[i]->set_color(color);
2946 mask_buttons[i]->update(i==k ? 1 : 0);
2950 // typ=0, this mask, this point
2951 // typ>0, this mask, all points
2952 // typ<0, all masks, all points
2953 // dxy= on? pt[+1]-pt[-1] : dxy=0
2954 int CWindowMaskGUI::smooth_mask(int typ, int on)
2961 #ifdef USE_KEYFRAME_SPANNING
2967 mwindow->undo->update_undo_before(_("mask smooth"), this);
2969 // Get existing keyframe
2970 get_keyframe(track, autos, keyframe,
2971 mask, point, create_it);
2973 #ifdef USE_KEYFRAME_SPANNING
2974 MaskAuto temp_keyframe(mwindow->edl, autos);
2975 temp_keyframe.copy_data(keyframe);
2976 keyframe = &temp_keyframe;
2978 int k = mwindow->edl->session->cwindow_mask;
2979 int n = typ>=0 ? k+1 : keyframe->masks.size();
2980 for( int j=typ<0? 0 : k; j<n; ++j ) {
2981 if( !mask_enables[j]->get_value() ) continue;
2982 SubMask *sub_mask = keyframe->get_submask(j);
2983 MaskPoints &points = sub_mask->points;
2984 int psz = points.size();
2985 if( psz < 3 ) continue;
2986 int l = mwindow->cwindow->gui->affected_point;
2987 if( l > psz ) l = psz;
2988 int m = typ ? psz : l+1;
2989 for( int i=typ ? 0 : l; i<m; ++i ) {
2990 int i0 = i-1, i1 = i+1;
2991 if( i0 < 0 ) i0 = psz-1;
2992 if( i1 >= psz ) i1 = 0;
2993 MaskPoint *p0 = points[i0];
2994 MaskPoint *p = points[i];
2995 MaskPoint *p1 = points[i1];
2996 float dx = !on ? 0 : p1->x - p0->x;
2997 float dy = !on ? 0 : p1->y - p0->y;
2998 p->control_x1 = -dx/4; p->control_y1 = -dy/4;
2999 p->control_x2 = dx/4; p->control_y2 = dy/4;
3002 #ifdef USE_KEYFRAME_SPANNING
3003 autos->update_parameter(keyframe);
3008 mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
3012 int CWindowMaskGUI::save_mask(const char *nm)
3014 int k = mwindow->edl->session->cwindow_mask;
3020 get_keyframe(track, autos, keyframe, mask, point, 0);
3021 if( !track ) return 0;
3022 SubMask *sub_mask = keyframe->get_submask(k);
3023 ArrayList<SubMask *> masks;
3025 int i = masks.size();
3027 if( strcmp(masks[i]->name, nm) ) continue;
3028 masks.remove_object_number(i);
3030 mask = new SubMask(0, -1);
3031 strncpy(mask->name, nm, sizeof(mask->name)-1);
3032 mask->copy_from(*sub_mask, 0);
3035 masks.remove_all_objects();
3039 int CWindowMaskGUI::del_mask(const char *nm)
3041 ArrayList<SubMask *> masks;
3043 int i = masks.size();
3045 if( strcmp(masks[i]->name, nm) ) continue;
3046 masks.remove_object_number(i);
3049 masks.remove_all_objects();
3053 int CWindowMaskGUI::center_mask()
3055 int k = mwindow->edl->session->cwindow_mask;
3061 #ifdef USE_KEYFRAME_SPANNING
3066 get_keyframe(track, autos, keyframe,
3067 mask, point, create_it);
3068 if( !track ) return 0;
3069 mwindow->undo->update_undo_before(_("mask center"), this);
3071 // Get existing keyframe
3072 #ifdef USE_KEYFRAME_SPANNING
3073 MaskAuto temp_keyframe(mwindow->edl, autos);
3074 temp_keyframe.copy_data(keyframe);
3075 keyframe = &temp_keyframe;
3077 SubMask *sub_mask = keyframe->get_submask(k);
3078 MaskPoints &points = sub_mask->points;
3079 int psz = points.size();
3081 float cx = 0, cy = 0;
3082 for( int i=0; i<psz; ++i ) {
3083 MaskPoint *p = points[i];
3084 cx += p->x; cy += p->y;
3086 cx /= psz; cy /= psz;
3087 cx -= mwindow->edl->session->output_w / 2.f;
3088 cy -= mwindow->edl->session->output_h / 2.f;
3089 for( int i=0; i<psz; ++i ) {
3090 MaskPoint *p = points[i];
3091 p->x -= cx; p->y -= cy;
3094 #ifdef USE_KEYFRAME_SPANNING
3095 autos->update_parameter(keyframe);
3098 mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3102 int CWindowMaskGUI::normal_mask()
3104 int k = mwindow->edl->session->cwindow_mask;
3110 #ifdef USE_KEYFRAME_SPANNING
3115 // Get existing keyframe
3116 get_keyframe(track, autos, keyframe,
3117 mask, point, create_it);
3118 if( !track ) return 0;
3119 mwindow->undo->update_undo_before(_("mask normal"), this);
3121 #ifdef USE_KEYFRAME_SPANNING
3122 MaskAuto temp_keyframe(mwindow->edl, autos);
3123 temp_keyframe.copy_data(keyframe);
3124 keyframe = &temp_keyframe;
3126 SubMask *sub_mask = keyframe->get_submask(k);
3127 MaskPoints &points = sub_mask->points;
3128 int psz = points.size();
3129 float cx = 0, cy = 0;
3132 for( int i=0; i<psz; ++i ) {
3133 MaskPoint *p = points[i];
3134 cx += p->x; cy += p->y;
3136 cx /= psz; cy /= psz;
3137 for( int i=0; i<psz; ++i ) {
3138 MaskPoint *p = points[i];
3139 float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3140 double d = sqrt(dx*dx + dy*dy);
3141 if( dr < d ) dr = d;
3145 float out_w = mwindow->edl->session->output_w;
3146 float out_h = mwindow->edl->session->output_h;
3147 float r = bmax(out_w, out_h);
3148 float s = r / (4 * dr * sqrt(2.));
3149 for( int i=0; i<psz; ++i ) {
3150 MaskPoint *p = points[i];
3151 float x = p->x, y = p->y;
3152 p->x = (x-cx) * s + cx;
3153 p->y = (y-cy) * s + cy;
3154 p->control_x1 *= s; p->control_y1 *= s;
3155 p->control_x2 *= s; p->control_y2 *= s;
3158 #ifdef USE_KEYFRAME_SPANNING
3159 autos->update_parameter(keyframe);
3163 mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3168 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3169 : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3171 this->mwindow = mwindow;
3176 CWindowMaskLoadList::~CWindowMaskLoadList()
3181 int CWindowMaskLoadList::handle_event()
3188 #ifdef USE_KEYFRAME_SPANNING
3194 mwindow->undo->update_undo_before(_("mask shape"), this);
3196 // Get existing keyframe
3197 gui->get_keyframe(track, autos, keyframe,
3198 mask, point, create_it);
3199 CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3200 if( track && item ) {
3201 #ifdef USE_KEYFRAME_SPANNING
3202 MaskAuto temp_keyframe(mwindow->edl, autos);
3203 temp_keyframe.copy_data(keyframe);
3204 keyframe = &temp_keyframe;
3205 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3207 ArrayList<SubMask *> masks;
3208 gui->load_masks(masks);
3209 mask->copy_from(*masks[item->id], 0);
3210 masks.remove_all_objects();
3211 #ifdef USE_KEYFRAME_SPANNING
3212 autos->update_parameter(keyframe);
3215 gui->update_preview(1);
3217 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3221 void CWindowMaskLoadList::create_objects()
3223 shape_items.remove_all_objects();
3224 ArrayList<SubMask *> masks;
3225 gui->load_masks(masks);
3226 for( int i=0; i<masks.size(); ++i )
3227 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3228 masks.remove_all_objects();
3229 update(&shape_items, 0, 0, 1);
3232 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3233 CWindowMaskGUI *gui, int x, int y, int w)
3234 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3236 this->mwindow = mwindow;
3238 set_tooltip(_("Load preset"));
3241 int CWindowMaskLoad::handle_event()
3243 gui->mask_load_list->create_objects();
3245 get_abs_cursor(px, py);
3246 return gui->mask_load_list->activate(px, py, 120,160);
3250 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3251 CWindowMaskGUI *gui, int x, int y, int w)
3252 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3254 this->mwindow = mwindow;
3256 set_tooltip(_("Save preset"));
3259 CWindowMaskSave::~CWindowMaskSave()
3263 int CWindowMaskSave::handle_event()
3270 gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3273 gui->get_abs_cursor(sx, sy);
3274 if( !gui->preset_dialog )
3275 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3276 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3281 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3284 this->mwindow = mwindow;
3289 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3294 void CWindowMaskPresetDialog::handle_close_event(int result)
3299 void CWindowMaskPresetDialog::handle_done_event(int result)
3301 if( result ) return;
3302 const char *nm = pgui->preset_text->get_text();
3309 BC_Window* CWindowMaskPresetDialog::new_gui()
3311 pgui = new CWindowMaskPresetGUI(this, sx, sy,
3312 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3313 _(PROGRAM_NAME ": Delete Mask"));
3314 pgui->create_objects();
3318 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3321 this->sx = sx; this->sy = sy;
3322 this->keyframe = keyframe;
3326 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3327 int x, int y, const char *title)
3328 : BC_Window(title, x, y, 320, 100, 320, 100, 0, 0, 1)
3330 this->preset_dialog = preset_dialog;
3333 void CWindowMaskPresetGUI::create_objects()
3335 int x = 10, y = 10, pad = 8;
3336 lock_window("CWindowMaskPresetGUI::create_objects");
3338 add_subwindow(title = new BC_Title(x, y,
3339 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3340 int x1 = x + title->get_w() + pad;
3341 int x2 = get_w() - x - pad - x1 -
3342 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3343 CWindowMaskGUI *gui = preset_dialog->gui;
3344 preset_text = new CWindowMaskPresetText(this,
3345 x1, y, x2, 120, gui->mask_name->get_text());
3346 preset_text->create_objects();
3347 preset_text->set_tooltip(_("Mask name"));
3348 preset_text->update_items();
3349 add_subwindow(new BC_OKButton(this));
3350 add_subwindow(new BC_CancelButton(this));
3356 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3357 int x, int y, int w, int h, const char *text)
3358 : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3363 int CWindowMaskPresetText::handle_event()
3365 int k = get_number();
3366 if( k >= 0 && k<mask_items.size() )
3367 update(mask_items[k]->get_text());
3371 void CWindowMaskPresetText::update_items()
3373 mask_items.remove_all_objects();
3374 ArrayList<SubMask *> masks;
3375 pgui->preset_dialog->gui->load_masks(masks);
3376 for( int i=0; i<masks.size(); ++i ) {
3377 char text[BCSTRLEN]; memset(text, 0, sizeof(text));
3378 strncpy(text, masks[i]->name, sizeof(text)-1);
3379 mask_items.append(new CWindowMaskItem(text));
3381 masks.remove_all_objects();
3382 update_list(&mask_items);
3386 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3387 CWindowMaskGUI *gui, int x, int y, int w)
3388 : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3390 this->mwindow = mwindow;
3392 set_tooltip(_("Delete preset"));
3395 int CWindowMaskDelete::handle_event()
3398 gui->get_abs_cursor(sx, sy);
3399 if( !gui->preset_dialog )
3400 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3401 gui->preset_dialog->start_dialog(sx, sy, 0);
3406 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3407 CWindowMaskGUI *gui, int x, int y, int w)
3408 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3410 this->mwindow = mwindow;
3412 set_tooltip(_("center mask"));
3415 int CWindowMaskCenter::handle_event()
3417 return gui->center_mask();
3421 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3422 CWindowMaskGUI *gui, int x, int y, int w)
3423 : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3425 this->mwindow = mwindow;
3427 set_tooltip(_("normalize mask"));
3430 int CWindowMaskNormal::handle_event()
3432 return gui->normal_mask();
3436 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3437 const char *images, int shape, int x, int y, const char *tip)
3438 : BC_Button(x, y, mwindow->theme->get_image_set(images))
3440 this->mwindow = mwindow;
3442 this->shape = shape;
3446 CWindowMaskShape::~CWindowMaskShape()
3450 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3452 int out_w = mwindow->edl->session->output_w;
3453 int out_h = mwindow->edl->session->output_h;
3454 float cx = out_w/2.f, cy = out_h/2.f;
3455 float r = bmax(cx, cy) / 4.f;
3456 double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3457 float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3459 MaskPoints &points = sub_mask->points;
3460 points.remove_all_objects();
3462 case MASK_SHAPE_SQUARE:
3463 points.append(pt = new MaskPoint());
3464 pt->x = cx - r; pt->y = cy - r;
3465 points.append(pt = new MaskPoint());
3466 pt->x = cx + r; pt->y = cy - r;
3467 points.append(pt = new MaskPoint());
3468 pt->x = cx + r; pt->y = cy + r;
3469 points.append(pt = new MaskPoint());
3470 pt->x = cx - r; pt->y = cy + r;
3472 case MASK_SHAPE_CIRCLE:
3473 points.append(pt = new MaskPoint());
3474 pt->x = cx - r; pt->y = cy - r;
3475 pt->control_x1 = -rc; pt->control_y1 = rc;
3476 pt->control_x2 = rc; pt->control_y2 = -rc;
3477 points.append(pt = new MaskPoint());
3478 pt->x = cx + r; pt->y = cy - r;
3479 pt->control_x1 = -rc; pt->control_y1 = -rc;
3480 pt->control_x2 = rc; pt->control_y2 = rc;
3481 points.append(pt = new MaskPoint());
3482 pt->x = cx + r; pt->y = cy + r;
3483 pt->control_x1 = rc; pt->control_y1 = -rc;
3484 pt->control_x2 = -rc; pt->control_y2 = rc;
3485 points.append(pt = new MaskPoint());
3486 pt->x = cx - r; pt->y = cy + r;
3487 pt->control_x1 = rc; pt->control_y1 = rc;
3488 pt->control_x2 = -rc; pt->control_y2 = -rc;
3490 case MASK_SHAPE_TRIANGLE:
3491 points.append(pt = new MaskPoint());
3492 pt->x = cx + 0; pt->y = cy - r*(sqrt(3.)-1.);
3493 points.append(pt = new MaskPoint());
3494 pt->x = cx + r; pt->y = cy + r;
3495 points.append(pt = new MaskPoint());
3496 pt->x = cx - r; pt->y = cy + r;
3498 case MASK_SHAPE_OVAL:
3499 points.append(pt = new MaskPoint());
3500 pt->x = cx - r; pt->y = cy - r2;
3501 pt->control_x1 = -r2; pt->control_y1 = r4;
3502 pt->control_x2 = r2; pt->control_y2 = -r4;
3503 points.append(pt = new MaskPoint());
3504 pt->x = cx + r; pt->y = cy - r2;
3505 pt->control_x1 = -r2; pt->control_y1 = -r4;
3506 pt->control_x2 = r2; pt->control_y2 = r4;
3507 points.append(pt = new MaskPoint());
3508 pt->x = cx + r; pt->y = cy + r2;
3509 pt->control_x1 = r2; pt->control_y1 = -r4;
3510 pt->control_x2 = -r2; pt->control_y2 = r4;
3511 points.append(pt = new MaskPoint());
3512 pt->x = cx - r; pt->y = cy + r2;
3513 pt->control_x1 = r2; pt->control_y1 = r4;
3514 pt->control_x2 = -r2; pt->control_y2 = -r4;
3519 int CWindowMaskShape::handle_event()
3526 #ifdef USE_KEYFRAME_SPANNING
3532 mwindow->undo->update_undo_before(_("mask shape"), this);
3534 // Get existing keyframe
3535 gui->get_keyframe(track, autos, keyframe,
3536 mask, point, create_it);
3538 #ifdef USE_KEYFRAME_SPANNING
3539 MaskAuto temp_keyframe(mwindow->edl, autos);
3540 temp_keyframe.copy_data(keyframe);
3541 keyframe = &temp_keyframe;
3542 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3545 builtin_shape(shape, mask);
3546 #ifdef USE_KEYFRAME_SPANNING
3547 autos->update_parameter(keyframe);
3550 gui->update_preview(1);
3553 mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3557 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3559 char path[BCTEXTLEN];
3560 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3562 fs.complete_path(path);
3564 file.read_from_file(path, 1);
3566 masks.remove_all_objects();
3568 while( !(result = file.read_tag()) ) {
3569 if( file.tag.title_is("MASK") ) {
3570 SubMask *sub_mask = new SubMask(0, -1);
3571 char name[BCTEXTLEN]; name[0] = 0;
3572 file.tag.get_property("NAME", name);
3573 strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3574 sub_mask->load(&file);
3575 masks.append(sub_mask);
3580 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3583 for( int i=0; i<masks.size(); ++i ) {
3584 SubMask *sub_mask = masks[i];
3585 sub_mask->copy(&file);
3587 file.terminate_string();
3589 char path[BCTEXTLEN];
3590 sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3592 fs.complete_path(path);
3593 file.write_to_file(path);
3597 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3598 : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
3602 CWindowRulerGUI::~CWindowRulerGUI()
3606 void CWindowRulerGUI::create_objects()
3608 int x = 10, y = 10, x1 = 100;
3611 lock_window("CWindowRulerGUI::create_objects");
3612 add_subwindow(title = new BC_Title(x, y, _("Current:")));
3613 add_subwindow(current = new BC_TextBox(x1, y, 200, 1, ""));
3614 y += title->get_h() + 5;
3615 add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3616 add_subwindow(point1 = new BC_TextBox(x1, y, 200, 1, ""));
3617 y += title->get_h() + 5;
3618 add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3619 add_subwindow(point2 = new BC_TextBox(x1, y, 200, 1, ""));
3620 y += title->get_h() + 5;
3621 add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3622 add_subwindow(deltas = new BC_TextBox(x1, y, 200, 1, ""));
3623 y += title->get_h() + 5;
3624 add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3625 add_subwindow(distance = new BC_TextBox(x1, y, 200, 1, ""));
3626 y += title->get_h() + 5;
3627 add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3628 add_subwindow(angle = new BC_TextBox(x1, y, 200, 1, ""));
3629 y += title->get_h() + 10;
3630 char string[BCTEXTLEN];
3632 _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3633 0xc2, 0xb0); // degrees utf
3634 add_subwindow(title = new BC_Title(x,
3637 y += title->get_h() + 10;
3638 sprintf(string, _("Press Alt to translate the ruler."));
3639 add_subwindow(title = new BC_Title(x,
3646 void CWindowRulerGUI::update()
3648 char string[BCTEXTLEN];
3649 int cx = mwindow->session->cwindow_output_x;
3650 int cy = mwindow->session->cwindow_output_y;
3651 sprintf(string, "%d, %d", cx, cy);
3652 current->update(string);
3653 double x1 = mwindow->edl->session->ruler_x1;
3654 double y1 = mwindow->edl->session->ruler_y1;
3655 sprintf(string, "%.0f, %.0f", x1, y1);
3656 point1->update(string);
3657 double x2 = mwindow->edl->session->ruler_x2;
3658 double y2 = mwindow->edl->session->ruler_y2;
3659 sprintf(string, "%.0f, %.0f", x2, y2);
3660 point2->update(string);
3661 double dx = x2 - x1, dy = y2 - y1;
3662 sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3663 deltas->update(string);
3664 double d = sqrt(dx*dx + dy*dy);
3665 sprintf(string, _("%0.01f pixels"), d);
3666 distance->update(string);
3667 double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3668 sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3669 angle->update(string);
3672 void CWindowRulerGUI::handle_event()