add missing GPL information in guicast program files
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / apatchgui.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 "apatchgui.h"
23 #include "atrack.h"
24 #include "autoconf.h"
25 #include "automation.h"
26 #include "edl.h"
27 #include "edlsession.h"
28 #include "floatauto.h"
29 #include "floatautos.h"
30 #include "gwindowgui.h"
31 #include "intauto.h"
32 #include "intautos.h"
33 #include "keys.h"
34 #include "language.h"
35 #include "localsession.h"
36 #include "mainsession.h"
37 #include "mainundo.h"
38 #include "mwindow.h"
39 #include "mwindowgui.h"
40 #include "panauto.h"
41 #include "panautos.h"
42 #include "patchbay.h"
43 #include "theme.h"
44 #include "trackcanvas.h"
45 #include "zwindow.h"
46
47 APatchGUI::APatchGUI(MWindow *mwindow, PatchBay *patchbay,
48                 ATrack *track, int x, int y)
49  : PatchGUI(mwindow, patchbay, track, x, y)
50 {
51         data_type = TRACK_AUDIO;
52         this->atrack = track;
53         meter = 0;
54         pan = 0;
55         fade = 0;
56 }
57
58 APatchGUI::~APatchGUI()
59 {
60         if( fade ) delete fade;
61         if( meter ) delete meter;
62         if( pan ) delete pan;
63 }
64
65 void APatchGUI::create_objects()
66 {
67         update(x, y);
68 }
69
70 int APatchGUI::reposition(int x, int y)
71 {
72         int y1 = PatchGUI::reposition(x, y);
73
74         if( fade )
75                 fade->reposition_window(fade->get_x(), y1+y);
76         y1 += mwindow->theme->fade_h;
77         if( meter )
78                 meter->reposition_window(meter->get_x(), y1+y, -1, meter->get_w());
79         y1 += mwindow->theme->meter_h;
80         if( mix )
81                 mix->reposition_window(mix->get_x(), y1+y);
82         if( pan )
83                 pan->reposition_window(pan->get_x(), y1+y);
84         if( nudge )
85                 nudge->reposition_window(nudge->get_x(), y1+y);
86         y1 += mwindow->theme->pan_h;
87
88         return y1;
89 }
90
91 int APatchGUI::update(int x, int y)
92 {
93         int h = track->vertical_span(mwindow->theme);
94         int x1 = 0;
95         int y1 = PatchGUI::update(x, y);
96
97         int y2 = y1 + mwindow->theme->fade_h;
98         if( fade ) {
99                 if( h < y2 ) {
100                         delete fade;
101                         fade = 0;
102                 }
103                 else {
104                         FloatAuto *previous = 0, *next = 0;
105                         double unit_position = mwindow->edl->local_session->get_selectionstart(1);
106                         unit_position = mwindow->edl->align_to_frame(unit_position, 0);
107                         int64_t unit_pos = atrack->to_units(unit_position, 0);
108                         FloatAutos *ptr = (FloatAutos*)atrack->automation->autos[AUTOMATION_FADE];
109                         float value = ptr->get_value(unit_pos, PLAY_FORWARD, previous, next);
110                         fade->update(fade->get_w(), value,
111                                      mwindow->edl->local_session->automation_mins[AUTOGROUPTYPE_AUDIO_FADE],
112                                      mwindow->edl->local_session->automation_maxs[AUTOGROUPTYPE_AUDIO_FADE]);
113                 }
114         }
115         else if( h >= y2 ) {
116                 float v = mwindow->get_float_auto(this, AUTOMATION_FADE)->get_value();
117                 patchbay->add_subwindow(fade = new AFadePatch(this, x1+x, y1+y,
118                         patchbay->get_w() - xS(10), v));
119         }
120         y1 = y2;
121
122         y2 = y1 + mwindow->theme->meter_h;
123         if( meter ) {
124                 if( h < y2 ) {
125                         delete meter;  meter = 0;
126                 }
127         }
128         else if( h >= y2 ) {
129                 patchbay->add_subwindow(meter = new AMeterPatch(mwindow, this, x1+x, y1+y));
130         }
131         y1 = y2;
132
133         y2 = y1 + mwindow->theme->pan_h;
134         if( pan ) {
135                 if( h < y2 ) {
136                         delete mix;    mix = 0;
137                         delete pan;    pan = 0;
138                         delete nudge;  nudge = 0;
139                 }
140                 else {
141                         if( mwindow->session->selected_zwindow >= 0 ) {
142                                 int v = mwindow->mixer_track_active(track);
143                                 mix->update(v);
144                         }
145                         if( pan->get_total_values() != mwindow->edl->session->audio_channels ) {
146                                 pan->change_channels(mwindow->edl->session->audio_channels,
147                                         mwindow->edl->session->achannel_positions);
148                         }
149                         else {
150                                 int handle_x, handle_y;
151                                 PanAuto *previous = 0, *next = 0;
152                                 double unit_position = mwindow->edl->local_session->get_selectionstart(1);
153                                 unit_position = mwindow->edl->align_to_frame(unit_position, 0);
154                                 unit_position = atrack->to_units(unit_position, 0);
155                                 PanAutos *ptr = (PanAutos*)atrack->automation->autos[AUTOMATION_PAN];
156                                 ptr->get_handle(handle_x, handle_y, (long)unit_position,
157                                                 PLAY_FORWARD, previous, next);
158                                 pan->update(handle_x, handle_y);
159                         }
160                         nudge->update();
161                 }
162         }
163         else if( h >= y2 ) {
164                 patchbay->add_subwindow(mix = new AMixPatch(mwindow, this, x1+x, y1+y+5));
165                 x1 += mix->get_w() + xS(10);
166                 patchbay->add_subwindow(pan = new APanPatch(mwindow, this, x1+x, y1+y));
167                 x1 += pan->get_w() + xS(20);
168                 patchbay->add_subwindow(nudge = new NudgePatch(mwindow, this, x1+x, y1+y,
169                                 patchbay->get_w() - x1-x - xS(10)));
170         }
171         y1 = y2;
172
173         return y1;
174 }
175
176 void APatchGUI::update_faders(float v)
177 {
178         if( fade )
179                 fade->update(v);
180
181         change_source = 1;
182         double position = mwindow->edl->local_session->get_selectionstart(1);
183         Autos *fade_autos = atrack->automation->autos[AUTOMATION_FADE];
184         int need_undo = !fade_autos->auto_exists_for_editing(position);
185         mwindow->undo->update_undo_before(_("fade"), need_undo ? 0 : this);
186         FloatAuto *current = (FloatAuto*)fade_autos->get_auto_for_editing(position);
187         float change = v - current->get_value(edge);
188         current->bump_value(v, edge, span);
189         if( track->is_ganged() && track->is_armed() )
190                 patchbay->synchronize_faders(change, TRACK_AUDIO, track, edge, span);
191         mwindow->undo->update_undo_after(_("fade"), LOAD_AUTOMATION);
192         change_source = 0;
193
194         mwindow->sync_parameters(CHANGE_PARAMS);
195
196         if( mwindow->edl->session->auto_conf->autos[AUTOMATION_FADE] ) {
197                 mwindow->gui->draw_overlays(1);
198         }
199 }
200
201 AFadePatch::AFadePatch(APatchGUI *patch, int x, int y, int w, float v)
202  : BC_FSlider(x, y, 0, w, w,
203         patch->mwindow->edl->local_session->automation_mins[AUTOGROUPTYPE_AUDIO_FADE],
204         patch->mwindow->edl->local_session->automation_maxs[AUTOGROUPTYPE_AUDIO_FADE],
205         v)
206 {
207         this->patch = patch;
208 }
209
210
211 int AFadePatch::handle_event()
212 {
213         if( shift_down() ) {
214                 update(0.0);
215                 set_tooltip(get_caption());
216         }
217         patch->update_faders(get_value());
218         return 1;
219 }
220
221 AKeyFadePatch::AKeyFadePatch(MWindow *mwindow, APatchGUI *gui,
222                         int bump, int x, int y)
223  : BC_SubWindow(x,y, xS(200)+4,yS(bump ? 50 : 24)+4,
224                 GWindowGUI::auto_colors[AUTOMATION_FADE])
225 {
226         this->mwindow = mwindow;
227         this->gui = gui;
228 }
229 AKeyFadePatch::~AKeyFadePatch()
230 {
231 }
232
233 void AKeyFadePatch::create_objects()
234 {
235         int x = 2, x1 = x, y = 0, dy = 0;
236         FloatAuto *fade_auto = mwindow->get_float_auto(gui, AUTOMATION_FADE);
237         float v = fade_auto->get_value(gui->edge);
238         add_subwindow(akey_fade_text = new AKeyFadeText(this, x, y, xS(64), v));
239         x += akey_fade_text->get_w();
240         dy = bmax(dy, akey_fade_text->get_h());
241         VFrame **lok_images = mwindow->theme->get_image_set("lok");
242         int w1 = get_w()-2 - x - lok_images[0]->get_w();
243         add_subwindow(akey_fade_slider = new AKeyFadeSlider(this, x, y, w1, v));
244         x += akey_fade_slider->get_w();
245         dy = bmax(dy, akey_fade_slider->get_h());
246         add_subwindow(akey_fade_ok = new AKeyFadeOK(this, x, y, lok_images));
247         dy = bmax(dy, akey_fade_ok->get_h());
248         if( fade_auto->is_bump() ) {
249                 y += dy;
250                 set_color(get_resources()->get_bg_color());
251                 draw_box(0,y, get_w(),get_h());
252                 add_subwindow(auto_edge = new AKeyPatchAutoEdge(mwindow, this, x1, y));
253                 x1 += auto_edge->get_w() + xS(15);
254                 add_subwindow(auto_span = new AKeyPatchAutoSpan(mwindow, this, x1, y));
255         }
256         draw_3d_border(0,0, get_w(), get_h(), 0);
257         activate();
258         show_window();
259 }
260
261 void AKeyFadePatch::set_edge(int edge)
262 {
263         gui->edge = edge;
264         FloatAuto *fade_auto = mwindow->get_float_auto(gui, AUTOMATION_FADE);
265         float v = fade_auto->get_value(edge);
266         update(v);
267 }
268
269 void AKeyFadePatch::set_span(int span)
270 {
271         gui->span = span;
272 }
273
274 void AKeyFadePatch::update(float v)
275 {
276         akey_fade_text->update(v);
277         akey_fade_slider->update(v);
278         gui->update_faders(v);
279 }
280
281 AKeyFadeOK::AKeyFadeOK(AKeyFadePatch *akey_fade_patch, int x, int y, VFrame **images)
282  : BC_Button(x, y, images)
283 {
284         this->akey_fade_patch = akey_fade_patch;
285 }
286
287 int AKeyFadeOK::handle_event()
288 {
289         MWindow *mwindow = akey_fade_patch->mwindow;
290         mwindow->gui->close_keyvalue_popup();
291         return 1;
292 }
293
294 AKeyFadeText::AKeyFadeText(AKeyFadePatch *akey_fade_patch, int x, int y, int w, float v)
295  : BC_TextBox(x, y, w, 1, v, 1, MEDIUMFONT, 2)
296 {
297         this->akey_fade_patch = akey_fade_patch;
298 }
299
300 int AKeyFadeText::handle_event()
301 {
302         float v = atof(get_text());
303         akey_fade_patch->update(v);
304         return get_keypress() != RETURN ? 1 :
305                 akey_fade_patch->akey_fade_ok->handle_event();
306 }
307
308 AKeyFadeSlider::AKeyFadeSlider(AKeyFadePatch *akey_fade_patch, int x, int y, int w, float v)
309  : AFadePatch(akey_fade_patch->gui, x, y, w, v)
310 {
311         this->akey_fade_patch = akey_fade_patch;
312 }
313
314 int AKeyFadeSlider::handle_event()
315 {
316         float v = get_value();
317         akey_fade_patch->update(v);
318         return 1;
319 }
320
321
322 APanPatch::APanPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
323  : BC_Pan(x, y, PAN_RADIUS, MAX_PAN,
324         mwindow->edl->session->audio_channels,
325         mwindow->edl->session->achannel_positions,
326         mwindow->get_pan_auto(patch)->handle_x,
327         mwindow->get_pan_auto(patch)->handle_y,
328         mwindow->get_pan_auto(patch)->values)
329 {
330         this->mwindow = mwindow;
331         this->patch = patch;
332         set_tooltip(_("Pan"));
333 }
334
335 int APanPatch::handle_event()
336 {
337         PanAuto *current;
338         double position = mwindow->edl->local_session->get_selectionstart(1);
339         Autos *pan_autos = patch->atrack->automation->autos[AUTOMATION_PAN];
340         int need_undo = !pan_autos->auto_exists_for_editing(position);
341         mwindow->undo->update_undo_before(_("pan"), need_undo ? 0 : this);
342         current = (PanAuto*)pan_autos->get_auto_for_editing(position);
343         current->handle_x = get_stick_x();
344         current->handle_y = get_stick_y();
345         memcpy(current->values, get_values(), sizeof(float) * mwindow->edl->session->audio_channels);
346         mwindow->undo->update_undo_after(_("pan"), LOAD_AUTOMATION);
347         mwindow->sync_parameters(CHANGE_PARAMS);
348         if( need_undo && mwindow->edl->session->auto_conf->autos[AUTOMATION_PAN] ) {
349                 mwindow->gui->draw_overlays(1);
350         }
351         return 1;
352 }
353
354 AKeyPanPatch::AKeyPanPatch(MWindow *mwindow, APatchGUI *patch)
355  : APanPatch(mwindow, patch, -1,-1)
356 {
357 }
358
359 int AKeyPanPatch::handle_event()
360 {
361         int ret = APanPatch::handle_event();
362         APanPatch *pan = patch->pan;
363         if( pan )
364                 pan->update(get_stick_x(), get_stick_y());
365         return ret;
366 }
367
368
369 AMeterPatch::AMeterPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
370  : BC_Meter(x, y, METER_HORIZ, patch->patchbay->get_w() - xS(10),
371         mwindow->edl->session->min_meter_db, mwindow->edl->session->max_meter_db,
372         mwindow->edl->session->meter_format, 0, -1)
373 {
374         this->mwindow = mwindow;
375         this->patch = patch;
376         set_delays(TRACKING_RATE * 10, TRACKING_RATE);
377 }
378
379 int AMeterPatch::button_press_event()
380 {
381         if( cursor_inside() && is_event_win() && get_buttonpress() == 1 ) {
382                 mwindow->reset_meters();
383                 return 1;
384         }
385
386         return 0;
387 }
388
389 AMixPatch::AMixPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
390  : MixPatch(mwindow, patch, x, y)
391 {
392         set_tooltip(_("Mixer"));
393 // *** CONTEXT_HELP ***
394         context_help_set_keyword("Recover Mixer Windows");
395 }
396
397 AMixPatch::~AMixPatch()
398 {
399 }
400
401 AKeyPatchAutoEdge::AKeyPatchAutoEdge(MWindow *mwindow,
402                 AKeyFadePatch *patch, int x, int y)
403  : BC_Toggle(x, y, mwindow->theme->get_image_set("bump_edge"),
404                 patch->gui->edge,_("Edge"))
405 {
406         this->mwindow = mwindow;
407         this->patch = patch;
408         set_tooltip(_("Bump uses left edge"));
409 }
410
411 int AKeyPatchAutoEdge::handle_event()
412 {
413         patch->set_edge(get_value());
414         return 1;
415 }
416
417 AKeyPatchAutoSpan::AKeyPatchAutoSpan(MWindow *mwindow,
418                 AKeyFadePatch *patch, int x, int y)
419  :  BC_Toggle(x, y, mwindow->theme->get_image_set("bump_span"),
420                 patch->gui->span,_("Span"))
421 {
422         this->mwindow = mwindow;
423         this->patch = patch;
424         set_tooltip(_("Bump spans to next"));
425 }
426
427 int AKeyPatchAutoSpan::handle_event()
428 {
429         patch->set_span(get_value());
430         return 1;
431 }
432