cinelerra-5.1/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                 mwindow->gui->draw_overlays(1);
 390                 return 1;
 391         }
 392         return 0;
 393 }
 394
 395 int RecordPatch::button_release_event()
 396 {
 397         int result = BC_Toggle::button_release_event();
 398         if(patch->patchbay->drag_operation == Tracks::RECORD)
 399         {
 400                 mwindow->undo->update_undo_after(_("record patch"), LOAD_PATCHES);
 401                 patch->patchbay->drag_operation = Tracks::NONE;
 402         }
 403         return result;
 404 }
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416 GangPatch::GangPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 417  : BC_Toggle(x, y,
 418                 mwindow->theme->get_image_set("gangpatch_data"),
 419                 patch->track->gang,
 420                 "",
 421                 0,
 422                 0,
 423                 0)
 424 {
 425         this->mwindow = mwindow;
 426         this->patch = patch;
 427         set_tooltip(_("Gang faders"));
 428         set_select_drag(1);
 429 }
 430
 431 int GangPatch::button_press_event()
 432 {
 433         if(is_event_win() && get_buttonpress() == 1)
 434         {
 435                 mwindow->undo->update_undo_before();
 436                 set_status(BC_Toggle::TOGGLE_DOWN);
 437                 update(!get_value());
 438                 patch->toggle_behavior(Tracks::GANG,
 439                         get_value(),
 440                         this,
 441                         &patch->track->gang);
 442                 return 1;
 443         }
 444         return 0;
 445 }
 446
 447 int GangPatch::button_release_event()
 448 {
 449         int result = BC_Toggle::button_release_event();
 450         if(patch->patchbay->drag_operation == Tracks::GANG)
 451         {
 452                 mwindow->undo->update_undo_after(_("gang patch"), LOAD_PATCHES);
 453                 patch->patchbay->drag_operation = Tracks::NONE;
 454         }
 455         return result;
 456 }
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468 DrawPatch::DrawPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 469  : BC_Toggle(x, y,
 470                 mwindow->theme->get_image_set("drawpatch_data"),
 471                 patch->track->draw,
 472                 "",
 473                 0,
 474                 0,
 475                 0)
 476 {
 477         this->mwindow = mwindow;
 478         this->patch = patch;
 479         set_tooltip(_("Draw media"));
 480         set_select_drag(1);
 481 }
 482
 483 int DrawPatch::button_press_event()
 484 {
 485         if(is_event_win() && get_buttonpress() == 1)
 486         {
 487                 mwindow->undo->update_undo_before();
 488                 set_status(BC_Toggle::TOGGLE_DOWN);
 489                 update(!get_value());
 490                 patch->toggle_behavior(Tracks::DRAW,
 491                         get_value(),
 492                         this,
 493                         &patch->track->draw);
 494                 return 1;
 495         }
 496         return 0;
 497 }
 498
 499 int DrawPatch::button_release_event()
 500 {
 501         int result = BC_Toggle::button_release_event();
 502         if(patch->patchbay->drag_operation == Tracks::DRAW)
 503         {
 504                 mwindow->undo->update_undo_after(_("draw patch"), LOAD_PATCHES);
 505                 patch->patchbay->drag_operation = Tracks::NONE;
 506         }
 507         return result;
 508 }
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519 MutePatch::MutePatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 520  : BC_Toggle(x, y,
 521                 mwindow->theme->get_image_set("mutepatch_data"),
 522                 mwindow->get_int_auto(patch, AUTOMATION_MUTE)->value,
 523                 "",
 524                 0,
 525                 0,
 526                 0)
 527 {
 528         this->mwindow = mwindow;
 529         this->patch = patch;
 530         set_tooltip(_("Don't send to output"));
 531         set_select_drag(1);
 532 }
 533
 534 int MutePatch::button_press_event()
 535 {
 536         if(is_event_win() && get_buttonpress() == 1)
 537         {
 538                 mwindow->undo->update_undo_before();
 539                 set_status(BC_Toggle::TOGGLE_DOWN);
 540                 update(!get_value());
 541                 IntAuto *current;
 542                 double position = mwindow->edl->local_session->get_selectionstart(1);
 543                 Autos *mute_autos = patch->track->automation->autos[AUTOMATION_MUTE];
 544
 545
 546                 current = (IntAuto*)mute_autos->get_auto_for_editing(position);
 547                 current->value = get_value();
 548
 549                 patch->toggle_behavior(Tracks::MUTE,
 550                         get_value(),
 551                         this,
 552                         &current->value);
 553
 554
 555
 556                 if(mwindow->edl->session->auto_conf->autos[AUTOMATION_MUTE])
 557                 {
 558                         mwindow->gui->draw_overlays(1);
 559                 }
 560                 return 1;
 561         }
 562         return 0;
 563 }
 564
 565 int MutePatch::button_release_event()
 566 {
 567         int result = BC_Toggle::button_release_event();
 568         if(patch->patchbay->drag_operation == Tracks::MUTE)
 569         {
 570                 mwindow->undo->update_undo_after(_("mute patch"), LOAD_PATCHES);
 571                 patch->patchbay->drag_operation = Tracks::NONE;
 572         }
 573         return result;
 574 }
 575
 576
 577
 578 ExpandPatch::ExpandPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 579  : BC_Toggle(x,
 580                 y,
 581                 mwindow->theme->get_image_set("expandpatch_data"),
 582                 patch->track->expand_view,
 583                 "",
 584                 0,
 585                 0,
 586                 0)
 587 {
 588         this->mwindow = mwindow;
 589         this->patch = patch;
 590         set_select_drag(1);
 591 }
 592
 593 int ExpandPatch::button_press_event()
 594 {
 595         if(is_event_win() && get_buttonpress() == 1)
 596         {
 597                 mwindow->undo->update_undo_before();
 598                 set_status(BC_Toggle::TOGGLE_DOWN);
 599                 update(!get_value());
 600                 patch->toggle_behavior(Tracks::EXPAND,
 601                         get_value(),
 602                         this,
 603                         &patch->track->expand_view);
 604                 mwindow->edl->tracks->update_y_pixels(mwindow->theme);
 605                 mwindow->gui->draw_trackmovement();
 606                 return 1;
 607         }
 608         return 0;
 609 }
 610
 611 int ExpandPatch::button_release_event()
 612 {
 613         int result = BC_Toggle::button_release_event();
 614         if(patch->patchbay->drag_operation == Tracks::EXPAND)
 615         {
 616                 mwindow->undo->update_undo_after(_("expand patch"), LOAD_PATCHES);
 617                 patch->patchbay->drag_operation = Tracks::NONE;
 618         }
 619         return result;
 620 }
 621
 622
 623 TitlePatch::TitlePatch(MWindow *mwindow, PatchGUI *patch, int x, int y, int w)
 624  : BC_TextBox(x, y, w, 1, patch->track->title, 1, MEDIUMFONT, 1)
 625 {
 626         this->mwindow = mwindow;
 627         this->patch = patch;
 628         set_back_color(patch->track->record ?
 629                         get_resources()->text_background :
 630                         get_resources()->text_background_disarmed);
 631 }
 632
 633 void TitlePatch::update(const char *text)
 634 {
 635         set_back_color(patch->track->record ?
 636                         get_resources()->text_background :
 637                         get_resources()->text_background_disarmed);
 638         BC_TextBox::update(text);
 639 }
 640
 641 int TitlePatch::handle_event()
 642 {
 643         mwindow->undo->update_undo_before(_("track title"), this);
 644         strcpy(patch->track->title, get_text());
 645         mwindow->update_plugin_titles();
 646         mwindow->gui->draw_overlays(1);
 647         mwindow->undo->update_undo_after(_("track title"), LOAD_PATCHES);
 648         return 1;
 649 }
 650
 651
 652 NudgePatch::NudgePatch(MWindow *mwindow,
 653         PatchGUI *patch,
 654         int x,
 655         int y,
 656         int w)
 657  : BC_TextBox(x,
 658         y,
 659         w,
 660         1,
 661         patch->calculate_nudge_text(0))
 662 {
 663         this->mwindow = mwindow;
 664         this->patch = patch;
 665         set_tooltip(_("Nudge"));
 666 }
 667
 668 int NudgePatch::handle_event()
 669 {
 670         set_value(patch->calculate_nudge(get_text()));
 671         return 1;
 672 }
 673
 674 void NudgePatch::set_value(int64_t value)
 675 {
 676         mwindow->undo->update_undo_before(_("nudge."), this);
 677         patch->track->nudge = value;
 678
 679         if(patch->track->gang && patch->track->record)
 680                 patch->patchbay->synchronize_nudge(patch->track->nudge, patch->track);
 681
 682         mwindow->undo->update_undo_after(_("nudge."), LOAD_PATCHES);
 683
 684         mwindow->gui->unlock_window();
 685         if(patch->track->data_type == TRACK_VIDEO)
 686                 mwindow->restart_brender();
 687         mwindow->sync_parameters(CHANGE_PARAMS);
 688         mwindow->gui->lock_window("NudgePatch::handle_event 2");
 689
 690         mwindow->session->changes_made = 1;
 691 }
 692
 693
 694 int NudgePatch::button_press_event()
 695 {
 696         int result = 0;
 697
 698         if(is_event_win() && cursor_inside())
 699         {
 700                 if(get_buttonpress() == 4)
 701                 {
 702                         int value = patch->calculate_nudge(get_text());
 703                         value += calculate_increment();
 704                         set_value(value);
 705                         update();
 706                         result = 1;
 707                 }
 708                 else
 709                 if(get_buttonpress() == 5)
 710                 {
 711                         int value = patch->calculate_nudge(get_text());
 712                         value -= calculate_increment();
 713                         set_value(value);
 714                         update();
 715                         result = 1;
 716                 }
 717                 else
 718                 if(get_buttonpress() == 3)
 719                 {
 720                         patch->patchbay->nudge_popup->activate_menu(patch);
 721                         result = 1;
 722                 }
 723         }
 724
 725         if(!result)
 726                 return BC_TextBox::button_press_event();
 727         else
 728                 return result;
 729 }
 730
 731 int64_t NudgePatch::calculate_increment()
 732 {
 733         if(patch->track->data_type == TRACK_AUDIO)
 734         {
 735                 return (int64_t)ceil(patch->track->edl->session->sample_rate / 10.0);
 736         }
 737         else
 738         {
 739                 return (int64_t)ceil(1.0 / patch->track->edl->session->frame_rate);
 740         }
 741 }
 742
 743 void NudgePatch::update()
 744 {
 745         int changed;
 746         char *string = patch->calculate_nudge_text(&changed);
 747         if(changed)
 748                 BC_TextBox::update(string);
 749 }
 750
 751
 752 MixPatch::MixPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
 753  : BC_Toggle(x, y, mwindow->theme->get_image_set("mixpatch_data"),
 754         patch->mixer, "", 0, 0, 0)
 755 {
 756         this->mwindow = mwindow;
 757         this->patch = patch;
 758 }
 759
 760 MixPatch::~MixPatch()
 761 {
 762 }
 763
 764 int MixPatch::handle_event()
 765 {
 766         int v = patch->track ? get_value() : 0;
 767         if( patch->mixer != v ) {
 768                 if( patch->track )
 769                         mwindow->gui->update_mixers(patch->track, v);
 770                 else
 771                         update(v);
 772                 mwindow->update_mixer_tracks();
 773         }
 774         return 1;
 775 }
 776
 777 void MixPatch::update(int v)
 778 {
 779         patch->mixer = v;
 780         BC_Toggle::update(v);
 781 }
 782