2ef53fa9041d13b51f35f4af6b5ddd748775fe12
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / cwindowtool.C
1 /*
2  * CINELERRA
3  * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
4  *
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.
9  *
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.
14  *
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
18  *
19  */
20
21 #include <stdio.h>
22 #include <stdint.h>
23
24 #include "automation.h"
25 #include "bccolors.h"
26 #include "bctimer.h"
27 #include "clip.h"
28 #include "condition.h"
29 #include "cpanel.h"
30 #include "cplayback.h"
31 #include "cwindow.h"
32 #include "cwindowgui.h"
33 #include "cwindowtool.h"
34 #include "edl.h"
35 #include "edlsession.h"
36 #include "floatauto.h"
37 #include "floatautos.h"
38 #include "keys.h"
39 #include "language.h"
40 #include "localsession.h"
41 #include "mainsession.h"
42 #include "mainundo.h"
43 #include "maskauto.h"
44 #include "maskautos.h"
45 #include "mutex.h"
46 #include "mwindow.h"
47 #include "mwindowgui.h"
48 #include "theme.h"
49 #include "track.h"
50 #include "trackcanvas.h"
51 #include "transportque.h"
52
53
54 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
55  : Thread(1, 0, 0)
56 {
57         this->mwindow = mwindow;
58         this->gui = gui;
59         tool_gui = 0;
60         done = 0;
61         current_tool = CWINDOW_NONE;
62         set_synchronous(1);
63         input_lock = new Condition(0, "CWindowTool::input_lock");
64         output_lock = new Condition(1, "CWindowTool::output_lock");
65         tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
66 }
67
68 CWindowTool::~CWindowTool()
69 {
70         done = 1;
71         stop_tool();
72         input_lock->unlock();
73         Thread::join();
74         delete input_lock;
75         delete output_lock;
76         delete tool_gui_lock;
77 }
78
79 void CWindowTool::start_tool(int operation)
80 {
81         CWindowToolGUI *new_gui = 0;
82         int result = 0;
83
84 //printf("CWindowTool::start_tool 1\n");
85         if(current_tool != operation)
86         {
87                 int previous_tool = current_tool;
88                 current_tool = operation;
89                 switch(operation)
90                 {
91                         case CWINDOW_EYEDROP:
92                                 new_gui = new CWindowEyedropGUI(mwindow, this);
93                                 break;
94                         case CWINDOW_CROP:
95                                 new_gui = new CWindowCropGUI(mwindow, this);
96                                 break;
97                         case CWINDOW_CAMERA:
98                                 new_gui = new CWindowCameraGUI(mwindow, this);
99                                 break;
100                         case CWINDOW_PROJECTOR:
101                                 new_gui = new CWindowProjectorGUI(mwindow, this);
102                                 break;
103                         case CWINDOW_MASK:
104                                 new_gui = new CWindowMaskGUI(mwindow, this);
105                                 break;
106                         case CWINDOW_RULER:
107                                 new_gui = new CWindowRulerGUI(mwindow, this);
108                                 break;
109                         case CWINDOW_PROTECT:
110                                 mwindow->edl->session->tool_window = 0;
111                                 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(0);
112                                 // fall thru
113                         default:
114                                 result = 1;
115                                 stop_tool();
116                                 break;
117                 }
118
119 //printf("CWindowTool::start_tool 1\n");
120
121
122                 if(!result)
123                 {
124                         stop_tool();
125 // Wait for previous tool GUI to finish
126                         output_lock->lock("CWindowTool::start_tool");
127                         this->tool_gui = new_gui;
128                         tool_gui->create_objects();
129                         if( previous_tool == CWINDOW_PROTECT || previous_tool == CWINDOW_NONE ) {
130                                 mwindow->edl->session->tool_window = 1;
131                                 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
132                         }
133                         update_show_window();
134
135 // Signal thread to run next tool GUI
136                         input_lock->unlock();
137                 }
138 //printf("CWindowTool::start_tool 1\n");
139         }
140         else
141         if(tool_gui)
142         {
143                 tool_gui->lock_window("CWindowTool::start_tool");
144                 tool_gui->update();
145                 tool_gui->unlock_window();
146         }
147
148 //printf("CWindowTool::start_tool 2\n");
149
150 }
151
152
153 void CWindowTool::stop_tool()
154 {
155         if(tool_gui)
156         {
157                 tool_gui->lock_window("CWindowTool::stop_tool");
158                 tool_gui->set_done(0);
159                 tool_gui->unlock_window();
160         }
161 }
162
163 void CWindowTool::show_tool()
164 {
165         if(tool_gui && mwindow->edl->session->tool_window)
166         {
167                 tool_gui->lock_window("CWindowTool::show_tool");
168                 tool_gui->show_window();
169                 tool_gui->unlock_window();
170         }
171 }
172
173 void CWindowTool::hide_tool()
174 {
175         if(tool_gui && mwindow->edl->session->tool_window)
176         {
177                 tool_gui->lock_window("CWindowTool::show_tool");
178                 tool_gui->hide_window();
179                 tool_gui->unlock_window();
180         }
181 }
182
183
184 void CWindowTool::run()
185 {
186         while(!done)
187         {
188                 input_lock->lock("CWindowTool::run");
189                 if(!done)
190                 {
191                         tool_gui->run_window();
192                         tool_gui_lock->lock("CWindowTool::run");
193                         delete tool_gui;
194                         tool_gui = 0;
195                         tool_gui_lock->unlock();
196                 }
197                 output_lock->unlock();
198         }
199 }
200
201 void CWindowTool::update_show_window()
202 {
203         if(tool_gui)
204         {
205                 tool_gui->lock_window("CWindowTool::update_show_window");
206
207                 if(mwindow->edl->session->tool_window)
208                 {
209                         tool_gui->update();
210                         tool_gui->show_window();
211                 }
212                 else
213                         tool_gui->hide_window();
214                 tool_gui->flush();
215
216                 tool_gui->unlock_window();
217         }
218 }
219
220 void CWindowTool::raise_window()
221 {
222         if(tool_gui)
223         {
224                 gui->unlock_window();
225                 tool_gui->lock_window("CWindowTool::raise_window");
226                 tool_gui->raise_window();
227                 tool_gui->unlock_window();
228                 gui->lock_window("CWindowTool::raise_window");
229         }
230 }
231
232 void CWindowTool::update_values()
233 {
234         tool_gui_lock->lock("CWindowTool::update_values");
235         if(tool_gui)
236         {
237                 tool_gui->lock_window("CWindowTool::update_values");
238                 tool_gui->update();
239                 tool_gui->flush();
240                 tool_gui->unlock_window();
241         }
242         tool_gui_lock->unlock();
243 }
244
245
246
247
248
249
250
251 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
252         CWindowTool *thread,
253         const char *title,
254         int w,
255         int h)
256  : BC_Window(title,
257         mwindow->session->ctool_x,
258         mwindow->session->ctool_y,
259         w,
260         h,
261         w,
262         h,
263         0,
264         0,
265         1)
266 {
267         this->mwindow = mwindow;
268         this->thread = thread;
269         current_operation = 0;
270 }
271
272 CWindowToolGUI::~CWindowToolGUI()
273 {
274 }
275
276 int CWindowToolGUI::close_event()
277 {
278         hide_window();
279         flush();
280         mwindow->edl->session->tool_window = 0;
281         unlock_window();
282
283
284
285         thread->gui->lock_window("CWindowToolGUI::close_event");
286         thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
287         thread->gui->flush();
288         thread->gui->unlock_window();
289
290         lock_window("CWindowToolGUI::close_event");
291         return 1;
292 ;}
293
294 int CWindowToolGUI::keypress_event()
295 {
296         int result = 0;
297
298         switch( get_keypress() ) {
299         case 'w':
300         case 'W':
301                 return close_event();
302         case KEY_F1:
303         case KEY_F2:
304         case KEY_F3:
305         case KEY_F4:
306         case KEY_F5:
307         case KEY_F6:
308         case KEY_F7:
309         case KEY_F8:
310         case KEY_F9:
311         case KEY_F10:
312         case KEY_F11:
313         case KEY_F12:
314                 resend_event(thread->gui);
315                 result = 1;
316         }
317
318         return result;
319 }
320
321 int CWindowToolGUI::translation_event()
322 {
323         mwindow->session->ctool_x = get_x();
324         mwindow->session->ctool_y = get_y();
325         return 0;
326 }
327
328
329
330
331
332
333 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
334  : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 100, 3)
335 {
336         this->gui = gui;
337         set_log_floatincrement(log_increment);
338 }
339
340 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
341  : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 100, 3)
342 {
343         this->gui = gui;
344 }
345 int CWindowCoord::handle_event()
346 {
347         gui->event_caller = this;
348         gui->handle_event();
349         return 1;
350 }
351
352
353 CWindowCropOK::CWindowCropOK(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
354  : BC_GenericButton(x, y, _("Do it"))
355 {
356         this->mwindow = mwindow;
357         this->gui = gui;
358 }
359 int CWindowCropOK::handle_event()
360 {
361         mwindow->crop_video();
362         return 1;
363 }
364
365
366 int CWindowCropOK::keypress_event()
367 {
368         if(get_keypress() == 0xd)
369         {
370                 handle_event();
371                 return 1;
372         }
373         return 0;
374 }
375
376
377
378
379
380
381
382 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
383  : CWindowToolGUI(mwindow,
384         thread,
385         _(PROGRAM_NAME ": Crop"),
386         330,
387         100)
388 {
389 }
390
391
392 CWindowCropGUI::~CWindowCropGUI()
393 {
394 }
395
396 void CWindowCropGUI::create_objects()
397 {
398         int x = 10, y = 10;
399         BC_Title *title;
400
401         lock_window("CWindowCropGUI::create_objects");
402         int column1 = 0;
403         int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
404                 BC_Title::calculate_h(this, "X")) + 5;
405         add_subwindow(title = new BC_Title(x, y, "X1:"));
406         column1 = MAX(column1, title->get_w());
407         y += pad;
408         add_subwindow(title = new BC_Title(x, y, _("W:")));
409         column1 = MAX(column1, title->get_w());
410         y += pad;
411         add_subwindow(new CWindowCropOK(mwindow, thread->tool_gui, x, y));
412
413         x += column1 + 5;
414         y = 10;
415         x1 = new CWindowCoord(thread->tool_gui, x, y,
416                 mwindow->edl->session->crop_x1);
417         x1->create_objects();
418         y += pad;
419         width = new CWindowCoord(thread->tool_gui, x, y,
420                 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
421         width->create_objects();
422
423
424         x += x1->get_w() + 10;
425         y = 10;
426         int column2 = 0;
427         add_subwindow(title = new BC_Title(x, y, "Y1:"));
428         column2 = MAX(column2, title->get_w());
429         y += pad;
430         add_subwindow(title = new BC_Title(x, y, _("H:")));
431         column2 = MAX(column2, title->get_w());
432         y += pad;
433
434         y = 10;
435         x += column2 + 5;
436         y1 = new CWindowCoord(thread->tool_gui, x, y,
437                 mwindow->edl->session->crop_y1);
438         y1->create_objects();
439         y += pad;
440         height = new CWindowCoord(thread->tool_gui, x, y,
441                 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
442         height->create_objects();
443         unlock_window();
444 }
445
446 void CWindowCropGUI::handle_event()
447 {
448         int new_x1, new_y1;
449         new_x1 = atol(x1->get_text());
450         new_y1 = atol(y1->get_text());
451         if(new_x1 != mwindow->edl->session->crop_x1)
452         {
453                 mwindow->edl->session->crop_x2 = new_x1 +
454                         mwindow->edl->session->crop_x2 -
455                         mwindow->edl->session->crop_x1;
456                 mwindow->edl->session->crop_x1 = new_x1;
457         }
458         if(new_y1 != mwindow->edl->session->crop_y1)
459         {
460                 mwindow->edl->session->crop_y2 = new_y1 +
461                         mwindow->edl->session->crop_y2 -
462                         mwindow->edl->session->crop_y1;
463                 mwindow->edl->session->crop_y1 = atol(y1->get_text());
464         }
465         mwindow->edl->session->crop_x2 = atol(width->get_text()) +
466                 mwindow->edl->session->crop_x1;
467         mwindow->edl->session->crop_y2 = atol(height->get_text()) +
468                 mwindow->edl->session->crop_y1;
469         update();
470         mwindow->cwindow->gui->canvas->redraw(1);
471 }
472
473 void CWindowCropGUI::update()
474 {
475         x1->update((int64_t)mwindow->edl->session->crop_x1);
476         y1->update((int64_t)mwindow->edl->session->crop_y1);
477         width->update((int64_t)mwindow->edl->session->crop_x2 -
478                 mwindow->edl->session->crop_x1);
479         height->update((int64_t)mwindow->edl->session->crop_y2 -
480                 mwindow->edl->session->crop_y1);
481 }
482
483
484 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
485  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), 220, 290)
486 {
487 }
488
489 CWindowEyedropGUI::~CWindowEyedropGUI()
490 {
491 }
492
493 void CWindowEyedropGUI::create_objects()
494 {
495         int margin = mwindow->theme->widget_border;
496         int x = 10 + margin;
497         int y = 10 + margin;
498         int x2 = 70, x3 = x2 + 60;
499         lock_window("CWindowEyedropGUI::create_objects");
500         BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
501         add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
502         y += title0->get_h() + margin;
503         add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
504         y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
505
506         add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
507         y += title1->get_h() + margin;
508         add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
509         y += title2->get_h() + margin;
510         add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
511         y += title3->get_h() + margin;
512
513         add_subwindow(title4 = new BC_Title(x, y, "Y:"));
514         y += title4->get_h() + margin;
515         add_subwindow(title5 = new BC_Title(x, y, "U:"));
516         y += title5->get_h() + margin;
517         add_subwindow(title6 = new BC_Title(x, y, "V:"));
518
519         add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
520
521         radius = new CWindowCoord(this, x2, title7->get_y(),
522                 mwindow->edl->session->eyedrop_radius);
523         radius->create_objects();
524         radius->set_boundaries((int64_t)0, (int64_t)255);
525
526         add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
527         add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
528         add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
529         add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
530
531         add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
532         add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
533         add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
534         add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
535
536         y = title6->get_y() + this->v->get_h() + 2*margin;
537         add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
538         y += sample->get_h() + margin;
539         add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
540         update();
541         unlock_window();
542 }
543
544 void CWindowEyedropGUI::update()
545 {
546         char string[BCTEXTLEN];
547         sprintf(string, "%d, %d",
548                 thread->gui->eyedrop_x,
549                 thread->gui->eyedrop_y);
550         current->update(string);
551
552         radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
553
554         LocalSession *local_session = mwindow->edl->local_session;
555         int use_max = local_session->use_max;
556         float r = use_max ? local_session->red_max : local_session->red;
557         float g = use_max ? local_session->green_max : local_session->green;
558         float b = use_max ? local_session->blue_max : local_session->blue;
559         this->red->update(r);
560         this->green->update(g);
561         this->blue->update(b);
562
563         int rx = 255*r + 0.5;  bclamp(rx,0,255);
564         int gx = 255*g + 0.5;  bclamp(gx,0,255);
565         int bx = 255*b + 0.5;  bclamp(bx,0,255);
566         char rgb_text[BCSTRLEN];
567         sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
568         rgb_hex->update(rgb_text);
569         
570         float y, u, v;
571         YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
572         this->y->update(y);
573         this->u->update(u);  u += 0.5;
574         this->v->update(v);  v += 0.5;
575
576         int yx = 255*y + 0.5;  bclamp(yx,0,255);
577         int ux = 255*u + 0.5;  bclamp(ux,0,255);
578         int vx = 255*v + 0.5;  bclamp(vx,0,255);
579         char yuv_text[BCSTRLEN];
580         sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
581         yuv_hex->update(yuv_text);
582
583         int rgb = (rx << 16) | (gx << 8) | (bx << 0);
584         sample->set_color(rgb);
585         sample->draw_box(0, 0, sample->get_w(), sample->get_h());
586         sample->set_color(BLACK);
587         sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
588         sample->flash();
589 }
590
591 void CWindowEyedropGUI::handle_event()
592 {
593         int new_radius = atoi(radius->get_text());
594         if(new_radius != mwindow->edl->session->eyedrop_radius)
595         {
596                 CWindowGUI *gui = mwindow->cwindow->gui;
597                 if(gui->eyedrop_visible)
598                 {
599                         gui->lock_window("CWindowEyedropGUI::handle_event");
600 // hide it
601                         int rerender;
602                         gui->canvas->do_eyedrop(rerender, 0, 1);
603                 }
604
605                 mwindow->edl->session->eyedrop_radius = new_radius;
606
607                 if(gui->eyedrop_visible)
608                 {
609 // draw it
610                         int rerender;
611                         gui->canvas->do_eyedrop(rerender, 0, 1);
612                         gui->unlock_window();
613                 }
614         }
615 }
616
617
618
619 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
620
621 // Configuration for all possible Keyframe Curve Mode toggles
622 struct _CVD {
623         FloatAuto::t_mode mode;
624         bool use_camera;
625         const char* icon_id;
626         const char* tooltip;
627 };
628
629 const _CVD Camera_Crv_Smooth =
630         {       FloatAuto::SMOOTH,
631                 true,
632                 "tan_smooth",
633                 N_("\"smooth\" Curve on current Camera Keyframes")
634         };
635 const _CVD Camera_Crv_Linear =
636         {       FloatAuto::LINEAR,
637                 true,
638                 "tan_linear",
639                 N_("\"linear\" Curve on current Camera Keyframes")
640         };
641 const _CVD Projector_Crv_Smooth =
642         {       FloatAuto::SMOOTH,
643                 false,
644                 "tan_smooth",
645                 N_("\"smooth\" Curve on current Projector Keyframes")
646         };
647 const _CVD Projector_Crv_Linear =
648         {       FloatAuto::LINEAR,
649                 false,
650                 "tan_linear",
651                 N_("\"linear\" Curve on current Projector Keyframes")
652         };
653
654 // Implementation Class für Keyframe Curve Mode buttons
655 //
656 // This button reflects the state of the "current" keyframe
657 // (the nearest keyframe on the left) for all three automation
658 // lines together. Clicking on this button (re)sets the curve
659 // mode for the three "current" keyframes simultanously, but
660 // never creates a new keyframe.
661 //
662 class CWindowCurveToggle : public BC_Toggle
663 {
664 public:
665         CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
666         void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
667         int handle_event();
668 private:
669         _CVD cfg;
670         MWindow *mwindow;
671         CWindowToolGUI *gui;
672 };
673
674
675 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
676  : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
677    cfg(mode)
678 {
679         this->gui = gui;
680         this->mwindow = mwindow;
681         set_tooltip(_(cfg.tooltip));
682 }
683
684 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
685 {
686 // the toggle state is only set to ON if all
687 // three automation lines have the same curve mode.
688 // For mixed states the toggle stays off.
689         set_value( x->curve_mode == this->cfg.mode &&
690                    y->curve_mode == this->cfg.mode &&
691                    z->curve_mode == this->cfg.mode
692                  ,true // redraw to show new state
693                  );
694 }
695
696 int CWindowCurveToggle::handle_event()
697 {
698         Track *track = mwindow->cwindow->calculate_affected_track();
699         if(track) {
700                 FloatAuto *x=0, *y=0, *z=0;
701                 mwindow->cwindow->calculate_affected_autos(track,
702                         &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
703                 if( x ) x->change_curve_mode(cfg.mode);
704                 if( y ) y->change_curve_mode(cfg.mode);
705                 if( z ) z->change_curve_mode(cfg.mode);
706
707                 gui->update();
708                 gui->update_preview();
709         }
710
711         return 1;
712 }
713
714
715 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow, 
716         CWindowEyedropGUI *gui, int x, int y)
717  : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
718 {
719         this->mwindow = mwindow;
720         this->gui = gui;
721 }
722
723 int CWindowEyedropCheckBox::handle_event()
724 {
725         mwindow->edl->local_session->use_max = get_value();
726         
727         gui->update();
728         return 1;
729 }
730
731
732 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
733  : CWindowToolGUI(mwindow,
734         thread,
735         _(PROGRAM_NAME ": Camera"),
736         170,
737         170)
738 {
739 }
740 CWindowCameraGUI::~CWindowCameraGUI()
741 {
742 }
743
744 void CWindowCameraGUI::create_objects()
745 {
746         int x = 10, y = 10, x1;
747         Track *track = mwindow->cwindow->calculate_affected_track();
748         FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
749         BC_Title *title;
750         BC_Button *button;
751
752         lock_window("CWindowCameraGUI::create_objects");
753         if( track ) {
754                 mwindow->cwindow->calculate_affected_autos(track,
755                         &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
756         }
757
758         add_subwindow(title = new BC_Title(x, y, "X:"));
759         x += title->get_w();
760         this->x = new CWindowCoord(this, x, y,
761                 x_auto ? x_auto->get_value() : (float)0);
762         this->x->create_objects();
763
764
765         y += 30;
766         x = 10;
767         add_subwindow(title = new BC_Title(x, y, "Y:"));
768         x += title->get_w();
769         this->y = new CWindowCoord(this, x, y,
770                 y_auto ? y_auto->get_value() : (float)0);
771         this->y->create_objects();
772         y += 30;
773         x = 10;
774         add_subwindow(title = new BC_Title(x, y, "Z:"));
775         x += title->get_w();
776         this->z = new CWindowCoord(this, x, y,
777                 z_auto ? z_auto->get_value() : (float)1);
778         this->z->create_objects();
779         this->z->set_increment(0.01);
780
781         y += 30;
782         x1 = 10;
783         add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
784         x1 += button->get_w();
785         add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
786         x1 += button->get_w();
787         add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
788
789         y += button->get_h();
790         x1 = 10;
791         add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
792         x1 += button->get_w();
793         add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
794         x1 += button->get_w();
795         add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
796 // additional Buttons to control the curve mode of the "current" keyframe
797         x1 += button->get_w() + 15;
798         add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
799         x1 += button->get_w();
800         add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
801
802 // fill in current auto keyframe values, set toggle states.
803         this->update();
804         unlock_window();
805 }
806
807 void CWindowCameraGUI::update_preview()
808 {
809         CWindowGUI *cgui = mwindow->cwindow->gui;
810         cgui->lock_window("CWindowCameraGUI::update_preview");
811         cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
812         cgui->unlock_window();
813 }
814
815
816 void CWindowCameraGUI::handle_event()
817 {
818         FloatAuto *x_auto = 0;
819         FloatAuto *y_auto = 0;
820         FloatAuto *z_auto = 0;
821         Track *track = mwindow->cwindow->calculate_affected_track();
822         if(track)
823         {
824                 mwindow->undo->update_undo_before(_("camera"), this);
825                 if(event_caller == x)
826                 {
827                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
828                                 track->automation->autos[AUTOMATION_CAMERA_X],
829                                 1);
830                         if(x_auto)
831                         {
832                                 x_auto->set_value(atof(x->get_text()));
833                                 update();
834                                 update_preview();
835                         }
836                 }
837                 else
838                 if(event_caller == y)
839                 {
840                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
841                                 track->automation->autos[AUTOMATION_CAMERA_Y],
842                                 1);
843                         if(y_auto)
844                         {
845                                 y_auto->set_value(atof(y->get_text()));
846                                 update();
847                                 update_preview();
848                         }
849                 }
850                 else
851                 if(event_caller == z)
852                 {
853                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
854                                 track->automation->autos[AUTOMATION_CAMERA_Z],
855                                 1);
856                         if(z_auto)
857                         {
858                                 float zoom = atof(z->get_text());
859                                 if(zoom > 100.) zoom = 100.;
860                                 else
861                                 if(zoom < 0.01) zoom = 0.01;
862         // Doesn't allow user to enter from scratch
863         //              if(zoom != atof(z->get_text()))
864         //                      z->update(zoom);
865
866                                 z_auto->set_value(zoom);
867                                 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
868                                 mwindow->gui->draw_overlays(1);
869                                 mwindow->gui->unlock_window();
870                                 update();
871                                 update_preview();
872                         }
873                 }
874
875                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
876         }
877 }
878
879 void CWindowCameraGUI::update()
880 {
881         FloatAuto *x_auto = 0;
882         FloatAuto *y_auto = 0;
883         FloatAuto *z_auto = 0;
884         Track *track = mwindow->cwindow->calculate_affected_track();
885         if( track ) {
886                 mwindow->cwindow->calculate_affected_autos(track,
887                         &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
888         }
889
890         if(x_auto)
891                 x->update(x_auto->get_value());
892         if(y_auto)
893                 y->update(y_auto->get_value());
894         if(z_auto) {
895                 float value = z_auto->get_value();
896                 z->update(value);
897                 thread->gui->lock_window("CWindowCameraGUI::update");
898                 thread->gui->composite_panel->cpanel_zoom->update(value);
899                 thread->gui->unlock_window();
900         }
901
902         if( x_auto && y_auto && z_auto )
903         {
904                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
905                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
906         }
907 }
908
909
910
911
912 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
913  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
914 {
915         this->gui = gui;
916         this->mwindow = mwindow;
917         set_tooltip(_("Left justify"));
918 }
919 int CWindowCameraLeft::handle_event()
920 {
921         FloatAuto *x_auto = 0;
922         FloatAuto *z_auto = 0;
923         Track *track = mwindow->cwindow->calculate_affected_track();
924         if( track ) {
925                 mwindow->cwindow->calculate_affected_autos(track,
926                         &x_auto, 0, &z_auto, 1, 1, 0, 0);
927         }
928
929         if(x_auto && z_auto)
930         {
931                 int w = 0, h = 0;
932                 track->get_source_dimensions(
933                         mwindow->edl->local_session->get_selectionstart(1),
934                         w,
935                         h);
936
937                 if(w && h)
938                 {
939                         mwindow->undo->update_undo_before(_("camera"), 0);
940                         x_auto->set_value(
941                                 (double)track->track_w / z_auto->get_value() / 2 -
942                                 (double)w / 2);
943                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
944                         gui->update();
945                         gui->update_preview();
946                 }
947         }
948
949         return 1;
950 }
951
952
953 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
954  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
955 {
956         this->gui = gui;
957         this->mwindow = mwindow;
958         set_tooltip(_("Center horizontal"));
959 }
960 int CWindowCameraCenter::handle_event()
961 {
962         FloatAuto *x_auto = 0;
963         Track *track = mwindow->cwindow->calculate_affected_track();
964         if(track)
965                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
966                         track->automation->autos[AUTOMATION_CAMERA_X],
967                         1);
968
969         if(x_auto)
970         {
971                 mwindow->undo->update_undo_before(_("camera"), 0);
972                 x_auto->set_value(0);
973                 gui->update();
974                 gui->update_preview();
975                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
976         }
977
978         return 1;
979 }
980
981
982 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
983  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
984 {
985         this->gui = gui;
986         this->mwindow = mwindow;
987         set_tooltip(_("Right justify"));
988 }
989 int CWindowCameraRight::handle_event()
990 {
991         FloatAuto *x_auto = 0;
992         FloatAuto *z_auto = 0;
993         Track *track = mwindow->cwindow->calculate_affected_track();
994         if( track ) {
995                 mwindow->cwindow->calculate_affected_autos(track,
996                         &x_auto, 0, &z_auto, 1, 1, 0, 0);
997         }
998
999         if(x_auto && z_auto)
1000         {
1001                 int w = 0, h = 0;
1002                 track->get_source_dimensions(
1003                         mwindow->edl->local_session->get_selectionstart(1),
1004                         w,
1005                         h);
1006
1007                 if(w && h)
1008                 {
1009                         mwindow->undo->update_undo_before(_("camera"), 0);
1010                         x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1011                                 (double)w / 2));
1012                         gui->update();
1013                         gui->update_preview();
1014                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1015                 }
1016         }
1017
1018         return 1;
1019 }
1020
1021
1022 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1023  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1024 {
1025         this->gui = gui;
1026         this->mwindow = mwindow;
1027         set_tooltip(_("Top justify"));
1028 }
1029 int CWindowCameraTop::handle_event()
1030 {
1031         FloatAuto *y_auto = 0;
1032         FloatAuto *z_auto = 0;
1033         Track *track = mwindow->cwindow->calculate_affected_track();
1034         if( track ) {
1035                 mwindow->cwindow->calculate_affected_autos(track,
1036                         0, &y_auto, &z_auto, 1, 0, 1, 0);
1037         }
1038
1039         if(y_auto && z_auto)
1040         {
1041                 int w = 0, h = 0;
1042                 track->get_source_dimensions(
1043                         mwindow->edl->local_session->get_selectionstart(1),
1044                         w,
1045                         h);
1046
1047                 if(w && h)
1048                 {
1049                         mwindow->undo->update_undo_before(_("camera"), 0);
1050                         y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1051                                 (double)h / 2);
1052                         gui->update();
1053                         gui->update_preview();
1054                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1055                 }
1056         }
1057
1058         return 1;
1059 }
1060
1061
1062 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1063  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1064 {
1065         this->gui = gui;
1066         this->mwindow = mwindow;
1067         set_tooltip(_("Center vertical"));
1068 }
1069 int CWindowCameraMiddle::handle_event()
1070 {
1071         FloatAuto *y_auto = 0;
1072         Track *track = mwindow->cwindow->calculate_affected_track();
1073         if(track)
1074                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1075                         track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1076
1077         if(y_auto)
1078         {
1079                 mwindow->undo->update_undo_before(_("camera"), 0);
1080                 y_auto->set_value(0);
1081                 gui->update();
1082                 gui->update_preview();
1083                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1084         }
1085
1086         return 1;
1087 }
1088
1089
1090 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1091  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1092 {
1093         this->gui = gui;
1094         this->mwindow = mwindow;
1095         set_tooltip(_("Bottom justify"));
1096 }
1097 int CWindowCameraBottom::handle_event()
1098 {
1099         FloatAuto *y_auto = 0;
1100         FloatAuto *z_auto = 0;
1101         Track *track = mwindow->cwindow->calculate_affected_track();
1102         if( track ) {
1103                 mwindow->cwindow->calculate_affected_autos(track,
1104                         0, &y_auto, &z_auto, 1, 0, 1, 0);
1105         }
1106
1107         if(y_auto && z_auto)
1108         {
1109                 int w = 0, h = 0;
1110                 track->get_source_dimensions(
1111                         mwindow->edl->local_session->get_selectionstart(1),
1112                         w,
1113                         h);
1114
1115                 if(w && h)
1116                 {
1117                         mwindow->undo->update_undo_before(_("camera"), 0);
1118                         y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1119                                 (double)h / 2));
1120                         gui->update();
1121                         gui->update_preview();
1122                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1123                 }
1124         }
1125
1126         return 1;
1127 }
1128
1129
1130 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1131  : CWindowToolGUI(mwindow,
1132         thread,
1133         _(PROGRAM_NAME ": Projector"),
1134         170,
1135         170)
1136 {
1137 }
1138 CWindowProjectorGUI::~CWindowProjectorGUI()
1139 {
1140 }
1141 void CWindowProjectorGUI::create_objects()
1142 {
1143         int x = 10, y = 10, x1;
1144         Track *track = mwindow->cwindow->calculate_affected_track();
1145         FloatAuto *x_auto = 0;
1146         FloatAuto *y_auto = 0;
1147         FloatAuto *z_auto = 0;
1148         BC_Title *title;
1149         BC_Button *button;
1150
1151         lock_window("CWindowProjectorGUI::create_objects");
1152         if( track ) {
1153                 mwindow->cwindow->calculate_affected_autos(track,
1154                         &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1155         }
1156
1157         add_subwindow(title = new BC_Title(x, y, "X:"));
1158         x += title->get_w();
1159         this->x = new CWindowCoord(this, x, y,
1160                 x_auto ? x_auto->get_value() : (float)0);
1161         this->x->create_objects();
1162         y += 30;
1163         x = 10;
1164         add_subwindow(title = new BC_Title(x, y, "Y:"));
1165         x += title->get_w();
1166         this->y = new CWindowCoord(this, x, y,
1167                 y_auto ? y_auto->get_value() : (float)0);
1168         this->y->create_objects();
1169         y += 30;
1170         x = 10;
1171         add_subwindow(title = new BC_Title(x, y, "Z:"));
1172         x += title->get_w();
1173         this->z = new CWindowCoord(this, x, y,
1174                 z_auto ? z_auto->get_value() : (float)1);
1175         this->z->create_objects();
1176         this->z->set_increment(0.01);
1177
1178         y += 30;
1179         x1 = 10;
1180         add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1181         x1 += button->get_w();
1182         add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1183         x1 += button->get_w();
1184         add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1185
1186         y += button->get_h();
1187         x1 = 10;
1188         add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1189         x1 += button->get_w();
1190         add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1191         x1 += button->get_w();
1192         add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1193
1194 // additional Buttons to control the curve mode of the "current" keyframe
1195         x1 += button->get_w() + 15;
1196         add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1197         x1 += button->get_w();
1198         add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1199
1200 // fill in current auto keyframe values, set toggle states.
1201         this->update();
1202         unlock_window();
1203 }
1204
1205 void CWindowProjectorGUI::update_preview()
1206 {
1207         CWindowGUI *cgui = mwindow->cwindow->gui;
1208         cgui->lock_window("CWindowProjectorGUI::update_preview");
1209         cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
1210         cgui->unlock_window();
1211 }
1212
1213 void CWindowProjectorGUI::handle_event()
1214 {
1215         FloatAuto *x_auto = 0;
1216         FloatAuto *y_auto = 0;
1217         FloatAuto *z_auto = 0;
1218         Track *track = mwindow->cwindow->calculate_affected_track();
1219
1220         if(track)
1221         {
1222                 mwindow->undo->update_undo_before(_("projector"), this);
1223                 if(event_caller == x)
1224                 {
1225                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1226                                 track->automation->autos[AUTOMATION_PROJECTOR_X],
1227                                 1);
1228                         if(x_auto)
1229                         {
1230                                 x_auto->set_value(atof(x->get_text()));
1231                                 update();
1232                                 update_preview();
1233                         }
1234                 }
1235                 else
1236                 if(event_caller == y)
1237                 {
1238                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1239                                 track->automation->autos[AUTOMATION_PROJECTOR_Y],
1240                                 1);
1241                         if(y_auto)
1242                         {
1243                                 y_auto->set_value(atof(y->get_text()));
1244                                 update();
1245                                 update_preview();
1246                         }
1247                 }
1248                 else
1249                 if(event_caller == z)
1250                 {
1251                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1252                                 track->automation->autos[AUTOMATION_PROJECTOR_Z],
1253                                 1);
1254                         if(z_auto)
1255                         {
1256                                 float zoom = atof(z->get_text());
1257                                 if(zoom > 100.) zoom = 100.;
1258                                 else if(zoom < 0.01) zoom = 0.01;
1259 //                      if (zoom != atof(z->get_text()))
1260 //                              z->update(zoom);
1261                                 z_auto->set_value(zoom);
1262
1263                                 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1264                                 mwindow->gui->draw_overlays(1);
1265                                 mwindow->gui->unlock_window();
1266
1267                                 update();
1268                                 update_preview();
1269                         }
1270                 }
1271                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1272         }
1273 }
1274
1275 void CWindowProjectorGUI::update()
1276 {
1277         FloatAuto *x_auto = 0;
1278         FloatAuto *y_auto = 0;
1279         FloatAuto *z_auto = 0;
1280         Track *track = mwindow->cwindow->calculate_affected_track();
1281         if( track ) {
1282                 mwindow->cwindow->calculate_affected_autos(track,
1283                         &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1284         }
1285
1286         if(x_auto)
1287                 x->update(x_auto->get_value());
1288         if(y_auto)
1289                 y->update(y_auto->get_value());
1290         if(z_auto) {
1291                 float value = z_auto->get_value();
1292                 z->update(value);
1293                 thread->gui->lock_window("CWindowProjectorGUI::update");
1294                 thread->gui->composite_panel->cpanel_zoom->update(value);
1295                 thread->gui->unlock_window();
1296         }
1297
1298         if( x_auto && y_auto && z_auto )
1299         {
1300                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1301                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1302         }
1303 }
1304
1305 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1306  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1307 {
1308         this->gui = gui;
1309         this->mwindow = mwindow;
1310         set_tooltip(_("Left justify"));
1311 }
1312 int CWindowProjectorLeft::handle_event()
1313 {
1314         FloatAuto *x_auto = 0;
1315         FloatAuto *z_auto = 0;
1316         Track *track = mwindow->cwindow->calculate_affected_track();
1317         if( track ) {
1318                 mwindow->cwindow->calculate_affected_autos(track,
1319                         &x_auto, 0, &z_auto, 0, 1, 0, 0);
1320         }
1321         if(x_auto && z_auto)
1322         {
1323                 mwindow->undo->update_undo_before(_("projector"), 0);
1324                 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1325                         (double)mwindow->edl->session->output_w / 2 );
1326                 gui->update();
1327                 gui->update_preview();
1328                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1329         }
1330
1331         return 1;
1332 }
1333
1334
1335 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1336  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1337 {
1338         this->gui = gui;
1339         this->mwindow = mwindow;
1340         set_tooltip(_("Center horizontal"));
1341 }
1342 int CWindowProjectorCenter::handle_event()
1343 {
1344         FloatAuto *x_auto = 0;
1345         Track *track = mwindow->cwindow->calculate_affected_track();
1346         if(track)
1347                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1348                         track->automation->autos[AUTOMATION_PROJECTOR_X],
1349                         1);
1350
1351         if(x_auto)
1352         {
1353                 mwindow->undo->update_undo_before(_("projector"), 0);
1354                 x_auto->set_value(0);
1355                 gui->update();
1356                 gui->update_preview();
1357                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1358         }
1359
1360         return 1;
1361 }
1362
1363
1364 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1365  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1366 {
1367         this->gui = gui;
1368         this->mwindow = mwindow;
1369         set_tooltip(_("Right justify"));
1370 }
1371 int CWindowProjectorRight::handle_event()
1372 {
1373         FloatAuto *x_auto = 0;
1374         FloatAuto *z_auto = 0;
1375         Track *track = mwindow->cwindow->calculate_affected_track();
1376         if( track ) {
1377                 mwindow->cwindow->calculate_affected_autos(track,
1378                         &x_auto, 0, &z_auto, 0, 1, 0, 0);
1379         }
1380
1381         if(x_auto && z_auto)
1382         {
1383                 mwindow->undo->update_undo_before(_("projector"), 0);
1384                 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1385                         (double)mwindow->edl->session->output_w / 2));
1386                 gui->update();
1387                 gui->update_preview();
1388                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1389         }
1390
1391         return 1;
1392 }
1393
1394
1395 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1396  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1397 {
1398         this->gui = gui;
1399         this->mwindow = mwindow;
1400         set_tooltip(_("Top justify"));
1401 }
1402 int CWindowProjectorTop::handle_event()
1403 {
1404         FloatAuto *y_auto = 0;
1405         FloatAuto *z_auto = 0;
1406         Track *track = mwindow->cwindow->calculate_affected_track();
1407         if( track ) {
1408                 mwindow->cwindow->calculate_affected_autos(track,
1409                         0, &y_auto, &z_auto, 0, 0, 1, 0);
1410         }
1411
1412         if(y_auto && z_auto)
1413         {
1414                 mwindow->undo->update_undo_before(_("projector"), 0);
1415                 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1416                         (double)mwindow->edl->session->output_h / 2 );
1417                 gui->update();
1418                 gui->update_preview();
1419                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1420         }
1421
1422         return 1;
1423 }
1424
1425
1426 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1427  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1428 {
1429         this->gui = gui;
1430         this->mwindow = mwindow;
1431         set_tooltip(_("Center vertical"));
1432 }
1433 int CWindowProjectorMiddle::handle_event()
1434 {
1435         FloatAuto *y_auto = 0;
1436         Track *track = mwindow->cwindow->calculate_affected_track();
1437         if(track)
1438                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1439                         track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1440
1441         if(y_auto)
1442         {
1443                 mwindow->undo->update_undo_before(_("projector"), 0);
1444                 y_auto->set_value(0);
1445                 gui->update();
1446                 gui->update_preview();
1447                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1448         }
1449
1450         return 1;
1451 }
1452
1453
1454 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1455  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1456 {
1457         this->gui = gui;
1458         this->mwindow = mwindow;
1459         set_tooltip(_("Bottom justify"));
1460 }
1461 int CWindowProjectorBottom::handle_event()
1462 {
1463         FloatAuto *y_auto = 0;
1464         FloatAuto *z_auto = 0;
1465         Track *track = mwindow->cwindow->calculate_affected_track();
1466         if( track ) {
1467                 mwindow->cwindow->calculate_affected_autos(track,
1468                         0, &y_auto, &z_auto, 0, 0, 1, 0);
1469         }
1470
1471         if(y_auto && z_auto)
1472         {
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));
1476                 gui->update();
1477                 gui->update_preview();
1478                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1479         }
1480
1481         return 1;
1482 }
1483
1484
1485 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1486                 int x, int y, const char *text)
1487  : BC_PopupTextBox(gui, 0, text, x, y, 100, 160)
1488 {
1489         this->mwindow = mwindow;
1490         this->gui = gui;
1491 }
1492
1493 CWindowMaskName::~CWindowMaskName()
1494 {
1495 }
1496
1497 int CWindowMaskName::handle_event()
1498 {
1499         Track *track;
1500         MaskAutos *autos;
1501         MaskAuto *keyframe;
1502         SubMask *mask;
1503         MaskPoint *point;
1504 //printf("CWindowMaskGUI::update 1\n");
1505         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1506         if( track ) {
1507                 int k = get_number();
1508                 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1509                 else mwindow->edl->session->cwindow_mask = k;
1510                 if( k >= 0 && k < mask_items.size() ) {
1511                         mask_items[k]->set_text(get_text());
1512                         update_list(&mask_items);
1513                 }
1514 #ifdef USE_KEYFRAME_SPANNING
1515                 MaskAuto temp_keyframe(mwindow->edl, autos);
1516                 temp_keyframe.copy_data(keyframe);
1517                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1518                 memset(submask->name, 0, sizeof(submask->name));
1519                 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1520                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1521 #else
1522                 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1523                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1524                         memset(submask->name, 0, sizeof(submask->name));
1525                         strncpy(submask->name, get_text(), sizeof(submask->name));
1526                         current = current == (MaskAuto*)autos->default_auto ?
1527                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1528                 }
1529 #endif
1530                 gui->update();
1531                 gui->update_preview();
1532         }
1533         return 1;
1534 }
1535
1536 void CWindowMaskName::update_items(MaskAuto *keyframe)
1537 {
1538         mask_items.remove_all_objects();
1539         int sz = keyframe->masks.size();
1540         for( int i=0; i<sz; ++i ) {
1541                 SubMask *sub_mask = keyframe->masks.get(i);
1542                 char *text = sub_mask->name;
1543                 mask_items.append(new BC_ListBoxItem(text));
1544         }
1545         update_list(&mask_items);
1546 }
1547
1548
1549 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1550                  int x, int y, int no, int v)
1551  : BC_CheckBox(x, y, v)
1552 {
1553         this->mwindow = mwindow;
1554         this->gui = gui;
1555         this->no = no;
1556 }
1557
1558 CWindowMaskButton::~CWindowMaskButton()
1559 {
1560 }
1561
1562 int CWindowMaskButton::handle_event()
1563 {
1564         mwindow->edl->session->cwindow_mask = no;
1565         gui->name->update(gui->name->mask_items[no]->get_text());
1566         gui->update();
1567         gui->update_preview();
1568         return 1;
1569 }
1570
1571 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1572                 int x, int y)
1573  : BC_Tumbler(x, y)
1574 {
1575         this->mwindow = mwindow;
1576         this->gui = gui;
1577 }
1578
1579 CWindowMaskThumbler::~CWindowMaskThumbler()
1580 {
1581 }
1582
1583 int CWindowMaskThumbler::handle_up_event()
1584 {
1585         return do_event(1);
1586 }
1587
1588 int CWindowMaskThumbler::handle_down_event()
1589 {
1590         return do_event(-1);
1591 }
1592
1593 int CWindowMaskThumbler::do_event(int dir)
1594 {
1595         int k = mwindow->edl->session->cwindow_mask;
1596         if( (k+=dir) >= SUBMASKS ) k = 0;
1597         else if( k < 0 ) k = SUBMASKS-1;
1598         mwindow->edl->session->cwindow_mask = k;
1599         gui->name->update(gui->name->mask_items[k]->get_text());
1600         gui->update();
1601         gui->update_preview();
1602         return 1;
1603 }
1604
1605
1606 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
1607         CWindowToolGUI *gui, int x, int y)
1608  : BC_GenericButton(x, y, _("Delete"))
1609 {
1610         this->mwindow = mwindow;
1611         this->gui = gui;
1612         set_tooltip(_("Delete mask"));
1613 }
1614
1615 int CWindowMaskDelMask::handle_event()
1616 {
1617         MaskAutos *autos;
1618         MaskAuto *keyframe;
1619         Track *track;
1620         MaskPoint *point;
1621         SubMask *mask;
1622         int total_points;
1623
1624 // Get existing keyframe
1625         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1626
1627         if( track ) {
1628                 mwindow->undo->update_undo_before(_("mask delete"), 0);
1629
1630 #ifdef USE_KEYFRAME_SPANNING
1631 // Create temp keyframe
1632                 MaskAuto temp_keyframe(mwindow->edl, autos);
1633                 temp_keyframe.copy_data(keyframe);
1634                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1635                 submask->points.remove_all_objects();
1636                 total_points = 0;
1637 // Commit change to span of keyframes
1638                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1639 #else
1640                 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1641                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1642                         submask->points.clear();
1643                         current = current == (MaskAuto*)autos->default_auto ?
1644                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1645                 }
1646                 total_points = 0;
1647 #endif
1648                 if( mwindow->cwindow->gui->affected_point >= total_points )
1649                         mwindow->cwindow->gui->affected_point =
1650                                 total_points > 0 ? total_points-1 : 0;
1651
1652                 gui->update();
1653                 gui->update_preview();
1654                 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1655         }
1656
1657         return 1;
1658 }
1659
1660 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
1661         CWindowToolGUI *gui, int x, int y)
1662  : BC_GenericButton(x, y, _("Delete"))
1663 {
1664         this->mwindow = mwindow;
1665         this->gui = gui;
1666         set_tooltip(_("Delete point"));
1667 }
1668
1669 int CWindowMaskDelPoint::handle_event()
1670 {
1671         MaskAutos *autos;
1672         MaskAuto *keyframe;
1673         Track *track;
1674         MaskPoint *point;
1675         SubMask *mask;
1676         int total_points;
1677
1678 // Get existing keyframe
1679         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1680         if( track ) {
1681                 mwindow->undo->update_undo_before(_("point delete"), 0);
1682
1683 #ifdef USE_KEYFRAME_SPANNING
1684 // Create temp keyframe
1685                 MaskAuto temp_keyframe(mwindow->edl, autos);
1686                 temp_keyframe.copy_data(keyframe);
1687 // Update parameter
1688                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1689                 int i = mwindow->cwindow->gui->affected_point;
1690                 for( ; i<submask->points.total-1; ++i )
1691                         *submask->points.values[i] = *submask->points.values[i+1];
1692                 if( submask->points.total > 0 ) {
1693                         point = submask->points.values[submask->points.total-1];
1694                         submask->points.remove_object(point);
1695                 }
1696                 total_points = submask->points.total;
1697
1698 // Commit change to span of keyframes
1699                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1700 #else
1701                 MaskAuto *current = (MaskAuto*)autos->default_auto;
1702                 while( current ) {
1703                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1704                         int i = mwindow->cwindow->gui->affected_point;
1705                         for( ; i<submask->points.total-1; ++i ) {
1706                                 *submask->points.values[i] = *submask->points.values[i+1];
1707                         if( submask->points.total > 0 ) {
1708                                 point = submask->points.values[submask->points.total-1];
1709                                 submask->points.remove_object(point);
1710                         }
1711                         total_points = submask->points.total;
1712                         current = current == (MaskAuto*)autos->default_auto ?
1713                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1714                 }
1715 #endif
1716                 if( mwindow->cwindow->gui->affected_point >= total_points )
1717                         mwindow->cwindow->gui->affected_point =
1718                                 total_points > 0 ? total_points-1 : 0;
1719
1720                 gui->update();
1721                 gui->update_preview();
1722                 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1723         }
1724
1725         return 1;
1726 }
1727
1728 int CWindowMaskDelPoint::keypress_event()
1729 {
1730         if( get_keypress() == BACKSPACE ||
1731             get_keypress() == DELETE )
1732                 return handle_event();
1733         return 0;
1734 }
1735
1736
1737
1738
1739 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
1740         CWindowToolGUI *gui, int x, int y)
1741  : BC_TumbleTextBox(gui,
1742                 (int64_t)mwindow->cwindow->gui->affected_point,
1743                 (int64_t)0, INT64_MAX, x, y, 100)
1744 {
1745         this->mwindow = mwindow;
1746         this->gui = gui;
1747 }
1748
1749 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
1750 {
1751 }
1752
1753 int CWindowMaskAffectedPoint::handle_event()
1754 {
1755         int total_points = 0;
1756         int affected_point = atol(get_text());
1757         Track *track = mwindow->cwindow->calculate_affected_track();
1758         if(track) {
1759                 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1760                 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
1761                 if( keyframe ) {
1762                         SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
1763                         total_points = mask->points.size();
1764                 }
1765         }
1766         int active_point = affected_point;
1767         if( affected_point >= total_points )
1768                 affected_point = total_points - 1;
1769         if( affected_point < 0 )
1770                 affected_point = 0;
1771         if( active_point != affected_point )
1772                 update((int64_t)affected_point);
1773         mwindow->cwindow->gui->affected_point = affected_point;
1774         gui->update();
1775         gui->update_preview();
1776         return 1;
1777 }
1778
1779
1780 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1781  : BC_CheckBox(x, y, ((CWindowMaskGUI*)gui)->focused, _("Focus"))
1782 {
1783         this->mwindow = mwindow;
1784         this->gui = gui;
1785         set_tooltip("Center for rotate/scale");
1786 }
1787
1788 CWindowMaskFocus::~CWindowMaskFocus()
1789 {
1790 }
1791
1792 int CWindowMaskFocus::handle_event()
1793 {
1794         ((CWindowMaskGUI*)gui)->focused = get_value();
1795         gui->update();
1796         gui->update_preview();
1797         return 1;
1798 }
1799
1800 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1801  : BC_CheckBox(x, y, ((CWindowMaskGUI*)gui)->markers, _("Markers"))
1802 {
1803         this->mwindow = mwindow;
1804         this->gui = gui;
1805         set_tooltip("Display points");
1806 }
1807
1808 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
1809 {
1810 }
1811
1812 int CWindowMaskDrawMarkers::handle_event()
1813 {
1814         ((CWindowMaskGUI*)gui)->markers = get_value();
1815         gui->update();
1816         gui->update_preview();
1817         return 1;
1818 }
1819
1820 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1821  : BC_CheckBox(x, y, ((CWindowMaskGUI*)gui)->boundary, _("Boundary"))
1822 {
1823         this->mwindow = mwindow;
1824         this->gui = gui;
1825         set_tooltip("Display mask outline");
1826 }
1827
1828 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
1829 {
1830 }
1831
1832 int CWindowMaskDrawBoundary::handle_event()
1833 {
1834         ((CWindowMaskGUI*)gui)->boundary = get_value();
1835         gui->update();
1836         gui->update_preview();
1837         return 1;
1838 }
1839
1840
1841 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1842  : BC_TumbleTextBox(gui, 0, -FEATHER_MAX, FEATHER_MAX, x, y, 64, 2)
1843 {
1844         this->mwindow = mwindow;
1845         this->gui = gui;
1846 }
1847 CWindowMaskFeather::~CWindowMaskFeather()
1848 {
1849 }
1850
1851 int CWindowMaskFeather::update(float v)
1852 {
1853         CWindowMaskGUI *mask_gui = (CWindowMaskGUI*)gui;
1854         mask_gui->feather_slider->update(v);
1855         return BC_TumbleTextBox::update(v);
1856 }
1857
1858 int CWindowMaskFeather::update_value(float v)
1859 {
1860         MaskAutos *autos;
1861         MaskAuto *keyframe;
1862         Track *track;
1863         MaskPoint *point;
1864         SubMask *mask;
1865 #ifdef USE_KEYFRAME_SPANNING
1866         int create_it = 0;
1867 #else
1868         int create_it = 1;
1869 #endif
1870
1871         mwindow->undo->update_undo_before(_("mask feather"), this);
1872
1873 // Get existing keyframe
1874         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
1875                         mask, point, create_it);
1876         if( track ) {
1877                 int gang = ((CWindowMaskGUI*)gui)->gang_feather->get_value();
1878 #ifdef USE_KEYFRAME_SPANNING
1879                 MaskAuto temp_keyframe(mwindow->edl, autos);
1880                 temp_keyframe.copy_data(keyframe);
1881                 keyframe = &temp_keyframe;
1882 #endif
1883                 float change = v - mask->feather;
1884                 int k = mwindow->edl->session->cwindow_mask;
1885                 int n = gang ? keyframe->masks.size() : k+1;
1886                 for( int i=gang? 0 : k; i<n; ++i ) {
1887                         SubMask *sub_mask = keyframe->get_submask(i);
1888                         float feather = sub_mask->feather + change;
1889                         bclamp(feather, -FEATHER_MAX, FEATHER_MAX);
1890                         sub_mask->feather = feather;
1891                 }
1892 #ifdef USE_KEYFRAME_SPANNING
1893                 autos->update_parameter(keyframe);
1894 #endif
1895                 gui->update_preview();
1896         }
1897
1898         mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
1899         return 1;
1900 }
1901
1902 int CWindowMaskFeather::handle_event()
1903 {
1904         float v = atof(get_text());
1905         CWindowMaskGUI * mask_gui = (CWindowMaskGUI*)gui;
1906         mask_gui->feather_slider->update(v);
1907         return mask_gui->feather->update_value(v);
1908 }
1909
1910 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
1911                 CWindowToolGUI *gui, int x, int y, int w, float v)
1912  : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX, FEATHER_MAX, v)
1913 {
1914         this->mwindow = mwindow;
1915         this->gui = gui;
1916         set_precision(0.01);
1917         timer = new Timer();
1918         stick = 0;
1919         last_v = 0;
1920 }
1921
1922 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
1923 {
1924         delete timer;
1925 }
1926
1927 int CWindowMaskFeatherSlider::handle_event()
1928 {
1929         float v = get_value();
1930         if( stick > 0 ) {
1931                 int64_t ms = timer->get_difference();
1932                 if( ms < 250 && --stick > 0 ) {
1933                         if( get_value() == 0 ) return 1;
1934                         update(v = 0);
1935                 }
1936                 else {
1937                         stick = 0;
1938                         last_v = v;
1939                 }
1940         }
1941         else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
1942                 stick = 16;
1943                 v = 0;
1944         }
1945         else
1946                 last_v = v;
1947         timer->update();
1948         CWindowMaskGUI * mask_gui = (CWindowMaskGUI*)gui;
1949         mask_gui->feather->BC_TumbleTextBox::update(v);
1950         return mask_gui->feather->update_value(v);
1951 }
1952
1953 int CWindowMaskFeatherSlider::update(float v)
1954 {
1955         return BC_FSlider::update(v);
1956 }
1957
1958 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1959  : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, 64, 2)
1960 {
1961         this->mwindow = mwindow;
1962         this->gui = gui;
1963 }
1964 CWindowMaskFade::~CWindowMaskFade()
1965 {
1966 }
1967
1968 int CWindowMaskFade::update(float v)
1969 {
1970         CWindowMaskGUI *mask_gui = (CWindowMaskGUI*)gui;
1971         mask_gui->fade_slider->update(v);
1972         return BC_TumbleTextBox::update(v);
1973 }
1974
1975 int CWindowMaskFade::update_value(float v)
1976 {
1977         MaskAutos *autos;
1978         MaskAuto *keyframe;
1979         Track *track;
1980         MaskPoint *point;
1981         SubMask *mask;
1982 #ifdef USE_KEYFRAME_SPANNING
1983         int create_it = 0;
1984 #else
1985         int create_it = 1;
1986 #endif
1987
1988         mwindow->undo->update_undo_before(_("mask fade"), this);
1989
1990 // Get existing keyframe
1991         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
1992                         mask, point, create_it);
1993         if( track ) {
1994                 int gang = ((CWindowMaskGUI*)gui)->gang_fader->get_value();
1995 #ifdef USE_KEYFRAME_SPANNING
1996                 MaskAuto temp_keyframe(mwindow->edl, autos);
1997                 temp_keyframe.copy_data(keyframe);
1998                 keyframe = &temp_keyframe;
1999 #endif
2000                 float change = v - mask->fader;
2001                 int k = mwindow->edl->session->cwindow_mask;
2002                 int n = gang ? keyframe->masks.size() : k+1;
2003                 for( int i=gang? 0 : k; i<n; ++i ) {
2004                         SubMask *sub_mask = keyframe->get_submask(i);
2005                         float fader = sub_mask->fader + change;
2006                         bclamp(fader, -100.f, 100.f);
2007                         sub_mask->fader = fader;
2008                 }
2009 #ifdef USE_KEYFRAME_SPANNING
2010                 autos->update_parameter(keyframe);
2011 #endif
2012                 gui->update_preview();
2013         }
2014
2015         mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2016         return 1;
2017 }
2018
2019 int CWindowMaskFade::handle_event()
2020 {
2021         float v = atof(get_text());
2022         CWindowMaskGUI * mask_gui = (CWindowMaskGUI*)gui;
2023         mask_gui->fade_slider->update(v);
2024         return mask_gui->fade->update_value(v);
2025 }
2026
2027 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowToolGUI *gui,
2028                 int x, int y, int w)
2029  : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2030 {
2031         this->mwindow = mwindow;
2032         this->gui = gui;
2033         timer = new Timer();
2034         stick = 0;
2035         last_v = 0;
2036 }
2037
2038 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2039 {
2040         delete timer;
2041 }
2042
2043 int CWindowMaskFadeSlider::handle_event()
2044 {
2045         float v = 100*get_value()/200;
2046         if( stick > 0 ) {
2047                 int64_t ms = timer->get_difference();
2048                 if( ms < 250 && --stick > 0 ) {
2049                         if( get_value() == 0 ) return 1;
2050                         update(v = 0);
2051                 }
2052                 else {
2053                         stick = 0;
2054                         last_v = v;
2055                 }
2056         }
2057         else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2058                 stick = 16;
2059                 v = 0;
2060         }
2061         else
2062                 last_v = v;
2063         timer->update();
2064         CWindowMaskGUI *mask_gui = (CWindowMaskGUI*)gui;
2065         mask_gui->fade->BC_TumbleTextBox::update(v);
2066         return mask_gui->fade->update_value(v);
2067 }
2068
2069 int CWindowMaskFadeSlider::update(int64_t v)
2070 {
2071         return BC_ISlider::update(200*v/100);
2072 }
2073
2074 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2075                 CWindowToolGUI *gui, int x, int y)
2076  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2077 {
2078         this->mwindow = mwindow;
2079         this->gui = gui;
2080         set_tooltip(_("Gang fader"));
2081 }
2082
2083 CWindowMaskGangFader::~CWindowMaskGangFader()
2084 {
2085 }
2086
2087 int CWindowMaskGangFader::handle_event()
2088 {
2089         return 1;
2090 }
2091
2092 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowToolGUI *gui, int x, int y)
2093  : BC_CheckBox(x,
2094         y,
2095         1,
2096         _("Apply mask before plugins"))
2097 {
2098         this->gui = gui;
2099 }
2100
2101 int CWindowMaskBeforePlugins::handle_event()
2102 {
2103         Track *track;
2104         MaskAutos *autos;
2105         MaskAuto *keyframe;
2106         SubMask *mask;
2107         MaskPoint *point;
2108         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
2109
2110         if (keyframe) {
2111                 int v = get_value();
2112 #ifdef USE_KEYFRAME_SPANNING
2113                 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2114                 temp_keyframe.copy_data(keyframe);
2115                 temp_keyframe.apply_before_plugins = v;
2116                 autos->update_parameter(&temp_keyframe);
2117 #else
2118                 keyframe->apply_before_plugins = v;
2119 #endif
2120                 gui->update_preview();
2121         }
2122         return 1;
2123 }
2124
2125
2126 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowToolGUI *gui, int x, int y)
2127  : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2128 {
2129         this->gui = gui;
2130 }
2131
2132 int CWindowDisableOpenGLMasking::handle_event()
2133 {
2134         Track *track;
2135         MaskAutos *autos;
2136         MaskAuto *keyframe;
2137         SubMask *mask;
2138         MaskPoint *point;
2139         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
2140
2141         if( keyframe ) {
2142                 int v = get_value();
2143 #ifdef USE_KEYFRAME_SPANNING
2144                 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2145                 temp_keyframe.copy_data(keyframe);
2146                 temp_keyframe.disable_opengl_masking = v;
2147                 autos->update_parameter(&temp_keyframe);
2148 #else
2149                 keyframe->disable_opengl_masking = v;
2150 #endif
2151                 gui->update_preview();
2152         }
2153         return 1;
2154 }
2155
2156
2157 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2158                 CWindowMaskGUI *gui, int x, int y)
2159  : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2160 {
2161         this->mwindow = mwindow;
2162         this->gui = gui;
2163         set_tooltip(_("Delete all masks"));
2164 }
2165
2166 CWindowMaskClrMask::~CWindowMaskClrMask()
2167 {
2168 }
2169
2170 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2171 {
2172         VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2173         return vfrm->get_w();
2174 }
2175
2176 int CWindowMaskClrMask::handle_event()
2177 {
2178         MaskAutos *autos;
2179         MaskAuto *keyframe;
2180         Track *track;
2181         MaskPoint *point;
2182         SubMask *mask;
2183
2184 // Get existing keyframe
2185         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
2186
2187         if( track ) {
2188                 mwindow->undo->update_undo_before(_("del masks"), 0);
2189                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2190                 gui->update();
2191                 gui->update_preview();
2192                 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2193         }
2194
2195         return 1;
2196 }
2197
2198 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2199                 CWindowToolGUI *gui, int x, int y)
2200  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2201 {
2202         this->mwindow = mwindow;
2203         this->gui = gui;
2204         set_tooltip(_("Gang feather"));
2205 }
2206
2207 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2208 {
2209 }
2210
2211 int CWindowMaskGangFeather::handle_event()
2212 {
2213         return 1;
2214 }
2215
2216 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2217  : CWindowToolGUI(mwindow, thread,
2218         _(PROGRAM_NAME ": Mask"), 360, 500)
2219 {
2220         this->mwindow = mwindow;
2221         this->thread = thread;
2222         active_point = 0;
2223         fade = 0;
2224         feather = 0;
2225         focused = 0;
2226         markers = 1;
2227         boundary = 1;
2228 }
2229 CWindowMaskGUI::~CWindowMaskGUI()
2230 {
2231         lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2232         delete active_point;
2233         delete fade;
2234         delete feather;
2235         unlock_window();
2236 }
2237
2238 void CWindowMaskGUI::create_objects()
2239 {
2240         int x = 10, y = 10, margin = mwindow->theme->widget_border;
2241         int clr_x = get_w()-x - CWindowMaskClrMask::calculate_w(mwindow);
2242         int del_x = clr_x-margin - CWindowMaskDelMask::calculate_w(this,_("Delete"));
2243         //MaskAuto *keyframe = 0;
2244         //Track *track = mwindow->cwindow->calculate_affected_track();
2245         //if(track)
2246         //      keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(track->automation->autos[AUTOMATION_MASK], 0);
2247
2248         lock_window("CWindowMaskGUI::create_objects");
2249         BC_Title *title;
2250         add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2251         int x1 = x + 70;
2252         name = new CWindowMaskName(mwindow, this, x1, y, "");
2253         name->create_objects();
2254         add_subwindow(clr_mask = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2255         add_subwindow(del_mask = new CWindowMaskDelMask(mwindow, this, del_x, y));
2256         y += name->get_h() + margin;
2257
2258         int bw = 0, bh = 0;
2259         BC_CheckBox::calculate_extents(this, &bw, &bh);
2260         int bdx = bw + margin;
2261         int x2 = x;
2262         for( int i=0; i<SUBMASKS; x2+=bdx, ++i ) {
2263                 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2264                 mask_buttons[i] = new CWindowMaskButton(mwindow, this, x2, y, i, v);
2265                 add_subwindow(mask_buttons[i]);
2266         }
2267         x2 += margin;
2268         add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, x2, y));
2269         y += bh + margin;
2270         x2 = x;
2271         for( int i=0; i<SUBMASKS; x2+=bdx, ++i ) {
2272                 char text[BCSTRLEN];  sprintf(text, "%d", i);
2273                 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2274                 mask_blabels[i] = new BC_Title(x2+tx, y, text);
2275                 add_subwindow(mask_blabels[i]);
2276         }
2277         y += bh + 2*margin;
2278
2279         add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2280         fade = new CWindowMaskFade(mwindow, this, x1, y);
2281         fade->create_objects();
2282         x2 = x1 + fade->get_w() + 2*margin;
2283         int w2 = clr_x-2*margin - x2;
2284         add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2285         add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2286         y += fade->get_h() + margin;
2287         add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2288         feather = new CWindowMaskFeather(mwindow, this, x1, y);
2289         feather->create_objects();
2290         w2 = clr_x - 2*margin - x2;
2291         feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2292         add_subwindow(feather_slider);
2293         add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2294         y += feather->get_h() + 3*margin;
2295
2296         add_subwindow(title = new BC_Title(x, y, _("Point:")));
2297         active_point = new CWindowMaskAffectedPoint(mwindow, this, x1, y);
2298         active_point->create_objects();
2299         add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2300         y += active_point->get_h() + margin;
2301         add_subwindow(title = new BC_Title(x, y, "X:"));
2302         this->x = new CWindowCoord(this, x1, y, (float)0.0);
2303         this->x->create_objects();
2304         add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2305         y += this->x->get_h() + margin;
2306         add_subwindow(title = new BC_Title(x, y, "Y:"));
2307         this->y = new CWindowCoord(this, x1, y, (float)0.0);
2308         this->y->create_objects();
2309         add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2310         y += this->y->get_h() + margin;
2311         BC_Bar *bar;
2312         add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2313         y += bar->get_h() + margin;
2314
2315         add_subwindow(title = new BC_Title(x, y, "X:"));
2316         focus_x = new CWindowCoord(this, x1, y, (float)0.0);
2317         focus_x->create_objects();
2318         add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2319         y += focus_x->get_h() + margin;
2320         add_subwindow(title = new BC_Title(x, y, "Y:"));
2321         focus_y = new CWindowCoord(this, x1, y, (float)0.0);
2322         focus_y->create_objects();
2323         y += focus_x->get_h() + margin;
2324         add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
2325         y += this->apply_before_plugins->get_h();
2326         add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
2327         y += this->disable_opengl_masking->get_h() + margin;
2328         add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2329         y += bar->get_h() + margin;
2330
2331         y += margin;
2332         add_subwindow(title = new BC_Title(x, y, _(
2333                 "Shift+LMB: move an end point\n"
2334                 "Ctrl+LMB: move a control point\n"
2335                 "Alt+LMB: to drag translate the mask\n"
2336                 "Shift+Key Delete to delete the mask\n"
2337                 "Wheel Up/Dn: rotate around pointer\n"
2338                 "Shift+Wheel Up/Dn: scale around pointer\n"
2339                 "Shift+MMB: Toggle focus center at pointer")));
2340         update();
2341         unlock_window();
2342 }
2343
2344 void CWindowMaskGUI::get_keyframe(Track* &track,
2345         MaskAutos* &autos,
2346         MaskAuto* &keyframe,
2347         SubMask* &mask,
2348         MaskPoint* &point,
2349         int create_it)
2350 {
2351         autos = 0;
2352         keyframe = 0;
2353
2354         track = mwindow->cwindow->calculate_affected_track();
2355         if(track)
2356         {
2357                 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2358                 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2359                         autos,
2360                         create_it);
2361         }
2362
2363         if(keyframe)
2364                 mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2365         else
2366                 mask = 0;
2367
2368         point = 0;
2369         if(keyframe)
2370         {
2371                 if(mwindow->cwindow->gui->affected_point < mask->points.total &&
2372                         mwindow->cwindow->gui->affected_point >= 0)
2373                 {
2374                         point = mask->points.values[mwindow->cwindow->gui->affected_point];
2375                 }
2376         }
2377 }
2378
2379 void CWindowMaskGUI::update()
2380 {
2381         Track *track;
2382         MaskAutos *autos;
2383         MaskAuto *keyframe;
2384         SubMask *mask;
2385         MaskPoint *point;
2386 //printf("CWindowMaskGUI::update 1\n");
2387         get_keyframe(track, autos, keyframe, mask, point, 0);
2388
2389         double position = mwindow->edl->local_session->get_selectionstart(1);
2390         position = mwindow->edl->align_to_frame(position, 0);
2391         if(track)
2392         {
2393                 int64_t position_i = track->to_units(position, 0);
2394
2395                 if(point) {
2396                         x->update(point->x);
2397                         y->update(point->y);
2398                 }
2399
2400                 if(mask) {
2401                         int k = mwindow->edl->session->cwindow_mask;
2402                         update_buttons(keyframe, k);
2403                         feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
2404                         fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
2405                         apply_before_plugins->update(keyframe->apply_before_plugins);
2406                         disable_opengl_masking->update(keyframe->disable_opengl_masking);
2407                 }
2408         }
2409
2410         active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2411         const char *text = "";
2412         if( keyframe ) {
2413                 name->update_items(keyframe);
2414                 int k = mwindow->edl->session->cwindow_mask;
2415                 if( k >= 0 && k < keyframe->masks.size() )
2416                         text = keyframe->masks[k]->name;
2417         }
2418         name->update(text);
2419 }
2420
2421 void CWindowMaskGUI::handle_event()
2422 {
2423         Track *track;
2424         MaskAuto *keyframe;
2425         MaskAutos *autos;
2426         SubMask *mask;
2427         MaskPoint *point;
2428         get_keyframe(track, autos, keyframe, mask, point, 0);
2429
2430         mwindow->undo->update_undo_before(_("mask point"), this);
2431
2432         if(point)
2433         {
2434 #ifdef USE_KEYFRAME_SPANNING
2435 // Create temp keyframe
2436                 MaskAuto temp_keyframe(mwindow->edl, autos);
2437                 temp_keyframe.copy_data(keyframe);
2438 // Get affected point in temp keyframe
2439                 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2440                 if(mwindow->cwindow->gui->affected_point < mask->points.total &&
2441                         mwindow->cwindow->gui->affected_point >= 0)
2442                 {
2443                         point = mask->points.values[mwindow->cwindow->gui->affected_point];
2444                 }
2445
2446                 if(point)
2447                 {
2448                         point->x = atof(x->get_text());
2449                         point->y = atof(y->get_text());
2450 // Commit to spanned keyframes
2451                         autos->update_parameter(&temp_keyframe);
2452                 }
2453 #else
2454                 point->x = atof(x->get_text());
2455                 point->y = atof(y->get_text());
2456 #endif
2457         }
2458
2459         update_preview();
2460         mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2461 }
2462
2463 void CWindowMaskGUI::update_preview()
2464 {
2465         unlock_window();
2466         CWindowGUI *cgui = mwindow->cwindow->gui;
2467         cgui->lock_window("CWindowMaskGUI::update_preview");
2468         cgui->sync_parameters(CHANGE_PARAMS, 0, 1);
2469         cgui->unlock_window();
2470         lock_window("CWindowMaskGUI::update_preview");
2471 }
2472
2473 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
2474 {
2475         focus_x->update(cx);
2476         focus_y->update(cy);
2477         focus->update(focused = v);
2478 }
2479
2480 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
2481 {
2482         int text_color = get_resources()->default_text_color;
2483         int high_color = get_resources()->button_highlighted;
2484         for( int i=0; i<SUBMASKS; ++i ) {
2485                 int color = text_color;
2486                 if( keyframe ) {
2487                         SubMask *submask = keyframe->get_submask(i);
2488                         if( submask && submask->points.size() )
2489                                 color = high_color;
2490                 }
2491                 mask_blabels[i]->set_color(color);
2492                 mask_buttons[i]->update(i==k ? 1 : 0);
2493         }
2494 }
2495
2496 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
2497  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), 320, 240)
2498 {
2499 }
2500
2501 CWindowRulerGUI::~CWindowRulerGUI()
2502 {
2503 }
2504
2505 void CWindowRulerGUI::create_objects()
2506 {
2507         int x = 10, y = 10, x1 = 100;
2508         BC_Title *title;
2509
2510         lock_window("CWindowRulerGUI::create_objects");
2511         add_subwindow(title = new BC_Title(x, y, _("Current:")));
2512         add_subwindow(current = new BC_TextBox(x1, y, 200, 1, ""));
2513         y += title->get_h() + 5;
2514         add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
2515         add_subwindow(point1 = new BC_TextBox(x1, y, 200, 1, ""));
2516         y += title->get_h() + 5;
2517         add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
2518         add_subwindow(point2 = new BC_TextBox(x1, y, 200, 1, ""));
2519         y += title->get_h() + 5;
2520         add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
2521         add_subwindow(deltas = new BC_TextBox(x1, y, 200, 1, ""));
2522         y += title->get_h() + 5;
2523         add_subwindow(title = new BC_Title(x, y, _("Distance:")));
2524         add_subwindow(distance = new BC_TextBox(x1, y, 200, 1, ""));
2525         y += title->get_h() + 5;
2526         add_subwindow(title = new BC_Title(x, y, _("Angle:")));
2527         add_subwindow(angle = new BC_TextBox(x1, y, 200, 1, ""));
2528         y += title->get_h() + 10;
2529         char string[BCTEXTLEN];
2530         sprintf(string,
2531                  _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
2532                 0xc2, 0xb0); // degrees utf
2533         add_subwindow(title = new BC_Title(x,
2534                 y,
2535                 string));
2536         y += title->get_h() + 10;
2537         sprintf(string, _("Press Alt to translate the ruler."));
2538         add_subwindow(title = new BC_Title(x,
2539                 y,
2540                 string));
2541         update();
2542         unlock_window();
2543 }
2544
2545 void CWindowRulerGUI::update()
2546 {
2547         char string[BCTEXTLEN];
2548         int cx = mwindow->session->cwindow_output_x;
2549         int cy = mwindow->session->cwindow_output_y;
2550         sprintf(string, "%d, %d", cx, cy);
2551         current->update(string);
2552         double x1 = mwindow->edl->session->ruler_x1;
2553         double y1 = mwindow->edl->session->ruler_y1;
2554         sprintf(string, "%.0f, %.0f", x1, y1);
2555         point1->update(string);
2556         double x2 = mwindow->edl->session->ruler_x2;
2557         double y2 = mwindow->edl->session->ruler_y2;
2558         sprintf(string, "%.0f, %.0f", x2, y2);
2559         point2->update(string);
2560         double dx = x2 - x1, dy = y2 - y1;
2561         sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
2562         deltas->update(string);
2563         double d = sqrt(dx*dx + dy*dy);
2564         sprintf(string, _("%0.01f pixels"), d);
2565         distance->update(string);
2566         double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
2567         sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
2568         angle->update(string);
2569 }
2570
2571 void CWindowRulerGUI::handle_event()
2572 {
2573 }
2574
2575
2576
2577