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                         unit_position = atrack->to_units(unit_position, 0);
 108                         FloatAutos *ptr = (FloatAutos*)atrack->automation->autos[AUTOMATION_FADE];
 109                         float value = ptr->get_value((long)unit_position, 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() - 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() + 10;
 166                 patchbay->add_subwindow(pan = new APanPatch(mwindow, this, x1+x, y1+y));
 167                 x1 += pan->get_w() + 20;
 168                 patchbay->add_subwindow(nudge = new NudgePatch(mwindow, this, x1+x, y1+y,
 169                                 patchbay->get_w() - x1-x - 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
 186         mwindow->undo->update_undo_before(_("fade"), need_undo ? 0 : this);
 187         FloatAuto *current = (FloatAuto*)fade_autos->get_auto_for_editing(position);
 188         float change = v - current->get_value();
 189         current->set_value(v);
 190
 191         if( track->gang && track->record )
 192                 patchbay->synchronize_faders(change, TRACK_AUDIO, track);
 193         mwindow->undo->update_undo_after(_("fade"), LOAD_AUTOMATION);
 194         change_source = 0;
 195
 196         mwindow->sync_parameters(CHANGE_PARAMS);
 197
 198         if( mwindow->edl->session->auto_conf->autos[AUTOMATION_FADE] ) {
 199                 mwindow->gui->draw_overlays(1);
 200         }
 201 }
 202
 203 AFadePatch::AFadePatch(APatchGUI *patch, int x, int y, int w, float v)
 204  : BC_FSlider(x, y, 0, w, w,
 205         patch->mwindow->edl->local_session->automation_mins[AUTOGROUPTYPE_AUDIO_FADE],
 206         patch->mwindow->edl->local_session->automation_maxs[AUTOGROUPTYPE_AUDIO_FADE],
 207         v)
 208 {
 209         this->patch = patch;
 210 }
 211
 212
 213 int AFadePatch::handle_event()
 214 {
 215         if( shift_down() ) {
 216                 update(0.0);
 217                 set_tooltip(get_caption());
 218         }
 219         patch->update_faders(get_value());
 220         return 1;
 221 }
 222
 223 AKeyFadePatch::AKeyFadePatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
 224  : BC_SubWindow(x,y, 200,20, GWindowGUI::auto_colors[AUTOMATION_FADE])
 225 {
 226         this->mwindow = mwindow;
 227         this->patch = patch;
 228 }
 229
 230 void AKeyFadePatch::create_objects()
 231 {
 232         int x = 0, y = 0;
 233         float v = mwindow->get_float_auto(patch, AUTOMATION_FADE)->get_value();
 234         add_subwindow(akey_fade_text = new AKeyFadeText(this, x, y, 64, v));
 235         x += akey_fade_text->get_w();
 236         VFrame **lok_images = mwindow->theme->get_image_set("lok");
 237         int w1 = get_w() - x - lok_images[0]->get_w();
 238         add_subwindow(akey_fade_slider = new AKeyFadeSlider(this, x, y, w1, v));
 239         x += akey_fade_slider->get_w();
 240         add_subwindow(akey_fade_ok = new AKeyFadeOK(this, x, y, lok_images));
 241         activate();
 242         show_window();
 243 }
 244
 245 void AKeyFadePatch::update(float v)
 246 {
 247         akey_fade_text->update(v);
 248         akey_fade_slider->update(v);
 249         patch->update_faders(v);
 250 }
 251
 252 AKeyFadeOK::AKeyFadeOK(AKeyFadePatch *akey_fade_patch, int x, int y, VFrame **images)
 253  : BC_Button(x, y, images)
 254 {
 255         this->akey_fade_patch = akey_fade_patch;
 256 }
 257
 258 int AKeyFadeOK::handle_event()
 259 {
 260         MWindowGUI *mgui = akey_fade_patch->mwindow->gui;
 261         delete mgui->keyvalue_popup;
 262         mgui->keyvalue_popup = 0;
 263         return 1;
 264 }
 265
 266 AKeyFadeText::AKeyFadeText(AKeyFadePatch *akey_fade_patch, int x, int y, int w, float v)
 267  : BC_TextBox(x, y, w, 1, v, 1, MEDIUMFONT, 2)
 268 {
 269         this->akey_fade_patch = akey_fade_patch;
 270 }
 271
 272 int AKeyFadeText::handle_event()
 273 {
 274         float v = atof(get_text());
 275         akey_fade_patch->update(v);
 276         return get_keypress() != RETURN ? 1 :
 277                 akey_fade_patch->akey_fade_ok->handle_event();
 278 }
 279
 280 AKeyFadeSlider::AKeyFadeSlider(AKeyFadePatch *akey_fade_patch, int x, int y, int w, float v)
 281  : AFadePatch(akey_fade_patch->patch, x, y, w, v)
 282 {
 283         this->akey_fade_patch = akey_fade_patch;
 284 }
 285
 286 int AKeyFadeSlider::handle_event()
 287 {
 288         float v = get_value();
 289         akey_fade_patch->update(v);
 290         return 1;
 291 }
 292
 293
 294 APanPatch::APanPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
 295  : BC_Pan(x, y, PAN_RADIUS, MAX_PAN,
 296         mwindow->edl->session->audio_channels,
 297         mwindow->edl->session->achannel_positions,
 298         mwindow->get_pan_auto(patch)->handle_x,
 299         mwindow->get_pan_auto(patch)->handle_y,
 300         mwindow->get_pan_auto(patch)->values)
 301 {
 302         this->mwindow = mwindow;
 303         this->patch = patch;
 304         set_tooltip(_("Pan"));
 305 }
 306
 307 int APanPatch::handle_event()
 308 {
 309         PanAuto *current;
 310         double position = mwindow->edl->local_session->get_selectionstart(1);
 311         Autos *pan_autos = patch->atrack->automation->autos[AUTOMATION_PAN];
 312         int need_undo = !pan_autos->auto_exists_for_editing(position);
 313
 314         mwindow->undo->update_undo_before(_("pan"), need_undo ? 0 : this);
 315
 316         current = (PanAuto*)pan_autos->get_auto_for_editing(position);
 317
 318         current->handle_x = get_stick_x();
 319         current->handle_y = get_stick_y();
 320         memcpy(current->values, get_values(), sizeof(float) * mwindow->edl->session->audio_channels);
 321
 322         mwindow->undo->update_undo_after(_("pan"), LOAD_AUTOMATION);
 323
 324         mwindow->sync_parameters(CHANGE_PARAMS);
 325
 326         if( need_undo && mwindow->edl->session->auto_conf->autos[AUTOMATION_PAN] ) {
 327                 mwindow->gui->draw_overlays(1);
 328         }
 329         return 1;
 330 }
 331
 332 AKeyPanPatch::AKeyPanPatch(MWindow *mwindow, APatchGUI *patch)
 333  : APanPatch(mwindow, patch, -1,-1)
 334 {
 335 }
 336
 337 int AKeyPanPatch::handle_event()
 338 {
 339         int ret = APanPatch::handle_event();
 340         APanPatch *pan = patch->pan;
 341         if( pan )
 342                 pan->update(get_stick_x(), get_stick_y());
 343         return ret;
 344 }
 345
 346
 347 AMeterPatch::AMeterPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
 348  : BC_Meter(x, y, METER_HORIZ, patch->patchbay->get_w() - 10,
 349         mwindow->edl->session->min_meter_db, mwindow->edl->session->max_meter_db,
 350         mwindow->edl->session->meter_format, 0, -1)
 351 {
 352         this->mwindow = mwindow;
 353         this->patch = patch;
 354         set_delays(TRACKING_RATE * 10,
 355                         TRACKING_RATE);
 356 }
 357
 358 int AMeterPatch::button_press_event()
 359 {
 360         if( cursor_inside() && is_event_win() && get_buttonpress() == 1 ) {
 361                 mwindow->reset_meters();
 362                 return 1;
 363         }
 364
 365         return 0;
 366 }
 367
 368 AMixPatch::AMixPatch(MWindow *mwindow, APatchGUI *patch, int x, int y)
 369  : MixPatch(mwindow, patch, x, y)
 370 {
 371         set_tooltip(_("Mixer"));
 372 }
 373
 374 AMixPatch::~AMixPatch()
 375 {
 376 }
 377