Credit Andrew - improve in-tree documentation
[goodguy/cinelerra.git] / cinelerra / patchgui.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "automation.h"
23 #include "bcsignals.h"
24 #include "cplayback.h"
25 #include "cwindow.h"
26 #include "edl.h"
27 #include "edlsession.h"
28 #include "intauto.h"
29 #include "intautos.h"
30 #include "language.h"
31 #include "localsession.h"
32 #include "mainsession.h"
33 #include "mainundo.h"
34 #include "mwindow.h"
35 #include "mwindowgui.h"
36 #include "patchbay.h"
37 #include "patchgui.h"
38 #include "playbackengine.h"
39 #include "theme.h"
40 #include "track.h"
41 #include "trackcanvas.h"
42 #include "tracks.h"
43 #include "transportque.h"
44 #include "vframe.h"
45 #include "zwindow.h"
46
47
48 PatchGUI::PatchGUI(MWindow *mwindow,
49                 PatchBay *patchbay,
50                 Track *track,
51                 int x,
52                 int y)
53 {
54         this->mwindow = mwindow;
55         this->patchbay = patchbay;
56         this->track = track;
57         this->x = x;
58         this->y = y;
59         title = 0;
60         record = 0;
61         play = 0;
62 //      automate = 0;
63         gang = 0;
64         draw = 0;
65         mute = 0;
66         expand = 0;
67         nudge = 0;
68         mix = 0;
69         change_source = 0;
70         track_id = track ? track->get_id() : -1;
71         mixer = 0;
72 }
73
74 PatchGUI::~PatchGUI()
75 {
76         delete title;
77         delete record;
78         delete play;
79 //      delete automate;
80         delete gang;
81         delete draw;
82         delete mute;
83         delete expand;
84         delete nudge;
85         delete mix;
86 }
87
88 void PatchGUI::create_objects()
89 {
90         update(x, y);
91 }
92
93 int PatchGUI::reposition(int x, int y)
94 {
95         int x1 = 0;
96         int y1 = 0;
97
98
99         if( x != this->x || y != this->y ) {
100                 this->x = x;  this->y = y;
101
102                 if( title )
103                         title->reposition_window(title->get_x(), y1 + y, 0);
104                 if( expand )
105                         expand->reposition_window(expand->get_x(), y1 + y);
106                 y1 += mwindow->theme->title_h;
107
108                 if( play ) {
109                         play->reposition_window(play->get_x(), y1 + y);
110                         x1 += play->get_w();
111                         record->reposition_window(record->get_x(), y1 + y);
112                         x1 += record->get_w();
113 //                      automate->reposition_window(x1, y1 + y);
114 //                      x1 += automate->get_w();
115                         gang->reposition_window(gang->get_x(), y1 + y);
116                         x1 += gang->get_w();
117                         draw->reposition_window(draw->get_x(), y1 + y);
118                         x1 += draw->get_w();
119                         mute->reposition_window(mute->get_x(), y1 + y);
120                         x1 += mute->get_w();
121                 }
122                 y1 += mwindow->theme->play_h;
123         }
124         else {
125                 if( title )
126                         y1 += mwindow->theme->title_h;
127                 if( play )
128                         y1 += mwindow->theme->play_h;
129         }
130
131         return y1;
132 }
133
134 int PatchGUI::update(int x, int y)
135 {
136 //TRACE("PatchGUI::update 1");
137         reposition(x, y);
138 //TRACE("PatchGUI::update 10");
139
140         int h = track->vertical_span(mwindow->theme);
141         int y1 = 0;
142         int x1 = 0;
143 //printf("PatchGUI::update 10\n");
144
145         int y2 = y1 + mwindow->theme->title_h;
146         if( title ) {
147                 if( h < y2 ) {
148                         delete title;   title = 0;
149                         delete expand;  expand = 0;
150                 }
151                 else {
152                         title->update(track->title);
153                         expand->update(track->expand_view);
154                 }
155         }
156         else if( h >= y2 ) {
157                 VFrame **expandpatch_data = mwindow->theme->get_image_set("expandpatch_data");
158                 int x2 = patchbay->get_w() - expandpatch_data[0]->get_w() - 5;
159                 patchbay->add_subwindow(title = new TitlePatch(mwindow, this, x1 + x, y1 + y, x2-x1-5));
160                 patchbay->add_subwindow(expand = new ExpandPatch(mwindow, this, x2, y1 + y));
161         }
162
163         if( title )
164                 y1 = y2;
165
166         y2 = y1 + mwindow->theme->play_h;
167         if( play ) {
168                 if( h < y2 ) {
169                         delete play;    play = 0;
170                         delete record;  record = 0;
171                         delete gang;    gang = 0;
172                         delete draw;    draw = 0;
173                         delete mute;    mute = 0;
174                 }
175                 else {
176                         play->update(track->play);
177                         record->update(track->record);
178                         gang->update(track->gang);
179                         draw->update(track->draw);
180                         mute->update(mwindow->get_int_auto(this, AUTOMATION_MUTE)->value);
181                 }
182         }
183         else if( h >= y2 ) {
184                 patchbay->add_subwindow(play = new PlayPatch(mwindow, this, x1 + x, y1 + y));
185 //printf("PatchGUI::update %d %d\n", __LINE__, play->get_h());
186                 x1 += play->get_w();
187                 patchbay->add_subwindow(record = new RecordPatch(mwindow, this, x1 + x, y1 + y));
188                 x1 += record->get_w();
189                 patchbay->add_subwindow(gang = new GangPatch(mwindow, this, x1 + x, y1 + y));
190                 x1 += gang->get_w();
191                 patchbay->add_subwindow(draw = new DrawPatch(mwindow, this, x1 + x, y1 + y));
192                 x1 += draw->get_w();
193                 patchbay->add_subwindow(mute = new MutePatch(mwindow, this, x1 + x, y1 + y));
194                 x1 += mute->get_w();
195         }
196         if( play )
197                 y1 = y2;
198
199 //UNTRACE
200         return y1;
201 }
202
203
204 void PatchGUI::toggle_behavior(int type,
205                 int value,
206                 BC_Toggle *toggle,
207                 int *output)
208 {
209         if(toggle->shift_down()) {
210                 int sense = type != Tracks::MUTE ? 1 : 0;
211                 // all selected if nothing previously selected or
212                 // if this patch was previously the only one selected
213                 int total_type = mwindow->edl->tracks->total_of(type);
214                 int total_selected = sense ? total_type :
215                         mwindow->edl->tracks->total() - total_type;
216                 int selected = !total_selected || (total_selected == 1 &&
217                          *output == sense ) ? sense : 1-sense;
218                 mwindow->edl->tracks->select_all(type, selected);
219                 if( selected != sense ) *output = sense;
220
221                 patchbay->drag_operation = type;
222                 patchbay->new_status = 1;
223         }
224         else
225         {
226                 *output = value;
227 // Select + drag behavior
228                 patchbay->drag_operation = type;
229                 patchbay->new_status = value;
230         }
231
232         switch(type)
233         {
234                 case Tracks::PLAY:
235                         mwindow->gui->unlock_window();
236                         mwindow->restart_brender();
237                         mwindow->sync_parameters(CHANGE_EDL);
238                         mwindow->gui->lock_window("PatchGUI::toggle_behavior 1");
239                         break;
240
241                 case Tracks::MUTE:
242                         mwindow->gui->unlock_window();
243                         mwindow->restart_brender();
244                         mwindow->sync_parameters(CHANGE_PARAMS);
245                         mwindow->gui->lock_window("PatchGUI::toggle_behavior 2");
246                         break;
247
248 // Update affected tracks in cwindow
249                 case Tracks::RECORD:
250                         mwindow->cwindow->update(0, 1, 1);
251                         break;
252
253                 case Tracks::GANG:
254                         break;
255
256                 case Tracks::DRAW:
257                         mwindow->gui->update(0, NORMAL_DRAW, 0, 0, 0, 0, 0);
258                         break;
259
260                 case Tracks::EXPAND:
261                         break;
262         }
263
264 // update all panes
265         mwindow->gui->update_patchbay();
266 }
267
268
269 char* PatchGUI::calculate_nudge_text(int *changed)
270 {
271         if(changed) *changed = 0;
272         if(track->edl->session->nudge_format)
273         {
274                 sprintf(string_return, "%.4f", track->from_units(track->nudge));
275                 if(changed && nudge && atof(nudge->get_text()) - atof(string_return) != 0)
276                         *changed = 1;
277         }
278         else
279         {
280                 sprintf(string_return, "%jd", track->nudge);
281                 if(changed && nudge && atoi(nudge->get_text()) - atoi(string_return) != 0)
282                         *changed = 1;
283         }
284         return string_return;
285 }
286
287
288 int64_t PatchGUI::calculate_nudge(const char *string)
289 {
290         if(mwindow->edl->session->nudge_format)
291         {
292                 float result;
293                 sscanf(string, "%f", &result);
294                 return track->to_units(result, 0);
295         }
296         else
297         {
298                 int64_t temp;
299                 sscanf(string, "%jd", &temp);
300                 return temp;
301         }
302 }
303
304
305 PlayPatch::PlayPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
306  : BC_Toggle(x,
307                 y,
308                 mwindow->theme->get_image_set("playpatch_data"),
309                 patch->track->play,
310                 "",
311                 0,
312                 0,
313                 0)
314 {
315         this->mwindow = mwindow;
316         this->patch = patch;
317         set_tooltip(_("Play track"));
318         set_select_drag(1);
319 }
320
321 int PlayPatch::button_press_event()
322 {
323         if(is_event_win() && get_buttonpress() == 1)
324         {
325                 mwindow->undo->update_undo_before();
326                 set_status(BC_Toggle::TOGGLE_DOWN);
327                 update(!get_value());
328                 patch->toggle_behavior(Tracks::PLAY,
329                         get_value(),
330                         this,
331                         &patch->track->play);
332                 return 1;
333         }
334         return 0;
335 }
336
337 int PlayPatch::button_release_event()
338 {
339         int result = BC_Toggle::button_release_event();
340         if(patch->patchbay->drag_operation == Tracks::PLAY)
341         {
342                 mwindow->undo->update_undo_after(_("play patch"), LOAD_PATCHES);
343                 patch->patchbay->drag_operation = Tracks::NONE;
344         }
345         return result;
346 }
347
348
349
350
351
352
353
354
355
356
357
358 RecordPatch::RecordPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
359  : BC_Toggle(x,
360                 y,
361                 mwindow->theme->get_image_set("recordpatch_data"),
362                 patch->track->record,
363                 "",
364                 0,
365                 0,
366                 0)
367 {
368         this->mwindow = mwindow;
369         this->patch = patch;
370         set_tooltip(_("Arm track"));
371         set_select_drag(1);
372 }
373
374 int RecordPatch::button_press_event()
375 {
376         if(is_event_win() && get_buttonpress() == 1)
377         {
378                 mwindow->undo->update_undo_before();
379                 set_status(BC_Toggle::TOGGLE_DOWN);
380                 update(!get_value());
381                 patch->toggle_behavior(Tracks::RECORD,
382                         get_value(),
383                         this,
384                         &patch->track->record);
385                 patch->title->set_back_color(patch->track->record ?
386                         get_resources()->text_background :
387                         get_resources()->text_background_disarmed);
388                 patch->title->set_text_row(0);
389                 return 1;
390         }
391         return 0;
392 }
393
394 int RecordPatch::button_release_event()
395 {
396         int result = BC_Toggle::button_release_event();
397         if(patch->patchbay->drag_operation == Tracks::RECORD)
398         {
399                 mwindow->undo->update_undo_after(_("record patch"), LOAD_PATCHES);
400                 patch->patchbay->drag_operation = Tracks::NONE;
401         }
402         return result;
403 }
404
405
406
407
408
409
410
411
412
413
414
415 GangPatch::GangPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
416  : BC_Toggle(x, y,
417                 mwindow->theme->get_image_set("gangpatch_data"),
418                 patch->track->gang,
419                 "",
420                 0,
421                 0,
422                 0)
423 {
424         this->mwindow = mwindow;
425         this->patch = patch;
426         set_tooltip(_("Gang faders"));
427         set_select_drag(1);
428 }
429
430 int GangPatch::button_press_event()
431 {
432         if(is_event_win() && get_buttonpress() == 1)
433         {
434                 mwindow->undo->update_undo_before();
435                 set_status(BC_Toggle::TOGGLE_DOWN);
436                 update(!get_value());
437                 patch->toggle_behavior(Tracks::GANG,
438                         get_value(),
439                         this,
440                         &patch->track->gang);
441                 return 1;
442         }
443         return 0;
444 }
445
446 int GangPatch::button_release_event()
447 {
448         int result = BC_Toggle::button_release_event();
449         if(patch->patchbay->drag_operation == Tracks::GANG)
450         {
451                 mwindow->undo->update_undo_after(_("gang patch"), LOAD_PATCHES);
452                 patch->patchbay->drag_operation = Tracks::NONE;
453         }
454         return result;
455 }
456
457
458
459
460
461
462
463
464
465
466
467 DrawPatch::DrawPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
468  : BC_Toggle(x, y,
469                 mwindow->theme->get_image_set("drawpatch_data"),
470                 patch->track->draw,
471                 "",
472                 0,
473                 0,
474                 0)
475 {
476         this->mwindow = mwindow;
477         this->patch = patch;
478         set_tooltip(_("Draw media"));
479         set_select_drag(1);
480 }
481
482 int DrawPatch::button_press_event()
483 {
484         if(is_event_win() && get_buttonpress() == 1)
485         {
486                 mwindow->undo->update_undo_before();
487                 set_status(BC_Toggle::TOGGLE_DOWN);
488                 update(!get_value());
489                 patch->toggle_behavior(Tracks::DRAW,
490                         get_value(),
491                         this,
492                         &patch->track->draw);
493                 return 1;
494         }
495         return 0;
496 }
497
498 int DrawPatch::button_release_event()
499 {
500         int result = BC_Toggle::button_release_event();
501         if(patch->patchbay->drag_operation == Tracks::DRAW)
502         {
503                 mwindow->undo->update_undo_after(_("draw patch"), LOAD_PATCHES);
504                 patch->patchbay->drag_operation = Tracks::NONE;
505         }
506         return result;
507 }
508
509
510
511
512
513
514
515
516
517
518 MutePatch::MutePatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
519  : BC_Toggle(x, y,
520                 mwindow->theme->get_image_set("mutepatch_data"),
521                 mwindow->get_int_auto(patch, AUTOMATION_MUTE)->value,
522                 "",
523                 0,
524                 0,
525                 0)
526 {
527         this->mwindow = mwindow;
528         this->patch = patch;
529         set_tooltip(_("Don't send to output"));
530         set_select_drag(1);
531 }
532
533 int MutePatch::button_press_event()
534 {
535         if(is_event_win() && get_buttonpress() == 1)
536         {
537                 mwindow->undo->update_undo_before();
538                 set_status(BC_Toggle::TOGGLE_DOWN);
539                 update(!get_value());
540                 IntAuto *current;
541                 double position = mwindow->edl->local_session->get_selectionstart(1);
542                 Autos *mute_autos = patch->track->automation->autos[AUTOMATION_MUTE];
543
544
545                 current = (IntAuto*)mute_autos->get_auto_for_editing(position);
546                 current->value = get_value();
547
548                 patch->toggle_behavior(Tracks::MUTE,
549                         get_value(),
550                         this,
551                         &current->value);
552
553
554
555                 if(mwindow->edl->session->auto_conf->autos[AUTOMATION_MUTE])
556                 {
557                         mwindow->gui->draw_overlays(1);
558                 }
559                 return 1;
560         }
561         return 0;
562 }
563
564 int MutePatch::button_release_event()
565 {
566         int result = BC_Toggle::button_release_event();
567         if(patch->patchbay->drag_operation == Tracks::MUTE)
568         {
569                 mwindow->undo->update_undo_after(_("mute patch"), LOAD_PATCHES);
570                 patch->patchbay->drag_operation = Tracks::NONE;
571         }
572         return result;
573 }
574
575
576
577 ExpandPatch::ExpandPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
578  : BC_Toggle(x,
579                 y,
580                 mwindow->theme->get_image_set("expandpatch_data"),
581                 patch->track->expand_view,
582                 "",
583                 0,
584                 0,
585                 0)
586 {
587         this->mwindow = mwindow;
588         this->patch = patch;
589         set_select_drag(1);
590 }
591
592 int ExpandPatch::button_press_event()
593 {
594         if(is_event_win() && get_buttonpress() == 1)
595         {
596                 mwindow->undo->update_undo_before();
597                 set_status(BC_Toggle::TOGGLE_DOWN);
598                 update(!get_value());
599                 patch->toggle_behavior(Tracks::EXPAND,
600                         get_value(),
601                         this,
602                         &patch->track->expand_view);
603                 mwindow->edl->tracks->update_y_pixels(mwindow->theme);
604                 mwindow->gui->draw_trackmovement();
605                 return 1;
606         }
607         return 0;
608 }
609
610 int ExpandPatch::button_release_event()
611 {
612         int result = BC_Toggle::button_release_event();
613         if(patch->patchbay->drag_operation == Tracks::EXPAND)
614         {
615                 mwindow->undo->update_undo_after(_("expand patch"), LOAD_PATCHES);
616                 patch->patchbay->drag_operation = Tracks::NONE;
617         }
618         return result;
619 }
620
621
622 TitlePatch::TitlePatch(MWindow *mwindow, PatchGUI *patch, int x, int y, int w)
623  : BC_TextBox(x, y, w, 1, patch->track->title, 1, MEDIUMFONT, 1)
624 {
625         this->mwindow = mwindow;
626         this->patch = patch;
627         set_back_color(patch->track->record ?
628                         get_resources()->text_background :
629                         get_resources()->text_background_disarmed);
630 }
631
632 void TitlePatch::update(const char *text)
633 {
634         set_back_color(patch->track->record ?
635                         get_resources()->text_background :
636                         get_resources()->text_background_disarmed);
637         BC_TextBox::update(text);
638 }
639
640 int TitlePatch::handle_event()
641 {
642         mwindow->undo->update_undo_before(_("track title"), this);
643         strcpy(patch->track->title, get_text());
644         mwindow->update_plugin_titles();
645         mwindow->gui->draw_overlays(1);
646         mwindow->undo->update_undo_after(_("track title"), LOAD_PATCHES);
647         return 1;
648 }
649
650
651 NudgePatch::NudgePatch(MWindow *mwindow,
652         PatchGUI *patch,
653         int x,
654         int y,
655         int w)
656  : BC_TextBox(x,
657         y,
658         w,
659         1,
660         patch->calculate_nudge_text(0))
661 {
662         this->mwindow = mwindow;
663         this->patch = patch;
664         set_tooltip(_("Nudge"));
665 }
666
667 int NudgePatch::handle_event()
668 {
669         set_value(patch->calculate_nudge(get_text()));
670         return 1;
671 }
672
673 void NudgePatch::set_value(int64_t value)
674 {
675         mwindow->undo->update_undo_before(_("nudge."), this);
676         patch->track->nudge = value;
677
678         if(patch->track->gang && patch->track->record)
679                 patch->patchbay->synchronize_nudge(patch->track->nudge, patch->track);
680
681         mwindow->undo->update_undo_after(_("nudge."), LOAD_PATCHES);
682
683         mwindow->gui->unlock_window();
684         if(patch->track->data_type == TRACK_VIDEO)
685                 mwindow->restart_brender();
686         mwindow->sync_parameters(CHANGE_PARAMS);
687         mwindow->gui->lock_window("NudgePatch::handle_event 2");
688
689         mwindow->session->changes_made = 1;
690 }
691
692
693 int NudgePatch::button_press_event()
694 {
695         int result = 0;
696
697         if(is_event_win() && cursor_inside())
698         {
699                 if(get_buttonpress() == 4)
700                 {
701                         int value = patch->calculate_nudge(get_text());
702                         value += calculate_increment();
703                         set_value(value);
704                         update();
705                         result = 1;
706                 }
707                 else
708                 if(get_buttonpress() == 5)
709                 {
710                         int value = patch->calculate_nudge(get_text());
711                         value -= calculate_increment();
712                         set_value(value);
713                         update();
714                         result = 1;
715                 }
716                 else
717                 if(get_buttonpress() == 3)
718                 {
719                         patch->patchbay->nudge_popup->activate_menu(patch);
720                         result = 1;
721                 }
722         }
723
724         if(!result)
725                 return BC_TextBox::button_press_event();
726         else
727                 return result;
728 }
729
730 int64_t NudgePatch::calculate_increment()
731 {
732         if(patch->track->data_type == TRACK_AUDIO)
733         {
734                 return (int64_t)ceil(patch->track->edl->session->sample_rate / 10.0);
735         }
736         else
737         {
738                 return (int64_t)ceil(1.0 / patch->track->edl->session->frame_rate);
739         }
740 }
741
742 void NudgePatch::update()
743 {
744         int changed;
745         char *string = patch->calculate_nudge_text(&changed);
746         if(changed)
747                 BC_TextBox::update(string);
748 }
749
750
751 MixPatch::MixPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
752  : BC_Toggle(x, y, mwindow->theme->get_image_set("mixpatch_data"),
753         patch->mixer, "", 0, 0, 0)
754 {
755         this->mwindow = mwindow;
756         this->patch = patch;
757 }
758
759 MixPatch::~MixPatch()
760 {
761 }
762
763 int MixPatch::handle_event()
764 {
765         int v = patch->track ? get_value() : 0;
766         if( patch->mixer != v ) {
767                 if( patch->track )
768                         mwindow->gui->update_mixers(patch->track, v);
769                 else
770                         update(v);
771                 mwindow->update_mixer_tracks();
772         }
773         return 1;
774 }
775
776 void MixPatch::update(int v)
777 {
778         patch->mixer = v;
779         BC_Toggle::update(v);
780 }
781